diff --git a/.appveyor.yml b/.appveyor.yml
new file mode 100644
index 000000000..a58675259
--- /dev/null
+++ b/.appveyor.yml
@@ -0,0 +1,162 @@
+image:
+  - MacOS
+  - Visual Studio 2015
+  - Visual Studio 2019
+  - Ubuntu
+
+build: off
+
+init:
+  - git config --global core.autocrlf input
+
+for:
+-
+  matrix:
+    only:
+      - image: Ubuntu
+
+  branches:
+    only:
+      - build-graal
+  artifacts:
+  - path: client/target/bin/sbtn
+    name: sbtn
+
+  install:
+  - curl -sL https://github.com/sbt/sbt/releases/download/v1.3.10/sbt-1.3.10.tgz > ~/sbt-bin.tgz
+  - mkdir ~/sbt
+  - tar -xf ~/sbt-bin.tgz --directory ~/sbt
+  - curl -sL https://raw.githubusercontent.com/shyiko/jabba/0.11.0/install.sh | bash && . ~/.jabba/jabba.sh
+  - jabba install adopt@1.8.0-275
+  - jabba use adopt@1.8.0-275
+  - curl -sL https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-20.1.0/graalvm-ce-java8-linux-amd64-20.1.0.tar.gz > graalvm.tar.gz
+  - tar -xf graalvm.tar.gz
+  - export PATH="~/sbt/sbt/bin:$PATH"
+  - export PATH="$PATH:~/.jabba/jdk/adopt@1.8.0-275/bin"
+  - export JAVA_HOME="~/.jabba/jdk/adopt@1.8.0-275"
+
+  test_script:
+    - export PATH="$PATH:~/.jabba/jdk/adopt@1.8.0-275/bin"
+    - export PATH="$PATH:graalvm-ce-java8-20.1.0/bin"
+    - gu install native-image
+    - sbt "-Dsbt.io.virtual=false" "-Dsbt.native-image=$(pwd)/graalvm-ce-java8-20.1.0/bin/native-image" "sbtClientProj/buildNativeThinClient"
+
+-
+  matrix:
+    only:
+      - image: MacOS
+
+  branches:
+    only:
+      - build-graal
+  artifacts:
+  - path: client/target/bin/sbtn
+    name: mac-native-sbt-client
+
+  install:
+  - curl -sL https://github.com/sbt/sbt/releases/download/v1.3.10/sbt-1.3.10.tgz > ~/sbt-bin.tgz
+  - mkdir ~/sbt
+  - tar -xf ~/sbt-bin.tgz --directory ~/sbt
+  - curl -sL https://raw.githubusercontent.com/shyiko/jabba/0.11.0/install.sh | bash && . ~/.jabba/jabba.sh
+  - jabba install adopt@1.8.0-222
+  - jabba use adopt@1.8.0-222
+  - curl -sL https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-20.1.0/graalvm-ce-java8-darwin-amd64-20.1.0.tar.gz > graalvm.tar.gz
+  - tar -xf graalvm.tar.gz
+  - export PATH="~/sbt/sbt/bin:$PATH"
+  - export PATH="$PATH:~/.jabba/jdk/adopt@1.8.0-222/bin"
+  - export JAVA_HOME="~/.jabba/jdk/adopt@1.8.0-222"
+
+  test_script:
+    - export PATH="$PATH:~/.jabba/jdk/adopt@1.8.0-222/Contents/Home/bin"
+    - export PATH="$PATH:graalvm-ce-java8-20.1.0/Contents/Home/bin"
+    - gu install native-image
+    - sbt "-Dsbt.io.virtual=false" "-Dsbt.native-image=$(pwd)/graalvm-ce-java8-20.1.0/Contents/Home/bin/native-image" "sbtClientProj/buildNativeThinClient"
+
+-
+  matrix:
+    only:
+      - image: Visual Studio 2015
+  branches:
+    only:
+      - build-graal
+
+  artifacts:
+  - path: client\target\bin\sbtn.exe
+    name: sbtn.exe
+  install:
+    - cinst adoptopenjdk8 -params 'installdir=C:\\jdk8'
+    - SET CI=true
+      #- choco install windows-sdk-7.1 kb2519277
+    - call "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd"
+
+    - ps: |
+        Add-Type -AssemblyName System.IO.Compression.FileSystem
+        if (!(Test-Path -Path "C:\sbt" )) {
+          (new-object System.Net.WebClient).DownloadFile(
+            'https://github.com/sbt/sbt/releases/download/v1.3.10/sbt-1.3.10.zip',
+            'C:\sbt-bin.zip'
+          )
+          [System.IO.Compression.ZipFile]::ExtractToDirectory("C:\sbt-bin.zip", "C:\sbt")
+        }
+        if (!(Test-Path -Path "C:\graalvm-ce-java8-20.2.0-dev" )) {
+          (new-object System.Net.WebClient).DownloadFile(
+            'https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-20.1.0/graalvm-ce-java8-windows-amd64-20.1.0.zip',
+            'C:\graalvm-ce-java8-20.1.0.zip'
+          )
+          [System.IO.Compression.ZipFile]::ExtractToDirectory("C:\graalvm-ce-java8-20.1.0.zip", "C:\")
+        }
+        if (!(Test-Path -Path "C:\zulu-jdk7" )) {
+          (new-object System.Net.WebClient).DownloadFile(
+            'https://cdn.azul.com/zulu/bin/zulu7.38.0.11-ca-jdk7.0.262-win_x64.zip',
+            'C:\zulu-jdk7.zip'
+          )
+          [System.IO.Compression.ZipFile]::ExtractToDirectory("C:\zulu-jdk7.zip", "C:\")
+        }
+    - SET PATH=C:\graalvm-ce-java8-20.1.0\bin;%PATH%
+    - SET PATH=C:\sbt\sbt\bin;%PATH%
+    - SET JAVA_HOME=C:\jdk8
+    - gu install native-image
+    - rm .sbtopts
+
+  cache:
+    - '%USERPROFILE%\.ivy2\cache'
+    - '%LOCALAPPDATA%\Coursier\Cache\v1'
+    - '%USERPROFILE%\.sbt'
+
+  test_script:
+    - sbt "-Dsbt.io.virtual=false" "-Dsbt.native-image=C:\graalvm-ce-java8-20.1.0\bin\native-image.cmd" "sbtClientProj/buildNativeThinClient"
+-
+  matrix:
+    only:
+      - image: Visual Studio 2019
+  branches:
+    except:
+      - build-graal
+  install:
+    - cinst adoptopenjdk8 -params 'installdir=C:\\jdk8'
+    - SET JAVA_HOME=C:\jdk8
+    - SET PATH=C:\jdk8\bin;%PATH%
+    - SET CI=true
+
+    - ps: |
+        Add-Type -AssemblyName System.IO.Compression.FileSystem
+        if (!(Test-Path -Path "C:\sbt" )) {
+          (new-object System.Net.WebClient).DownloadFile(
+            'https://github.com/sbt/sbt/releases/download/v1.3.10/sbt-1.3.10.zip',
+            'C:\sbt-bin.zip'
+          )
+          [System.IO.Compression.ZipFile]::ExtractToDirectory("C:\sbt-bin.zip", "C:\sbt")
+        }
+    - SET PATH=C:\sbt\sbt\bin;%PATH%
+    - SET SBT_OPTS=-Xmx4g -Dsbt.supershell=never -Dfile.encoding=UTF8
+    - rm .sbtopts
+
+  cache:
+    - '%USERPROFILE%\.ivy2\cache'
+    - '%LOCALAPPDATA%\Coursier\Cache\v1'
+    - '%USERPROFILE%\.sbt'
+
+  test_script:
+    # The server tests often fail in CI when run together so just run a single test to ensure
+    # that the thin client works on windows
+    - sbt "-Dsbt.io.virtual=false" "scripted actions/* reporter/source-mapper classloader-cache/* nio/* watch/*" "serverTestProj/testOnly testpkg.ClientTest"
diff --git a/.gitattributes b/.gitattributes
index a5d9c6403..11d44bd7f 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,7 +1,4 @@
-# Set default behaviour, in case users don't have core.autocrlf set.
-* text=auto
-
-# Explicitly declare text files we want to always be normalized and converted 
-# to native line endings on checkout.
-*.scala text
-*.java text
+# Exclude contraband generated files from diff (by default - you can see it if you want)
+**/contraband-scala/**/* -diff merge=ours
+**/contraband-scala/**/* linguist-generated=true
+**/contraband-scala/**/* diff
diff --git a/.github/ISSUE_TEMPLATE/---bug-report.md b/.github/ISSUE_TEMPLATE/---bug-report.md
new file mode 100644
index 000000000..c2f43e7b9
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/---bug-report.md
@@ -0,0 +1,22 @@
+---
+name: "\U0001F41B Bug report"
+about: Create a report to help us improve
+title: ''
+labels: Bug
+assignees: ''
+
+---
+
+## steps
+
+<!-- Describe exact steps to reproduce your problems on our computer, including sbt version and build.sbt  -->
+
+## problem
+
+<!-- Next, describe the problem, or what you think is the problem. -->
+
+## expectation
+
+<!-- Describe what you think should've happened. -->
+
+## notes
diff --git a/.github/ISSUE_TEMPLATE/--feature-request.md b/.github/ISSUE_TEMPLATE/--feature-request.md
new file mode 100644
index 000000000..5ef8d3776
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/--feature-request.md
@@ -0,0 +1,10 @@
+---
+name: "\U0001F389 Feature request"
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Please use https://discuss.lightbend.com/c/tooling including a specific user story instead of posting them to the issue tracker.
diff --git a/.github/ISSUE_TEMPLATE/--question.md b/.github/ISSUE_TEMPLATE/--question.md
new file mode 100644
index 000000000..8d1dd089f
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/--question.md
@@ -0,0 +1,10 @@
+---
+name: "❓ Question"
+about: Please use https://stackoverflow.com/questions/tagged/sbt for questions
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Please use https://stackoverflow.com/questions/tagged/sbt for questions instead of posting them to the issue tracker.
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..5ace4600a
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 000000000..ca77b2d48
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,108 @@
+name: CI
+on:
+  pull_request:
+  push:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            java: 11
+            jobtype: 1
+          - os: ubuntu-latest
+            java: 11
+            jobtype: 2
+          - os: ubuntu-latest
+            java: 11
+            jobtype: 3
+          - os: ubuntu-latest
+            java: 11
+            jobtype: 4
+          - os: ubuntu-latest
+            java: 11
+            jobtype: 5
+          - os: ubuntu-latest
+            java: 8
+            jobtype: 6
+    runs-on: ${{ matrix.os }}
+    env:
+      JAVA_OPTS: -Xms800M -Xmx2G -Xss6M -XX:ReservedCodeCacheSize=128M -server -Dsbt.io.virtual=false -Dfile.encoding=UTF-8
+      SCALA_212: 2.12.13
+      SCALA_213: 2.13.3
+      UTIL_TESTS: utilCache/test;utilControl/test;utilInterface/test;utilLogging/test;utilPosition/test;utilRelation/test;utilScripted/test;utilTracking/test
+      SBT_LOCAL: false
+    steps:
+    - name: Checkout sbt/sbt
+      uses: actions/checkout@v2
+    - name: Checkout sbt/io
+      uses: actions/checkout@v2
+      with:
+        repository: sbt/io
+        ref: develop
+        path: io
+    - name: Checkout sbt/librarymanagement
+      uses: actions/checkout@v2
+      with:
+        repository: sbt/librarymanagement
+        ref: develop
+        path: librarymanagement
+    - name: Checkout sbt/zinc
+      uses: actions/checkout@v2
+      with:
+        repository: sbt/zinc
+        ref: develop
+        path: zinc
+    - name: Setup
+      uses: olafurpg/setup-scala@v10
+      with:
+        java-version: "adopt@1.${{ matrix.java }}"
+    - name: Coursier cache
+      uses: coursier/cache-action@v6
+    - name: Cache sbt
+      uses: actions/cache@v2.1.3
+      with:
+        path: ~/.sbt
+        key: ${{ runner.os }}-sbt-cache-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }}
+    - name: Build and test
+      run: |
+        rm -rf "$HOME/.sbt/scripted/" || true
+        case ${{ matrix.jobtype }} in
+          1)
+            sbt -v "mimaReportBinaryIssues ; javafmtCheck ; Test / javafmtCheck; scalafmtCheckAll ; scalafmtSbtCheck; serverTestProj/scalafmtCheckAll; headerCheck ;test:headerCheck ;whitesourceOnPush ;test:compile; publishLocal; test; serverTestProj/test; doc; $UTIL_TESTS; ++$SCALA_213; $UTIL_TESTS"
+            ;;
+          2)
+            sbt -v "scripted actions/* apiinfo/* compiler-project/* ivy-deps-management/* reporter/* tests/* watch/* classloader-cache/* package/*"
+            ;;
+          3)
+            sbt -v "dependencyTreeProj/publishLocal; scripted dependency-graph/* dependency-management/* plugins/* project-load/* java/* run/* nio/*"
+            ;;
+          4)
+            sbt -v "repoOverrideTest:scripted dependency-management/*; scripted source-dependencies/* project/*"
+            ;;
+          5)
+            sbt -v "++$SCALA_213!; test;"
+            ;;
+          6)
+            # build from fresh IO, LM, and Zinc
+            BUILD_VERSION="1.5.0-SNAPSHOT"
+            cd io
+            sbt -v -Dsbt.build.version=${BUILD_VERSION} +publishLocal
+            cd ../
+            sbt -Dsbtlm.path=$HOME/work/sbt/sbt/librarymanagement -Dsbtzinc.path=$HOME/work/sbt/sbt/zinc -Dsbt.build.version=$BUILD_VERSION -Dsbt.build.fatal=false "+lowerUtils/publishLocal; {librarymanagement}/publishLocal; {zinc}/publishLocal; upperModules/publishLocal"
+            rm -r $(find $HOME/.sbt/boot -name "*-SNAPSHOT") || true
+            sbt -v -Dsbt.version=$BUILD_VERSION "++$SCALA_213; $UTIL_TESTS; ++$SCALA_212; $UTIL_TESTS; scripted actions/* source-dependencies/*1of3 dependency-management/*1of4 java/*"
+            ;;
+          *)
+            echo unknown jobtype
+            exit 1
+        esac
+        rm -rf "$HOME/.sbt/scripted/" || true
+        rm -rf "$HOME/.ivy2/local" || true
+        rm -r $(find $HOME/.sbt/boot -name "*-SNAPSHOT") || true
+        find $HOME/Library/Caches/Coursier/v1        -name "ivydata-*.properties" -delete || true
+        find $HOME/.ivy2/cache                       -name "ivydata-*.properties" -delete || true
+        find $HOME/.cache/coursier/v1                -name "ivydata-*.properties" -delete || true
+        find $HOME/.sbt                              -name "*.lock"               -delete || true
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
new file mode 100644
index 000000000..7adaddb2a
--- /dev/null
+++ b/.github/workflows/nightly.yml
@@ -0,0 +1,63 @@
+name: Nightly
+on:
+  schedule:
+    # 08:00 UTC = 03:00 EST
+    - cron:  '0 8 * * *'
+
+jobs:
+  deploy:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            java: 8
+    runs-on: ${{ matrix.os }}
+    env:
+      JAVA_OPTS: -Xms800M -Xmx800M -Xss6M -XX:ReservedCodeCacheSize=128M -server -Dsbt.io.virtual=false -Dfile.encoding=UTF-8
+    steps:
+    - name: Checkout sbt/sbt
+      uses: actions/checkout@v2
+    - name: Checkout sbt/io
+      uses: actions/checkout@v2
+      with:
+        repository: sbt/io
+        ref: develop
+        path: io
+    - name: Checkout sbt/librarymanagement
+      uses: actions/checkout@v2
+      with:
+        repository: sbt/librarymanagement
+        ref: develop
+        path: librarymanagement
+    - name: Checkout sbt/zinc
+      uses: actions/checkout@v2
+      with:
+        repository: sbt/zinc
+        ref: develop
+        path: zinc
+    - name: Setup
+      uses: olafurpg/setup-scala@v10
+      with:
+        java-version: "adopt@1.${{ matrix.java }}"
+    - name: Coursier cache
+      uses: coursier/cache-action@v6
+    - name: Build and deploy
+      run: |
+        # build from fresh IO, LM, and Zinc
+        TIMESTAMP=$(TZ=UTC date +%Y%m%dT%H%M%S)
+        export BUILD_VERSION="1.5.0-bin-${TIMESTAMP}"
+        cd io
+        sbt -v +publish
+        cd ../
+        sbt -Dsbtlm.path=$HOME/work/sbt/sbt/librarymanagement -Dsbtzinc.path=$HOME/work/sbt/sbt/zinc -Dsbt.build.fatal=false "+lowerUtils/publish; {librarymanagement}/publish; {zinc}/publish; upperModules/publish; bundledLauncherProj/publish"
+        rm -rf "$HOME/.ivy2/local" || true
+        rm -r $(find $HOME/.sbt/boot -name "*-SNAPSHOT") || true
+        find $HOME/Library/Caches/Coursier/v1        -name "ivydata-*.properties" -delete || true
+        find $HOME/.ivy2/cache                       -name "ivydata-*.properties" -delete || true
+        find $HOME/.cache/coursier/v1                -name "ivydata-*.properties" -delete || true
+        find $HOME/.sbt                              -name "*.lock"               -delete || true
+      env:
+        BINTRAY_USER: ${{ secrets.BINTRAY_USER }}
+        BINTRAY_PASS: ${{ secrets.BINTRAY_PASS }}
+        BINTRAY_REPOSITORY: maven-snapshots
+        BINTRAY_PACKAGE: sbt
diff --git a/.gitignore b/.gitignore
index e762de7f9..4901fa3a4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,14 @@
 target/
 __pycache__
+out
+node_modules
+vscode-sbt-scala/client/server
+npm-debug.log
+*.vsix
+!sbt/src/server-test/completions/target
+.big
+.idea
+.bloop
+.metals
+.bsp/
+metals.sbt
diff --git a/.mailmap b/.mailmap
new file mode 100644
index 000000000..dfe6ffc8c
--- /dev/null
+++ b/.mailmap
@@ -0,0 +1,7 @@
+Andrea Peruffo <andrea.peruffo1982@gmail.com>
+Ethan Atkins <github@ethanatkins.com>
+Ethan Atkins <github@ethanatkins.com> <ethan.atkins@gmail.com> 
+Eugene Yokota (eed3si9n) <eed3si9n@gmail.com>
+Jorge Vicente Cantero <jorgevc@fastmail.es>
+Kenji Yoshida (xuwei-k) <6b656e6a69@gmail.com>
+Yasuhiro Tatsuno <mogami@exoego.net>
diff --git a/.sbtopts b/.sbtopts
new file mode 100644
index 000000000..1ca6d0b39
--- /dev/null
+++ b/.sbtopts
@@ -0,0 +1 @@
+-J-Xmx2G
diff --git a/.scalafmt.conf b/.scalafmt.conf
new file mode 100644
index 000000000..213dea496
--- /dev/null
+++ b/.scalafmt.conf
@@ -0,0 +1,23 @@
+version = 2.3.2
+edition = 2019-10
+maxColumn = 100
+project.git = true
+project.excludeFilters = [ "\\Wsbt-test\\W", "\\Winput_sources\\W", "\\Wcontraband-scala\\W" ]
+lineEndings = preserve
+
+# https://docs.scala-lang.org/style/scaladoc.html recommends the JavaDoc style.
+# scala/scala is written that way too https://github.com/scala/scala/blob/v2.12.2/src/library/scala/Predef.scala
+docstrings = JavaDoc
+
+# This also seems more idiomatic to include whitespace in import x.{ yyy }
+spaces.inImportCurlyBraces = true
+
+# This is more idiomatic Scala.
+# https://docs.scala-lang.org/style/indentation.html#methods-with-numerous-arguments
+align.openParenCallSite = false
+align.openParenDefnSite = false
+
+# For better code clarity
+danglingParentheses = true
+
+trailingCommas = preserve
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 20fc55510..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,51 +0,0 @@
-# Use Docker-based container (instead of OpenVZ)
-sudo: false
-
-cache:
-  directories:
-    - $HOME/.ivy2/cache
-    - $HOME/.sbt/boot
-
-language: scala
-
-jdk:
-  - oraclejdk8
-
-matrix:
-  fast_finish: true
-
-env:
-  matrix:
-    - SBT_CMD=";test:compile;scalariformCheck"
-    - SBT_CMD="mimaReportBinaryIssues"
-    - SBT_CMD="safeUnitTests"
-    - SBT_CMD="otherUnitTests"
-    - SBT_CMD="scripted actions/*"
-    - SBT_CMD="scripted apiinfo/*"
-    - SBT_CMD="scripted compiler-project/*"
-    - SBT_CMD="scripted dependency-management/*1of2"
-    - SBT_CMD="scripted dependency-management/*2of2"
-    - SBT_CMD="scripted ivy-deps-management/*"
-    - SBT_CMD="scripted java/*"
-    - SBT_CMD="scripted package/*"
-    - SBT_CMD="scripted project/*1of2"
-    - SBT_CMD="scripted project/*2of2"
-    - SBT_CMD="scripted reporter/*"
-    - SBT_CMD="scripted run/*"
-    - SBT_CMD="scripted source-dependencies/*1of3"
-    - SBT_CMD="scripted source-dependencies/*2of3"
-    - SBT_CMD="scripted source-dependencies/*3of3"
-    - SBT_CMD="scripted tests/*"
-    - SBT_CMD="scripted project-load/*"
-    - SBT_CMD="repoOverrideTest:scripted dependency-management/*"
-
-notifications:
-  email:
-    - sbt-dev-bot@googlegroups.com
-
-script:
-  - sbt -J-XX:ReservedCodeCacheSize=128m "$SBT_CMD"
-
-before_cache:
-  - find $HOME/.ivy2 -name "ivydata-*.properties" -print -delete
-  - find $HOME/.sbt  -name "*.lock"               -print -delete
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e36cea592..7a90de47c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,57 +1,72 @@
-  [StackOverflow]: http://stackoverflow.com/tags/sbt
-  [ask]: https://stackoverflow.com/questions/ask?tags=sbt
-  [Setup]: http://www.scala-sbt.org/release/docs/Getting-Started/Setup
+  [StackOverflow]: https://stackoverflow.com/tags/sbt
+  [Setup]: https://www.scala-sbt.org/release/docs/Getting-Started/Setup
   [Issues]: https://github.com/sbt/sbt/issues
-  [sbt-dev]: https://groups.google.com/d/forum/sbt-dev
-  [subscriptions]: http://typesafe.com/how/subscription
+  [sbt-contrib]: https://gitter.im/sbt/sbt-contrib
   [327]: https://github.com/sbt/sbt/issues/327
+  [documentation]: https://github.com/sbt/website
+
+Contributing
+============
+
+(For support, see [SUPPORT](./SUPPORT.md))
+
+There are lots of ways to contribute to sbt ecosystem depending on your interests and skill level.
+
+- Help someone at work or online fix their build problem.
+- Answer StackOverflow questions.
+- Ask StackOverflow questions.
+- Create plugins that extend sbt's features.
+- Maintain and update [documentation].
+- Garden the issue tracker.
+- Report issues.
+- Patch the core (send pull requests to code).
+- On-ramp other contributors.
 
 Issues and Pull Requests
-========================
+------------------------
 
 When you find a bug in sbt we want to hear about it. Your bug reports play an important part in making sbt more reliable and usable.
 
 Effective bug reports are more likely to be fixed. These guidelines explain how to write such reports and pull requests.
 
-Preliminaries
---------------
+Please open a GitHub issue when you are 90% sure it's an actual bug.
+
+If you have an enhancement idea, or a general discussion, bring it up to [sbt-contrib].
+
+### Notes about Documentation
+
+Documentation fixes and contributions are as much welcome as to patching the core. Visit [sbt/website][documentation] to learn about how to contribute.
+
+### Preliminaries
 
 - Make sure your sbt version is up to date.
 - Search [StackOverflow] and [Issues] to see whether your bug has already been reported.
 - Open one case for each problem.
 - Proceed to the next steps for details.
 
-Where to get help and/or file a bug report
-------------------------------------------
-
-sbt project uses GitHub Issues as a publicly visible todo list. Please open a GitHub issue only when asked to do so.
-
-- If you need help with sbt, please [ask] on StackOverflow with the tag "sbt" and the name of the sbt plugin if any.
-- If you run into an issue, have an enhancement idea, or a general discussion, bring it up to [sbt-dev] Google Group first.
-- If you need a faster response time, consider one of the [Typesafe subscriptions][subscriptions].
-
-What to report
---------------
+### What to report
 
 The developers need three things from you: **steps**, **problems**, and **expectations**.
 
-### Steps
+The most important thing to remember about bug reporting is to clearly distinguish facts and opinions.
 
-The most important thing to remember about bug reporting is to clearly distinguish facts and opinions. What we need first is **the exact steps to reproduce your problems on our computers**. This is called *reproduction steps*, which is often shortened to "repro steps" or "steps." Describe your method of running sbt. Provide `build.sbt` that caused the problem and the version of sbt or Scala that was used. Provide sample Scala code if it's to do with incremental compilation. If possible, minimize the problem to reduce non-essential factors.
+#### Steps
+
+What we need first is **the exact steps to reproduce your problems on our computers**. This is called *reproduction steps*, which is often shortened to "repro steps" or "steps." Describe your method of running sbt. Provide `build.sbt` that caused the problem and the version of sbt or Scala that was used. Provide sample Scala code if it's to do with incremental compilation. If possible, minimize the problem to reduce non-essential factors.
 
 Repro steps are the most important part of a bug report. If we cannot reproduce the problem in one way or the other, the problem can't be fixed. Telling us the error messages is not enough.
 
-### Problems
+#### Problems
 
 Next, describe the problems, or what *you think* is the problem. It might be "obvious" to you that it's a problem, but it could actually be an intentional behavior for some backward compatibility etc. For compilation errors, include the stack trace. The more raw info the better.
 
-### Expectations
+#### Expectations
 
 Same as the problems. Describe what *you think* should've happened.
 
-### Notes
+#### Notes
 
-Add an optional notes section to describe your analysis.
+Add any optional notes section to describe your analysis.
 
 ### Subject
 
@@ -61,7 +76,7 @@ The subject of the bug report doesn't matter. A more descriptive subject is cert
 
 If possible, please format code or console outputs.
 
-On Github it's:
+On GitHub it's:
 
     ```scala
     name := "foo"
@@ -81,14 +96,11 @@ Finally, thank you for taking the time to report a problem.
 Pull Requests
 -------------
 
-### Branch to work against
-
-Whether implementing a new feature, fixing a bug, or modifying documentation, please work against the latest development branch (currently, 0.13).
-See below for instructions on building sbt from source.
+See below for the branch to work against.
 
 ### Adding notes
 
-All pull requests are required to include a "Notes" file which documents the change.  This file should reside in the
+Most pull requests should include a "Notes" file which documents the change.  This file should reside in the
 directory:
 
     <sbt root>
@@ -111,92 +123,38 @@ Make sure you document each commit and squash them appropriately. You can use th
 * Scala's documentation on [Git Hygiene](https://github.com/scala/scala/tree/v2.12.0-M3#git-hygiene)
 * Play's documentation on [Working with Git](https://www.playframework.com/documentation/2.4.4/WorkingWithGit#Squashing-commits)
 
-Documentation
--------------
-
-Documentation fixes and contributions are as much welcome as to the source code itself. Visit [the website project](https://github.com/sbt/website) to learn about how to contribute.
-
 Build from source
-=================
-
-1. Install the current stable binary release of sbt (see [Setup]), which will be used to build sbt from source.
-2. Get the source code.
-
-		$ git clone git://github.com/sbt/sbt.git
-		$ cd sbt
-
-3. The default branch is the development branch [0.13](https://github.com/sbt/sbt/tree/0.13), which contains the latest code for the next major sbt release.  To build a specific release or commit, switch to the associated tag.  The tag for the latest stable release is [v0.13.9](https://github.com/sbt/sbt/tree/v0.13.9):
-
-		$ git checkout v0.13.9
-
-	Note that sbt is always built with the previous stable release.  For example, the [0.13](https://github.com/sbt/sbt/tree/0.13) branch is built with 0.13.9 and the [v0.13.9](https://github.com/sbt/sbt/tree/v0.13.9) tag is built with 0.13.8.
-
-4. To build the launcher and publish all components locally,
-
-		$ sbt
-		> publishLocal
-
-5. To use this locally built version of sbt, copy your stable `~/bin/sbt` script to `~/bin/xsbt` and change it to use the launcher jar at `<sbt>/launch/target/sbt-launch.jar`.
-
-	Directory `target` is removed by `clean` command. Second solution is using the artifact stored in the local ivy repository.
-
-	The launcher is located in:
-
-    $HOME/.ivy2/local/org.scala-sbt/sbt-launch/0.13.9/jars/sbt-launch.jar
-
-	for v0.13.9 tag, or in:
-
-    $HOME/.ivy2/local/org.scala-sbt/sbt-launch/0.13.10-SNAPSHOT/jars/sbt-launch.jar
-
-	for the development branch.
-
-## Modifying sbt
-
-1. When developing sbt itself, run `compile` when checking compilation only.
-
-2. To use your modified version of sbt in a project locally, run `publishLocal`.
-
-3. After each `publishLocal`, clean the `~/.sbt/boot/` directory.  Alternatively, if sbt is running and the launcher hasn't changed, run `reboot full` to have sbt do this for you.
-
-4. If a project has `project/build.properties` defined, either delete the file or change `sbt.version` to `0.13.10-SNAPSHOT`.
-
-## Diagnosing build failures
-
-Globally included plugins can interfere building `sbt`; if you are getting errors building sbt, try disabling all globally included plugins and try again.
-
-Running Tests
-=============
-
-sbt has an extensive test suite of Unit tests and Integration tests!
-
-Unit / Functional tests
------------------------
-
-Various functional and unit tests are defined throughout the
-project. To run all of them, run `sbt test`. You can run a single test
-suite with `sbt testOnly`
-
-Integration tests
 -----------------
 
-Scripted integration tests reside in `sbt/src/sbt-test` and are
-written using the same testing infrastructure sbt plugin authors can
-use to test their own plugins with sbt. You can read more about this
-style of tests [here](http://eed3si9n.com/testing-sbt-plugins).
+See [DEVELOPING](./DEVELOPING.md)
 
-You can run the integration tests with the `sbt scripted` sbt
-command. To run a single test, such as the test in
-`sbt/src/sbt-test/project/global-plugin`, simply run:
+Profiling sbt
+-------------
 
-    sbt "scripted project/global-plugin"
+See [PROFILING](./PROFILING.md)
 
-Please note that these tests run PAINFULLY slow if the version set in
-`build.sbt` is set to SNAPSHOT, as every time the scripted test boots
-up a test instance of sbt, remote mirrors are scanned for possible
-updates. It is recommended that you set the version suffix to
-`-devel`, as in `0.13.10-devel`.
+Other notes for maintainers
+---------------------------
 
-Building Documentation
-======================
+### Publishing VS Code Extensions
 
-The scala-sbt.org site documentation is a separate project [website](https://github.com/sbt/website). Follow [the steps in the README](https://github.com/sbt/website#scala-sbtorg) to generate the documentation.
+Reference https://code.visualstudio.com/docs/extensions/publish-extension
+
+```
+$ sbt
+> vscodePlugin/compile
+> exit
+cd vscode-sbt-scala/client
+# update version number in vscode-sbt-scala/client/package.json
+$ vsce package
+$ vsce publish
+```
+
+## Signing the CLA
+
+Contributing to sbt requires you or your employer to sign the
+[Lightbend Contributor License Agreement](https://www.lightbend.com/contribute/cla).
+
+To make it easier to respect our license agreements, we have added an sbt task
+that takes care of adding the LICENSE headers to new files. Run `headerCreate`
+and sbt will put a copyright notice into it.
diff --git a/DEVELOPING.md b/DEVELOPING.md
new file mode 100644
index 000000000..691720ea2
--- /dev/null
+++ b/DEVELOPING.md
@@ -0,0 +1,154 @@
+Developer guide
+===============
+
+### Branch to work against
+
+sbt uses two branches for development:
+
+- Development branch: `develop` (this is also called "master")
+- Stable branch: `1.$MINOR.x`, where `$MINOR` is current minor version (e.g. `1.1.x` during 1.1.x series)
+
+
+### Instruction to build just sbt
+
+If the change you are making is contained in sbt/sbt, you could publishLocal on sbt/sbt:
+
+```
+$ sbt
+sbt:sbtRoot> publishLocal
+```
+
+### Instruction to build all modules from source
+
+1. Install the current stable binary release of sbt (see [Setup]), which will be used to build sbt from source.
+2. Get the source code.
+
+   ```
+   $ mkdir sbt-modules
+   $ cd sbt-modules
+   $ for i in sbt io librarymanagement zinc; do \
+     git clone https://github.com/sbt/$i.git && (cd $i; git checkout -b develop origin/develop)
+   done
+   $ cd sbt
+   $ ./sbt-allsources.sh
+   ```
+
+3. To build and publish all components locally,
+
+   ```
+   $ ./sbt-allsources.sh
+   sbt:sbtRoot> publishLocalAllModule
+   ```
+
+### Using the locally built sbt
+
+The `publishLocal` above will build and publish version `1.$MINOR.$PATCH-SNAPSHOT` (e.g. 1.1.2-SNAPSHOT) to your local ivy repository.
+
+To use the locally built sbt, set the version in `build.properties` file in your project to `1.$MINOR.$PATCH-SNAPSHOT` then launch `sbt` (this can be the `sbt` launcher installed in your machine).
+
+```
+$ cd $YOUR_OWN_PROJECT
+$ sbt
+> compile
+```
+
+### Nightly builds
+
+The latest development versions are available as nightly builds on sbt-maven-snapshots (<https://repo.scala-sbt.org/scalasbt/maven-snapshots>) repo, which is a redirect proxy whose underlying repository is subject to change it could be Bintray, Linux box, etc.
+
+To use a nightly build:
+
+1. Find out a version from [/org/scala-sbt/sbt/](https://repo.scala-sbt.org/scalasbt/maven-snapshots/org/scala-sbt/sbt/).
+2. Put the version, for example `sbt.version=1.5.0-bin-20201121T081131` in `project/build.properties`.
+
+sbt launcher will resolve the specified sbt core artifacts. Because of the aforementioned redirection, this resolution is going to be very slow for the first time you run sbt, and then it should be ok for subsequent runs.
+
+Unless you're debugging the `sbt` script or the launcher JAR, you should be able to use any recent stable version of sbt installation as the launcher following the [Setup][Setup] instructions first.
+
+If you're overriding the repositories via `~/.sbt/repositories`, make sure that there's a following entry:
+
+```
+[repositories]
+  ...
+  sbt-maven-snapshots: https://repo.scala-sbt.org/scalasbt/maven-snapshots/, bootOnly
+```
+
+### Clearing out boot and local cache
+
+When you run a locally built sbt, the JAR artifacts will be now cached under `$HOME/.sbt/boot/scala-2.12.6/org.scala-sbt/sbt/1.$MINOR.$PATCH-SNAPSHOT` directory. To clear this out run: `reboot dev` command from sbt's session of your test application.
+
+One drawback of `-SNAPSHOT` version is that it's slow to resolve as it tries to hit all the resolvers. You can workaround that by using a version name like `1.$MINOR.$PATCH-LOCAL1`. A non-SNAPSHOT artifacts will now be cached under `$HOME/.ivy/cache/` directory, so you need to clear that out using [sbt-dirty-money](https://github.com/sbt/sbt-dirty-money)'s `cleanCache` task.
+
+### Running sbt "from source" - `sbtOn`
+
+In addition to locally publishing a build of sbt, there is an alternative, experimental launcher within sbt/sbt
+to be able to run sbt "from source", that is to compile sbt and run it from its resulting classfiles rather than
+from published jar files.
+
+Such a launcher is available within sbt/sbt's build through a custom `sbtOn` command that takes as its first
+argument the directory on which you want to run sbt, and the remaining arguments are passed _to_ that sbt
+instance. For example:
+
+I have setup a minimal sbt build in the directory `/s/t`, to run sbt on that directory I call:
+
+```bash
+> sbtOn /s/t
+[info] Packaging /d/sbt/scripted/sbt/target/scala-2.12/scripted-sbt_2.12-1.2.0-SNAPSHOT.jar ...
+[info] Done packaging.
+[info] Running (fork) sbt.RunFromSourceMain /s/t
+Listening for transport dt_socket at address: 5005
+[info] Loading settings from idea.sbt,global-plugins.sbt ...
+[info] Loading global plugins from /Users/dnw/.dotfiles/.sbt/1.0/plugins
+[info] Loading project definition from /s/t/project
+[info] Set current project to t (in build file:/s/t/)
+[info] sbt server started at local:///Users/dnw/.sbt/1.0/server/ce9baa494c7598e4d59b/sock
+> show baseDirectory
+[info] /s/t
+> exit
+[info] shutting down sbt server
+[success] Total time: 19 s, completed 25-Apr-2018 15:04:58
+```
+
+Please note that this alternative launcher does _not_ have feature parity with sbt/launcher. (Meta)
+contributions welcome! :-D
+
+### Diagnosing build failures
+
+Globally included plugins can interfere building `sbt`; if you are getting errors building sbt, try disabling all globally included plugins and try again.
+
+### Running Tests
+
+sbt has a suite of unit tests and integration tests, also known as scripted tests.
+
+#### Unit / Functional tests
+
+Various functional and unit tests are defined throughout the
+project. To run all of them, run `sbt test`. You can run a single test
+suite with `sbt testOnly`
+
+#### Integration tests
+
+Scripted integration tests reside in `sbt/src/sbt-test` and are
+written using the same testing infrastructure sbt plugin authors can
+use to test their own plugins with sbt. You can read more about this
+style of tests [here](https://www.scala-sbt.org/1.0/docs/Testing-sbt-plugins).
+
+You can run the integration tests with the `sbt scripted` sbt
+command. To run a single test, such as the test in
+`sbt/src/sbt-test/project/global-plugin`, simply run:
+
+    sbt "scripted project/global-plugin"
+
+### Random tidbits
+
+#### Import statements
+
+You'd need alternative DSL import since you can't rely on sbt package object.
+
+```scala
+// for slash syntax
+import sbt.SlashSyntax0._
+
+// for IO
+import sbt.io.syntax._
+```
diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
deleted file mode 100644
index 748cd9fd1..000000000
--- a/ISSUE_TEMPLATE.md
+++ /dev/null
@@ -1,16 +0,0 @@
-(See the guidelines for contributing, linked above)
-
-## steps
-
-
-
-## problem
-
-
-
-## expectation
-
-
-
-## notes
-
diff --git a/LICENSE b/LICENSE
index d70192438..a5c4997c4 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,25 +1,203 @@
-Copyright (c) 2008-2014 Typesafe Inc, Mark Harrah, Grzegorz Kossakowski, Josh Suereth, Indrajit Raychaudhuri, Eugene Yokota, and other contributors.
-All rights reserved.
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. The name of the author may not be used to endorse or promote products
-   derived from this software without specific prior written permission.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2011 - 2018, Lightbend, Inc.
+   Copyright (c) 2008 - 2010, Mark Harrah
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/MIGRATION.md b/MIGRATION.md
deleted file mode 100644
index 6f7d67952..000000000
--- a/MIGRATION.md
+++ /dev/null
@@ -1,21 +0,0 @@
-Migration notes
-===============
-
-- Build definition is based on Scala 2.11.8
-- Build.scala style builds are gone. Use multi-project `build.sbt`.
-- `Project(...)` constructor is restricted down to two parameters. Use `project` instead.
-- `sbt.Plugin` is also gone. Use auto plugins.
-- The incremental compiler, called Zinc, uses class-based name hashing.
-- Zinc drops support for Scala 2.8.x and 2.9.x.
-- Removed the pre-0.13.7 *.sbt file parser (previously available under `-Dsbt.parser.simple=true`)
-- Removed old, hyphen-separated key names (use `publishLocal` instead of `publish-local`)
-- Removes no-longer-documented old operators `<<=`, `<+=`, and `<++=`.
-- Renames early command feature from `--<command>` to `early(<command>)`.
-- Log options `-error`, `-warn`, `-info`, `-debug` are added as shorthand for `"early(error)"` etc.
-
-#### Additional import required
-
-Implicit conversions are moved to `sbt.syntax`. Add the following imports to auto plugins
-or `project/*.scala`.
-
-    import sbt._, syntax._, Keys._
diff --git a/NOTICE b/NOTICE
index 55efecac8..82bd2c916 100644
--- a/NOTICE
+++ b/NOTICE
@@ -1,6 +1,7 @@
 sbt
-Copyright (c) 2008-2014 Typesafe Inc, Mark Harrah, Grzegorz Kossakowski, Josh Suereth, Indrajit Raychaudhuri, Eugene Yokota, and other contributors.
-Licensed under BSD-style license (see LICENSE)
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under Apache v2 license (see LICENSE)
 
 Portions based on code from the Scala compiler.  Portions of the Scala
 library are distributed with the launcher.
@@ -33,4 +34,3 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
\ No newline at end of file
diff --git a/PROFILING.md b/PROFILING.md
new file mode 100644
index 000000000..02b235e18
--- /dev/null
+++ b/PROFILING.md
@@ -0,0 +1,153 @@
+Profiling sbt
+-------------
+
+There are several ways to profile sbt. The new hotness in profiling is FlameGraph.
+You first collect stack trace samples, and then it is processed into svg graph.
+See:
+
+- [Using FlameGraphs To Illuminate The JVM by Nitsan Wakart](https://www.youtube.com/watch?v=ugRrFdda_JQ)
+- [USENIX ATC '17: Visualizing Performance with Flame Graphs](https://www.youtube.com/watch?v=D53T1Ejig1Q)
+
+### jvm-profiling-tools/async-profiler
+
+The first one I recommend is async-profiler. This is available for macOS and Linux,
+and works fairly well.
+
+1. Download the installer from https://github.com/jvm-profiling-tools/async-profiler/releases/tag/v1.2
+2. Make symbolic link to `build/` and `profiler.sh` to `$HOME/bin`, assuming you have PATH to `$HOME/bin`:
+   `ln -s ~/Applications/async-profiler/profiler.sh $HOME/bin/profiler.sh`
+   `ln -s ~/Applications/async-profiler/build $HOME/bin/build`
+
+Next, close all Java applications and anything that may affect the profiling, and run sbt in one terminal:
+
+```
+$ sbt exit
+```
+
+In another terminal, run:
+
+```
+$ jps
+92746 sbt-launch.jar
+92780 Jps
+```
+
+This tells you the process ID of sbt. In this case, it's 92746. While it's running, run
+
+```
+$ profiler.sh -d 60 <process id>
+Started [cpu] profiling
+--- Execution profile ---
+Total samples:         31602
+Non-Java:              3239 (10.25%)
+GC active:             46 (0.15%)
+Unknown (native):      14667 (46.41%)
+Not walkable (native): 3 (0.01%)
+Unknown (Java):        433 (1.37%)
+Not walkable (Java):   8 (0.03%)
+Thread exit:           1 (0.00%)
+Deopt:                 9 (0.03%)
+
+Frame buffer usage:    55.658%
+
+Total: 1932000000 (6.11%)  samples: 1932
+  [ 0] java.lang.ClassLoader$NativeLibrary.load
+  [ 1] java.lang.ClassLoader.loadLibrary0
+  [ 2] java.lang.ClassLoader.loadLibrary
+  [ 3] java.lang.Runtime.loadLibrary0
+  [ 4] java.lang.System.loadLibrary
+....
+```
+
+This should show a bunch of stacktraces that are useful.
+To visualize this as a flamegraph, run:
+
+```
+$ profiler.sh -d 60 -f /tmp/flamegraph.svg <process id>
+```
+
+This should produce `/tmp/flamegraph.svg` at the end.
+
+![flamegraph](project/flamegraph_svg.png)
+
+See https://gist.github.com/eed3si9n/82d43acc95a002876d357bd8ad5f40d5
+
+### running sbt with standby
+
+One of the tricky things you come across while profiling is figuring out the process ID,
+while wnating to profile the beginning of the application.
+
+For this purpose, we've added `sbt.launcher.standby` JVM flag.
+In the next version of sbt, you should be able to run:
+
+```
+$ sbt -J-Dsbt.launcher.standby=20s exit
+```
+
+This will count down for 20s before doing anything else.
+
+### jvm-profiling-tools/perf-map-agent
+
+If you want to try the mixed flamegraph, you can try perf-map-agent.
+This uses `dtrace` on macOS and `perf` on Linux.
+
+You first have to compile https://github.com/jvm-profiling-tools/perf-map-agent.
+For macOS, here to how to export `JAVA_HOME` before running `cmake .`:
+
+```
+$ export JAVA_HOME=$(/usr/libexec/java_home)
+$ cmake .
+-- The C compiler identification is AppleClang 9.0.0.9000039
+-- The CXX compiler identification is AppleClang 9.0.0.9000039
+...
+$ make
+```
+
+In addition, you have to git clone https://github.com/brendangregg/FlameGraph
+
+In a fresh termimal, run sbt with `-XX:+PreserveFramePointer` flag:
+
+```
+$ sbt -J-Dsbt.launcher.standby=20s -J-XX:+PreserveFramePointer exit
+```
+
+In the terminal that you will run the perf-map:
+
+```
+$ cd quicktest/
+$ export JAVA_HOME=$(/usr/libexec/java_home)
+$ export FLAMEGRAPH_DIR=$HOME/work/FlameGraph
+$ jps
+94592 Jps
+94549 sbt-launch.jar
+$ $HOME/work/perf-map-agent/bin/dtrace-java-flames 94549
+dtrace: system integrity protection is on, some features will not be available
+
+dtrace: description 'profile-99 ' matched 2 probes
+Flame graph SVG written to DTRACE_FLAME_OUTPUT='/Users/xxx/work/quicktest/flamegraph-94549.svg'.
+```
+
+This would produce better flamegraph in theory, but the output looks too messy for `sbt exit` case.
+See https://gist.github.com/eed3si9n/b5856ff3d987655513380d1a551aa0df
+This might be because it assumes that the operations are already JITed.
+
+### ktoso/sbt-jmh
+
+https://github.com/ktoso/sbt-jmh
+
+Due to JIT warmup etc, benchmarking is difficult. JMH runs the same tests multiple times to
+remove these effects and comes closer to measuring the performance of your code.
+
+There's also an integration with jvm-profiling-tools/async-profiler, apparently.
+
+### VisualVM
+
+I'd also mention traditional JVM profiling tool. Since VisualVM is opensource,
+I'll mention this one: https://visualvm.github.io/
+
+1. First VisualVM.
+2. Start sbt from a terminal.
+3. You should see `xsbt.boot.Boot` under Local.
+4. Open it, and select either sampler or profiler, and hit CPU button at the point when you want to start.
+
+If you are familiar with YourKit, it also works similarly.
diff --git a/PULL_REQUEST_TEMPLATE.md b/PULL_REQUEST_TEMPLATE.md
deleted file mode 100644
index 0392fc0ee..000000000
--- a/PULL_REQUEST_TEMPLATE.md
+++ /dev/null
@@ -1 +0,0 @@
-(See the guidelines for contributing, linked above)
diff --git a/README.md b/README.md
index d71adbfeb..4224db130 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,16 @@
+[![Build Status](https://travis-ci.com/sbt/sbt.svg?branch=develop)](https://travis-ci.com/github/sbt/sbt)
+[![Latest version](https://img.shields.io/github/tag/sbt/sbt.svg)](https://index.scala-lang.org/sbt/sbt)
+[![Gitter Chat](https://badges.gitter.im/sbt/sbt.svg)](https://gitter.im/sbt/sbt)
+
   [sbt/sbt-zero-seven]: https://github.com/sbt/sbt-zero-seven
   [CONTRIBUTING]: CONTRIBUTING.md
-  [Setup]: http://www.scala-sbt.org/release/docs/Getting-Started/Setup
-  [FAQ]: http://www.scala-sbt.org/release/docs/Faq.html
+  [Setup]: https://www.scala-sbt.org/release/docs/Getting-Started/Setup
+  [FAQ]: https://www.scala-sbt.org/release/docs/Faq.html
   [sbt-dev]: https://groups.google.com/d/forum/sbt-dev
-  [searching]: http://stackoverflow.com/tags/sbt
+  [searching]: https://stackoverflow.com/tags/sbt
   [asking]: https://stackoverflow.com/questions/ask?tags=sbt
   [LICENSE]: LICENSE
   [sbt/io]: https://github.com/sbt/io
-  [sbt/util]: https://github.com/sbt/util
   [sbt/librarymanagement]: https://github.com/sbt/librarymanagement
   [sbt/zinc]: https://github.com/sbt/zinc
   [sbt/sbt]: https://github.com/sbt/sbt
@@ -17,16 +20,15 @@ sbt
 
 sbt is a build tool for Scala, Java, and more.
 
-For general documentation, see http://www.scala-sbt.org/.
+For general documentation, see https://www.scala-sbt.org/.
 
-sbt 1.0.x
+sbt 1.x
 ---------
 
-This is the 1.0.x series of sbt. The source code of sbt is split across
-several Github repositories, including this one.
+This is the 1.x series of sbt. The source code of sbt is split across
+several GitHub repositories, including this one.
 
 - [sbt/io][sbt/io] hosts `sbt.io` module.
-- [sbt/util][sbt/util] hosts a collection of internally used modules.
 - [sbt/librarymanagement][sbt/librarymanagement] hosts `sbt.librarymanagement` module that wraps Ivy.
 - [sbt/zinc][sbt/zinc] hosts Zinc, an incremental compiler for Scala.
 - [sbt/sbt][sbt/sbt], this repository hosts modules that implements the build tool.
@@ -42,7 +44,7 @@ Issues and Pull Requests
 
 Please read [CONTRIBUTING] carefully before opening a GitHub Issue.
 
-The short version: try [searching] or [asking] on StackOverflow and [sbt-dev].
+The short version: try [searching] or [asking] on StackOverflow.
 
 license
 -------
diff --git a/SUPPORT.md b/SUPPORT.md
new file mode 100644
index 000000000..c3c7d0c44
--- /dev/null
+++ b/SUPPORT.md
@@ -0,0 +1,20 @@
+  [ask]: https://stackoverflow.com/questions/ask?tags=sbt
+  [Lightbend]: https://www.lightbend.com/
+  [subscriptions]: https://www.lightbend.com/platform/subscription
+  [gitter]: https://gitter.im/sbt/sbt
+
+Support
+=======
+
+[Lightbend] sponsors sbt and encourages contributions from the active community. Enterprises can adopt it for mission critical systems with confidence because Lightbend stands behind sbt with commercial support and services.
+
+For community support please [ask] on StackOverflow with the tag "sbt" (and the name of the sbt plugin(s) if any).
+
+- State the problem or question clearly and provide enough context. Code examples and `build.sbt` are often useful when appropriately edited.
+- There's also [Gitter sbt/sbt room][gitter], but Stackoverflow is recommended so others can benefit from the answers.
+
+For professional support, for instance if you need faster response times, [Lightbend], the maintainer of Scala compiler and sbt, provides:
+
+- [Lightbend Subscriptions][subscriptions], which includes Expert Support
+- Training
+- Consulting
diff --git a/build.sbt b/build.sbt
index ffd4ae2f7..cea416b0d 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1,375 +1,1562 @@
-import Util._
 import Dependencies._
-import Sxr.sxr
+import Util._
+import com.typesafe.tools.mima.core.ProblemFilters._
+import com.typesafe.tools.mima.core._
+import local.Scripted
+import java.nio.file.{ Files, Path => JPath }
 
-import com.typesafe.tools.mima.core._, ProblemFilters._
-import com.typesafe.tools.mima.plugin.MimaKeys.{ binaryIssueFilters, previousArtifact}
-import com.typesafe.tools.mima.plugin.MimaPlugin.mimaDefaultSettings
+import scala.util.Try
 
 // ThisBuild settings take lower precedence,
 // but can be shared across the multi projects.
-def buildLevelSettings: Seq[Setting[_]] = inThisBuild(Seq(
-  organization := "org.scala-sbt",
-  version := "1.0.0-SNAPSHOT",
-  description := "sbt is an interactive build tool",
-  bintrayOrganization := Some("sbt"),
-  bintrayRepository := {
-    if (!isSnapshot.value) "maven-releases"
-    else "maven-snapshots"
-  },
-  bintrayPackage := "sbt",
-  bintrayReleaseOnPublish := false,
-  licenses := List("BSD New" -> url("https://github.com/sbt/sbt/blob/0.13/LICENSE")),
-  developers := List(
-    Developer("harrah", "Mark Harrah", "@harrah", url("https://github.com/harrah")),
-    Developer("eed3si9n", "Eugene Yokota", "@eed3si9n", url("https://github.com/eed3si9n")),
-    Developer("jsuereth", "Josh Suereth", "@jsuereth", url("https://github.com/jsuereth")),
-    Developer("dwijnand", "Dale Wijnand", "@dwijnand", url("https://github.com/dwijnand")),
-    Developer("gkossakowski", "Grzegorz Kossakowski", "@gkossakowski", url("https://github.com/gkossakowski")),
-    Developer("Duhemm", "Martin Duhem", "@Duhemm", url("https://github.com/Duhemm"))
+ThisBuild / version := {
+  val v = "1.5.0-SNAPSHOT"
+  nightlyVersion.getOrElse(v)
+}
+ThisBuild / version2_13 := "2.0.0-SNAPSHOT"
+ThisBuild / versionScheme := Some("early-semver")
+ThisBuild / scalafmtOnCompile := !(Global / insideCI).value
+ThisBuild / Test / scalafmtOnCompile := !(Global / insideCI).value
+ThisBuild / turbo := true
+ThisBuild / usePipelining := false // !(Global / insideCI).value
+ThisBuild / organization := "org.scala-sbt"
+ThisBuild / description := "sbt is an interactive build tool"
+ThisBuild / licenses := List("Apache-2.0" -> url("https://github.com/sbt/sbt/blob/develop/LICENSE"))
+ThisBuild / javacOptions ++= Seq("-source", "1.8", "-target", "1.8")
+ThisBuild / Compile / doc / javacOptions := Nil
+ThisBuild / developers := List(
+  Developer("harrah", "Mark Harrah", "@harrah", url("https://github.com/harrah")),
+  Developer("eed3si9n", "Eugene Yokota", "@eed3si9n", url("https://github.com/eed3si9n")),
+  Developer("jsuereth", "Josh Suereth", "@jsuereth", url("https://github.com/jsuereth")),
+  Developer("dwijnand", "Dale Wijnand", "@dwijnand", url("https://github.com/dwijnand")),
+  Developer("eatkins", "Ethan Atkins", "@eatkins", url("https://github.com/eatkins")),
+  Developer(
+    "gkossakowski",
+    "Grzegorz Kossakowski",
+    "@gkossakowski",
+    url("https://github.com/gkossakowski")
   ),
-  homepage := Some(url("https://github.com/sbt/sbt")),
-  scmInfo := Some(ScmInfo(url("https://github.com/sbt/sbt"), "git@github.com:sbt/sbt.git")),
-  resolvers += Resolver.mavenLocal
-))
+  Developer("Duhemm", "Martin Duhem", "@Duhemm", url("https://github.com/Duhemm"))
+)
+ThisBuild / homepage := Some(url("https://github.com/sbt/sbt"))
+ThisBuild / scmInfo := Some(
+  ScmInfo(url("https://github.com/sbt/sbt"), "git@github.com:sbt/sbt.git")
+)
+ThisBuild / resolvers += Resolver.mavenLocal
 
-def commonSettings: Seq[Setting[_]] = Seq[SettingsDefinition](
-  scalaVersion := scala211,
+Global / semanticdbEnabled := !(Global / insideCI).value
+Global / semanticdbVersion := "4.4.10"
+val excludeLint = SettingKey[Set[Def.KeyedInitialize[_]]]("excludeLintKeys")
+Global / excludeLint := (Global / excludeLint).?.value.getOrElse(Set.empty)
+Global / excludeLint += componentID
+Global / excludeLint += whitesourceIgnoredScopes
+Global / excludeLint += scriptedBufferLog
+Global / excludeLint += checkPluginCross
+
+def commonBaseSettings: Seq[Setting[_]] = Def.settings(
+  headerLicense := Some(
+    HeaderLicense.Custom(
+      """|sbt
+       |Copyright 2011 - 2018, Lightbend, Inc.
+       |Copyright 2008 - 2010, Mark Harrah
+       |Licensed under Apache License 2.0 (see LICENSE)
+       |""".stripMargin
+    )
+  ),
+  scalaVersion := baseScalaVersion,
   componentID := None,
-  resolvers += Resolver.typesafeIvyRepo("releases"),
+  resolvers += Resolver.typesafeIvyRepo("releases").withName("typesafe-sbt-build-ivy-releases"),
   resolvers += Resolver.sonatypeRepo("snapshots"),
-  resolvers += "bintray-sbt-maven-releases" at "https://dl.bintray.com/sbt/maven-releases/",
+  resolvers += Resolver.url(
+    "bintray-scala-hedgehog",
+    url("https://dl.bintray.com/hedgehogqa/scala-hedgehog")
+  )(Resolver.ivyStylePatterns),
+  testFrameworks += TestFramework("hedgehog.sbt.Framework"),
+  testFrameworks += TestFramework("verify.runner.Framework"),
   concurrentRestrictions in Global += Util.testExclusiveRestriction,
-  testOptions += Tests.Argument(TestFrameworks.ScalaCheck, "-w", "1"),
-  javacOptions in compile ++= Seq("-target", "6", "-source", "6", "-Xlint", "-Xlint:-serial"),
-  incOptions := incOptions.value.withNameHashing(true),
-  crossScalaVersions := Seq(scala211),
-  bintrayPackage := (bintrayPackage in ThisBuild).value,
-  bintrayRepository := (bintrayRepository in ThisBuild).value,
-  mimaDefaultSettings,
+  testOptions in Test += Tests.Argument(TestFrameworks.ScalaCheck, "-w", "1"),
+  testOptions in Test += Tests.Argument(TestFrameworks.ScalaCheck, "-verbosity", "2"),
+  javacOptions in compile ++= Seq("-Xlint", "-Xlint:-serial"),
+  Compile / doc / scalacOptions ++= {
+    import scala.sys.process._
+    val devnull = ProcessLogger(_ => ())
+    val tagOrSha = ("git describe --exact-match" #|| "git rev-parse HEAD").lineStream(devnull).head
+    Seq(
+      "-sourcepath",
+      (baseDirectory in LocalRootProject).value.getAbsolutePath,
+      "-doc-source-url",
+      s"https://github.com/sbt/sbt/tree/$tagOrSha€{FILE_PATH}.scala"
+    )
+  },
+  Compile / javafmtOnCompile := Def
+    .taskDyn(if ((scalafmtOnCompile).value) Compile / javafmt else Def.task(()))
+    .value,
+  Test / javafmtOnCompile := Def
+    .taskDyn(if ((Test / scalafmtOnCompile).value) Test / javafmt else Def.task(()))
+    .value,
+  Compile / unmanagedSources / inputFileStamps :=
+    (Compile / unmanagedSources / inputFileStamps).dependsOn(Compile / javafmtOnCompile).value,
+  Test / unmanagedSources / inputFileStamps :=
+    (Test / unmanagedSources / inputFileStamps).dependsOn(Test / javafmtOnCompile).value,
+  crossScalaVersions := List(scala212, scala213),
   publishArtifact in Test := false,
-  previousArtifact := None, // Some(organization.value % moduleName.value % "1.0.0"),
-  binaryIssueFilters ++= Seq(
-  )
-) flatMap (_.settings)
+  fork in run := true,
+)
+def commonSettings: Seq[Setting[_]] =
+  commonBaseSettings :+
+    addCompilerPlugin(kindProjector)
+def utilCommonSettings: Seq[Setting[_]] =
+  baseSettings :+ (crossScalaVersions := (scala212 :: scala213 :: Nil))
 
 def minimalSettings: Seq[Setting[_]] =
   commonSettings ++ customCommands ++
-  publishPomSettings ++ Release.javaVersionCheckSettings
+    publishPomSettings
 
 def baseSettings: Seq[Setting[_]] =
-  minimalSettings ++ Seq(projectComponent) ++ baseScalacOptions ++ Licensed.settings ++ Formatting.settings
+  minimalSettings ++ Seq(projectComponent) ++ baseScalacOptions ++ Licensed.settings
 
 def testedBaseSettings: Seq[Setting[_]] =
   baseSettings ++ testDependencies
 
-lazy val sbtRoot: Project = (project in file(".")).
-  enablePlugins(ScriptedPlugin).
-  configs(Sxr.sxrConf).
-  aggregate(nonRoots: _*).
-  settings(
-    buildLevelSettings,
+val sbt13Plus = Seq("1.3.0")
+val sbt10Plus =
+  Seq(
+    "1.0.0",
+    "1.0.1",
+    "1.0.2",
+    "1.0.3",
+    "1.0.4",
+    "1.1.0",
+    "1.1.1",
+    "1.1.2",
+    "1.1.3",
+    "1.1.4",
+    "1.1.5",
+    "1.1.6",
+    "1.2.0",
+    "1.2.1",
+    /*DOA,*/ "1.2.3",
+    "1.2.4",
+    /*DOA,*/ "1.2.6",
+    "1.2.7",
+    "1.2.8",
+  ) ++ sbt13Plus
+val noUtilVersion =
+  Set("1.0.4", "1.1.4", "1.1.5", "1.1.6", "1.2.3", "1.2.4", "1.2.6", "1.2.7", "1.2.8")
+
+val mimaSettings = mimaSettingsSince(sbt10Plus)
+val utilMimaSettings = mimaSettingsSince(sbt10Plus.filterNot(noUtilVersion))
+def mimaSettingsSince(versions: Seq[String]): Seq[Def.Setting[_]] = Def settings (
+  mimaPreviousArtifacts := {
+    val crossVersion = if (crossPaths.value) CrossVersion.binary else CrossVersion.disabled
+    versions.map(v => organization.value % moduleName.value % v cross crossVersion).toSet
+  },
+  mimaBinaryIssueFilters ++= Seq(
+    // Changes in the internal package
+    exclude[DirectMissingMethodProblem]("sbt.internal.*"),
+    exclude[FinalClassProblem]("sbt.internal.*"),
+    exclude[FinalMethodProblem]("sbt.internal.*"),
+    exclude[IncompatibleResultTypeProblem]("sbt.internal.*"),
+    exclude[ReversedMissingMethodProblem]("sbt.internal.*")
+  ),
+)
+
+val scriptedSbtReduxMimaSettings = Def.settings(mimaPreviousArtifacts := Set())
+
+lazy val sbtRoot: Project = (project in file("."))
+// .enablePlugins(ScriptedPlugin)
+  .aggregate(nonRoots: _*)
+  .settings(
     minimalSettings,
-    rootSettings,
+    onLoadMessage := {
+      val version = sys.props("java.specification.version")
+      """           __    __ 
+        |     _____/ /_  / /_
+        |    / ___/ __ \/ __/
+        |   (__  ) /_/ / /_  
+        |  /____/_.___/\__/ 
+        |Welcome to the build for sbt.
+        |""".stripMargin +
+        (if (version != "1.8")
+           s"""!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+               |  Java version is $version. We recommend java 8.
+               |!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""".stripMargin
+         else "")
+    },
+    Util.baseScalacOptions,
+    Docs.settings,
+    scalacOptions += "-Ymacro-expand:none", // for both sxr and doc
+    Util.publishPomSettings,
+    otherRootSettings,
+    Transform.conscriptSettings(bundledLauncherProj),
     publish := {},
-    publishLocal := {}
+    publishLocal := {},
+    skip in publish := true,
+    commands in Global += Command
+      .single("sbtOn")((state, dir) => s"sbtProj/test:runMain sbt.RunFromSourceMain $dir" :: state),
+    mimaSettings,
+    mimaPreviousArtifacts := Set.empty,
+    buildThinClient := (sbtClientProj / buildThinClient).evaluated,
+    buildNativeThinClient := (sbtClientProj / buildNativeThinClient).value,
+    installNativeThinClient := {
+      // nativeInstallDirectory can be set globally or in a gitignored local file
+      val dir = nativeInstallDirectory.?.value
+      val target = Def.spaceDelimited("").parsed.headOption match {
+        case Some(p) => file(p).toPath
+        case _ =>
+          dir match {
+            case Some(d) => d / "sbtn"
+            case _ =>
+              val msg = "Expected input parameter <path>: installNativeExecutable /usr/local/bin"
+              throw new IllegalStateException(msg)
+          }
+      }
+      val base = baseDirectory.value.toPath
+      val exec = (sbtClientProj / buildNativeThinClient).value
+      streams.value.log.info(s"installing thin client ${base.relativize(exec)} to ${target}")
+      Files.copy(exec, target, java.nio.file.StandardCopyOption.REPLACE_EXISTING)
+    }
   )
 
 // This is used to configure an sbt-launcher for this version of sbt.
 lazy val bundledLauncherProj =
-  (project in file("launch")).
-  settings(
-    minimalSettings,
-    inConfig(Compile)(Transform.configSettings),
-    Release.launcherSettings(sbtLaunchJar)
-  ).
-  enablePlugins(SbtLauncherPlugin).
-  settings(
-    name := "sbt-launch",
-    moduleName := "sbt-launch",
-    description := "sbt application launcher",
-    autoScalaLibrary := false,
-    crossPaths := false,
-    publish := Release.deployLauncher.value,
-    publishLauncher := Release.deployLauncher.value,
-    packageBin in Compile := sbtLaunchJar.value
-  )
+  (project in file("launch"))
+    .enablePlugins(SbtLauncherPlugin)
+    .settings(
+      minimalSettings,
+      inConfig(Compile)(Transform.configSettings),
+    )
+    .settings(
+      name := "sbt-launch",
+      moduleName := "sbt-launch",
+      description := "sbt application launcher",
+      autoScalaLibrary := false,
+      crossPaths := false,
+      packageBin in Compile := sbtLaunchJar.value,
+      mimaSettings,
+      mimaPreviousArtifacts := Set()
+    )
 
 /* ** subproject declarations ** */
 
+val collectionProj = (project in file("internal") / "util-collection")
+  .settings(
+    testedBaseSettings,
+    utilCommonSettings,
+    Util.keywordsSettings,
+    name := "Collections",
+    libraryDependencies ++= Seq(sjsonNewScalaJson.value),
+    libraryDependencies ++= (CrossVersion.partialVersion(scalaVersion.value) match {
+      case Some((2, major)) if major <= 12 => Seq()
+      case _                               => Seq("org.scala-lang.modules" %% "scala-parallel-collections" % "0.2.0")
+    }),
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // Added private[sbt] method to capture State attributes.
+      exclude[ReversedMissingMethodProblem]("sbt.internal.util.AttributeMap.setCond"),
+      // Dropped in favour of kind-projector's inline type lambda syntax
+      exclude[MissingClassProblem]("sbt.internal.util.TypeFunctions$P1of2"),
+      // Dropped in favour of kind-projector's polymorphic lambda literals
+      exclude[MissingClassProblem]("sbt.internal.util.Param"),
+      exclude[MissingClassProblem]("sbt.internal.util.Param$"),
+      // Dropped in favour of plain scala.Function, and its compose method
+      exclude[MissingClassProblem]("sbt.internal.util.Fn1"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.TypeFunctions.toFn1"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.Types.toFn1"),
+      // Instead of defining foldr in KList & overriding in KCons,
+      // it's now abstract in KList and defined in both KCons & KNil.
+      exclude[FinalMethodProblem]("sbt.internal.util.KNil.foldr"),
+      exclude[DirectAbstractMethodProblem]("sbt.internal.util.KList.foldr"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.Init*.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.Settings0.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings#INode.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.TypeFunctions.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.Settings.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings#MixedNode.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings#BindNode.this"),
+      exclude[IncompatibleSignatureProblem](
+        "sbt.internal.util.EvaluateSettings#BindNode.dependsOn"
+      ),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.Types.some")
+    ),
+  )
+  .dependsOn(utilPosition)
+
+// Command line-related utilities.
+val completeProj = (project in file("internal") / "util-complete")
+  .dependsOn(collectionProj, utilControl, utilLogging)
+  .settings(
+    testedBaseSettings,
+    name := "Completion",
+    libraryDependencies += jline,
+    libraryDependencies += jline3Reader,
+    libraryDependencies += jline3Builtins,
+    mimaSettings,
+    // Parser is used publicly, so we can't break bincompat.
+    mimaBinaryIssueFilters := Seq(
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.SoftInvalid.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.Invalid.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.Finite.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.Infinite.decrement"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.History.this"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.complete.Completion.suggestion"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.complete.Completion.token"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.complete.Completion.displayOnly"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.complete.*"),
+    ),
+  )
+  .configure(addSbtIO)
+
+// A logic with restricted negation as failure for a unique, stable model
+val logicProj = (project in file("internal") / "util-logic")
+  .dependsOn(collectionProj, utilRelation)
+  .settings(
+    testedBaseSettings,
+    name := "Logic",
+    mimaSettings,
+  )
+
+// defines Java structures used across Scala versions, such as the API structures and relationships extracted by
+//   the analysis compiler phases and passed back to sbt.  The API structures are defined in a simple
+//   format from which Java sources are generated by the datatype generator Projproject
+lazy val utilInterface = (project in file("internal") / "util-interface").settings(
+  utilCommonSettings,
+  crossScalaVersions := List(scala212),
+  javaOnlySettings,
+  crossPaths := false,
+  name := "Util Interface",
+  exportJars := true,
+  utilMimaSettings,
+)
+
+lazy val utilControl = (project in file("internal") / "util-control").settings(
+  utilCommonSettings,
+  name := "Util Control",
+  utilMimaSettings,
+)
+
+lazy val utilPosition = (project in file("internal") / "util-position")
+  .settings(
+    utilCommonSettings,
+    name := "Util Position",
+    scalacOptions += "-language:experimental.macros",
+    libraryDependencies ++= Seq(scalaReflect.value, scalatest % "test"),
+    utilMimaSettings,
+  )
+
+lazy val utilLogging = (project in file("internal") / "util-logging")
+  .enablePlugins(ContrabandPlugin, JsonCodecPlugin)
+  .dependsOn(utilInterface, collectionProj, coreMacrosProj)
+  .settings(
+    utilCommonSettings,
+    name := "Util Logging",
+    libraryDependencies ++=
+      Seq(
+        jline,
+        jline3Terminal,
+        jline3JNA,
+        jline3Jansi,
+        log4jApi,
+        log4jCore,
+        disruptor,
+        sjsonNewScalaJson.value,
+        scalaReflect.value
+      ),
+    libraryDependencies ++= Seq(scalacheck % "test", scalatest % "test"),
+    Compile / scalacOptions ++= (scalaVersion.value match {
+      case v if v.startsWith("2.12.") => List("-Ywarn-unused:-locals,-explicits,-privates")
+      case _                          => List()
+    }),
+    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
+    managedSourceDirectories in Compile +=
+      baseDirectory.value / "src" / "main" / "contraband-scala",
+    contrabandFormatsForType in generateContrabands in Compile := { tpe =>
+      val old = (contrabandFormatsForType in generateContrabands in Compile).value
+      val name = tpe.removeTypeParameters.name
+      if (name == "Throwable") Nil
+      else old(tpe)
+    },
+    utilMimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.SuccessEvent.copy*"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.TraceEvent.copy*"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.StringEvent.copy*"),
+      // Private final class constructors changed
+      exclude[DirectMissingMethodProblem]("sbt.util.InterfaceUtil#ConcretePosition.this"),
+      exclude[DirectMissingMethodProblem]("sbt.util.InterfaceUtil#ConcreteProblem.this"),
+      exclude[ReversedMissingMethodProblem]("sbt.internal.util.ConsoleOut.flush"),
+      // This affects Scala 2.11 only it seems, so it's ok?
+      exclude[InheritedNewAbstractMethodProblem](
+        "sbt.internal.util.codec.JsonProtocol.LogOptionFormat"
+      ),
+      exclude[InheritedNewAbstractMethodProblem](
+        "sbt.internal.util.codec.JsonProtocol.ProgressItemFormat"
+      ),
+      exclude[InheritedNewAbstractMethodProblem](
+        "sbt.internal.util.codec.JsonProtocol.ProgressEventFormat"
+      ),
+      exclude[DirectMissingMethodProblem]("sbt.internal.util.MainAppender.*"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.BufferedAppender.*"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.ManagedLogger.this"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.ManagedLogger.this"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.MainAppender*"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.util.GlobalLogging.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.GlobalLogging.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.util.MainAppender*"),
+      exclude[MissingTypesProblem]("sbt.internal.util.ConsoleAppender"),
+      exclude[MissingTypesProblem]("sbt.internal.util.BufferedAppender"),
+    ),
+  )
+  .configure(addSbtIO)
+
+lazy val utilRelation = (project in file("internal") / "util-relation")
+  .settings(
+    utilCommonSettings,
+    name := "Util Relation",
+    libraryDependencies ++= Seq(scalacheck % "test"),
+    utilMimaSettings,
+  )
+
+// Persisted caching based on sjson-new
+lazy val utilCache = (project in file("util-cache"))
+  .settings(
+    utilCommonSettings,
+    name := "Util Cache",
+    libraryDependencies ++=
+      Seq(sjsonNewScalaJson.value, sjsonNewMurmurhash.value, scalaReflect.value),
+    libraryDependencies ++= Seq(scalatest % "test"),
+    utilMimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // Added a method to a sealed trait, technically not a problem for Scala
+      exclude[ReversedMissingMethodProblem]("sbt.util.HashFileInfo.hashArray"),
+    )
+  )
+  .configure(addSbtIO)
+
+// Builds on cache to provide caching for filesystem-related operations
+lazy val utilTracking = (project in file("util-tracking"))
+  .dependsOn(utilCache)
+  .settings(
+    utilCommonSettings,
+    name := "Util Tracking",
+    libraryDependencies ++= Seq(scalatest % "test"),
+    utilMimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // Private final class constructors changed
+      ProblemFilters.exclude[IncompatibleMethTypeProblem]("sbt.util.Tracked#CacheHelp.this"),
+    )
+  )
+  .configure(addSbtIO)
+
+lazy val utilScripted = (project in file("internal") / "util-scripted")
+  .dependsOn(utilLogging, utilInterface)
+  .settings(
+    utilCommonSettings,
+    name := "Util Scripted",
+    libraryDependencies += scalaParsers,
+    utilMimaSettings,
+  )
+  .configure(addSbtIO)
 /* **** Intermediate-level Modules **** */
 
 // Runner for uniform test interface
-lazy val testingProj = (project in file("testing")).
-  dependsOn(testAgentProj).
-  settings(
+lazy val testingProj = (project in file("testing"))
+  .enablePlugins(ContrabandPlugin, JsonCodecPlugin)
+  .dependsOn(testAgentProj, utilLogging)
+  .settings(
     baseSettings,
     name := "Testing",
-    libraryDependencies ++= Seq(sbtIO, testInterface,launcherInterface, compilerClasspath, utilLogging)
+    libraryDependencies ++= Seq(
+      scalaXml,
+      testInterface,
+      launcherInterface,
+      sjsonNewScalaJson.value
+    ),
+    Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
+    managedSourceDirectories in Compile +=
+      baseDirectory.value / "src" / "main" / "contraband-scala",
+    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
+    contrabandFormatsForType in generateContrabands in Compile := ContrabandConfig.getFormats,
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // private[sbt]
+      exclude[IncompatibleMethTypeProblem]("sbt.TestStatus.write"),
+      exclude[IncompatibleResultTypeProblem]("sbt.TestStatus.read"),
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupErrorEvent.copy"),
+      exclude[DirectMissingMethodProblem](
+        "sbt.protocol.testing.EndTestGroupErrorEvent.copy$default$*"
+      ),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.StartTestGroupEvent.copy"),
+      exclude[DirectMissingMethodProblem](
+        "sbt.protocol.testing.StartTestGroupEvent.copy$default$*"
+      ),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestCompleteEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestCompleteEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestInitEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemDetail.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemDetail.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestStringEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestStringEvent.copy$default$1"),
+      //no reason to use
+      exclude[DirectMissingMethodProblem]("sbt.JUnitXmlTestsListener.testSuite"),
+    )
   )
+  .configure(addSbtIO, addSbtCompilerClasspath)
 
 // Testing agent for running tests in a separate process.
-lazy val testAgentProj = (project in file("testing") / "agent").
-  settings(
+lazy val testAgentProj = (project in file("testing") / "agent")
+  .settings(
     minimalSettings,
-    crossScalaVersions := Seq(scala211),
+    crossScalaVersions := Seq(baseScalaVersion),
     crossPaths := false,
     autoScalaLibrary := false,
     name := "Test Agent",
-    libraryDependencies += testInterface
+    libraryDependencies += testInterface,
+    mimaSettings,
   )
 
 // Basic task engine
-lazy val taskProj = (project in file("tasks")).
-  settings(
+lazy val taskProj = (project in file("tasks"))
+  .dependsOn(collectionProj, utilControl)
+  .settings(
     testedBaseSettings,
     name := "Tasks",
-    libraryDependencies ++= Seq(utilControl, utilCollection)
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      exclude[IncompatibleSignatureProblem]("sbt.Triggers.this"),
+      exclude[IncompatibleSignatureProblem]("sbt.Triggers.runBefore"),
+      exclude[IncompatibleSignatureProblem]("sbt.Triggers.injectFor"),
+      exclude[IncompatibleSignatureProblem]("sbt.Triggers.onComplete"),
+      exclude[DirectMissingMethodProblem]("sbt.Inc.apply"),
+      // ok because sbt.ExecuteProgress has been under private[sbt]
+      exclude[IncompatibleResultTypeProblem]("sbt.ExecuteProgress.initial"),
+      exclude[DirectMissingMethodProblem]("sbt.ExecuteProgress.*"),
+      exclude[ReversedMissingMethodProblem]("sbt.ExecuteProgress.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.ExecuteProgress.*"),
+      // ok because sbt.Execute has been under private[sbt]
+      exclude[IncompatibleSignatureProblem]("sbt.Execute.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.Execute#CyclicException.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.NodeView.*"),
+    )
   )
 
 // Standard task system.  This provides map, flatMap, join, and more on top of the basic task model.
-lazy val stdTaskProj = (project in file("tasks-standard")).
-  dependsOn (taskProj % "compile;test->test").
-  settings(
+lazy val stdTaskProj = (project in file("tasks-standard"))
+  .dependsOn(collectionProj, utilLogging, utilCache)
+  .dependsOn(taskProj % "compile;test->test")
+  .settings(
     testedBaseSettings,
     name := "Task System",
     testExclusive,
-    libraryDependencies ++= Seq(utilCollection, utilLogging, sbtIO)
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // unused private[sbt]
+      exclude[DirectMissingMethodProblem]("sbt.Task.mapTask"),
+    ),
   )
+  .configure(addSbtIO)
 
 // Embedded Scala code runner
-lazy val runProj = (project in file("run")).
-  settings(
+lazy val runProj = (project in file("run"))
+  .enablePlugins(ContrabandPlugin)
+  .dependsOn(collectionProj, utilLogging, utilControl)
+  .settings(
     testedBaseSettings,
     name := "Run",
-    libraryDependencies ++= Seq(sbtIO,
-      utilLogging, compilerClasspath)
+    Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
+    managedSourceDirectories in Compile +=
+      baseDirectory.value / "src" / "main" / "contraband-scala",
+    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.ForkOptions.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.ForkOptions.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#BufferedOutput.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#BufferedOutput.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#CustomOutput.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#CustomOutput.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy$default$*"),
+    )
+  )
+  .configure(addSbtIO, addSbtCompilerClasspath)
+
+val sbtProjDepsCompileScopeFilter =
+  ScopeFilter(
+    inDependencies(LocalProject("sbtProj"), includeRoot = false),
+    inConfigurations(Compile)
   )
 
-lazy val scriptedSbtProj = (project in scriptedPath / "sbt").
-  dependsOn(commandProj).
-  settings(
+lazy val scriptedSbtReduxProj = (project in file("scripted-sbt-redux"))
+  .dependsOn(sbtProj % "compile;test->test", commandProj, utilLogging, utilScripted)
+  .settings(
+    baseSettings,
+    name := "Scripted sbt Redux",
+    libraryDependencies ++= Seq(launcherInterface % "provided"),
+    mimaSettings,
+    scriptedSbtReduxMimaSettings,
+  )
+  .configure(addSbtIO, addSbtCompilerInterface, addSbtLmCore)
+
+lazy val scriptedSbtOldProj = (project in file("scripted-sbt-old"))
+  .dependsOn(scriptedSbtReduxProj)
+  .settings(
     baseSettings,
     name := "Scripted sbt",
-    libraryDependencies ++= Seq(launcherInterface % "provided",
-      sbtIO, utilLogging, compilerInterface, utilScripted)
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // sbt.test package is renamed to sbt.scriptedtest.
+      exclude[MissingClassProblem]("sbt.test.*"),
+      exclude[DirectMissingMethodProblem]("sbt.test.*"),
+      exclude[IncompatibleMethTypeProblem]("sbt.test.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.test.*"),
+    ),
   )
 
-lazy val scriptedPluginProj = (project in scriptedPath / "plugin").
-  dependsOn(sbtProj).
-  settings(
+lazy val scriptedPluginProj = (project in file("scripted-plugin"))
+  .settings(
     baseSettings,
     name := "Scripted Plugin",
-    libraryDependencies ++= Seq(compilerClasspath)
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // scripted plugin has moved into sbt mothership.
+      exclude[MissingClassProblem]("sbt.ScriptedPlugin*")
+    ),
+  )
+
+lazy val dependencyTreeProj = (project in file("dependency-tree"))
+  .dependsOn(sbtProj)
+  .settings(
+    sbtPlugin := true,
+    baseSettings,
+    name := "sbt-dependency-tree",
+    publishMavenStyle := true,
+    // mimaSettings,
+    mimaPreviousArtifacts := Set.empty,
   )
 
 // Implementation and support code for defining actions.
-lazy val actionsProj = (project in file("main-actions")).
-  dependsOn(runProj, stdTaskProj, taskProj, testingProj).
-  settings(
+lazy val actionsProj = (project in file("main-actions"))
+  .dependsOn(
+    completeProj,
+    runProj,
+    stdTaskProj,
+    taskProj,
+    testingProj,
+    utilLogging,
+    utilRelation,
+    utilTracking,
+  )
+  .settings(
     testedBaseSettings,
     name := "Actions",
-    libraryDependencies ++= Seq(compilerClasspath, utilCompletion, compilerApiInfo,
-      zinc, compilerIvyIntegration, compilerInterface,
-      sbtIO, utilLogging, utilRelation, libraryManagement, utilTracking)
+    libraryDependencies += sjsonNewScalaJson.value,
+    libraryDependencies += jline3Terminal,
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // Removed unused private[sbt] nested class
+      exclude[MissingClassProblem]("sbt.Doc$Scaladoc"),
+      // Removed no longer used private[sbt] method
+      exclude[DirectMissingMethodProblem]("sbt.Doc.generate"),
+      exclude[DirectMissingMethodProblem]("sbt.compiler.Eval.filesModifiedBytes"),
+      exclude[DirectMissingMethodProblem]("sbt.compiler.Eval.fileModifiedBytes"),
+    ),
+  )
+  .configure(
+    addSbtIO,
+    addSbtCompilerInterface,
+    addSbtCompilerClasspath,
+    addSbtCompilerApiInfo,
+    addSbtLmCore,
+    addSbtZinc
+  )
+
+lazy val protocolProj = (project in file("protocol"))
+  .enablePlugins(ContrabandPlugin, JsonCodecPlugin)
+  .dependsOn(collectionProj, utilLogging)
+  .settings(
+    testedBaseSettings,
+    name := "Protocol",
+    libraryDependencies ++= Seq(sjsonNewScalaJson.value, ipcSocket),
+    Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
+    managedSourceDirectories in Compile +=
+      baseDirectory.value / "src" / "main" / "contraband-scala",
+    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
+    contrabandFormatsForType in generateContrabands in Compile := ContrabandConfig.getFormats,
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ChannelAcceptedEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ChannelAcceptedEvent.copy$default$1"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy$default$1"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy$default$2"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecStatusEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecStatusEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecutionEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecutionEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.InitCommand.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.InitCommand.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.LogEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.LogEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuery.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuery.copy$default$1"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQueryFailure.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQueryFailure.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuerySuccess.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuerySuccess.copy$default$*"),
+      // ignore missing or incompatible methods in sbt.internal
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.*"),
+      exclude[DirectMissingMethodProblem]("sbt.internal.*"),
+      exclude[MissingTypesProblem]("sbt.internal.protocol.JsonRpcResponseError"),
+    )
   )
 
 // General command support and core commands not specific to a build system
-lazy val commandProj = (project in file("main-command")).
-  enablePlugins(DatatypePlugin, JsonCodecPlugin).
-  settings(
+lazy val commandProj = (project in file("main-command"))
+  .enablePlugins(ContrabandPlugin, JsonCodecPlugin)
+  .dependsOn(protocolProj, completeProj, utilLogging)
+  .settings(
     testedBaseSettings,
     name := "Command",
-    libraryDependencies ++= Seq(launcherInterface, compilerInterface,
-      sbtIO, utilLogging, utilCompletion, compilerClasspath, sjsonNewScalaJson),
-    sourceManaged in (Compile, generateDatatypes) := baseDirectory.value / "src" / "main" / "datatype-scala"
+    libraryDependencies ++= Seq(launcherInterface, sjsonNewScalaJson.value, templateResolverApi),
+    Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
+    managedSourceDirectories in Compile +=
+      baseDirectory.value / "src" / "main" / "contraband-scala",
+    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
+    contrabandFormatsForType in generateContrabands in Compile := ContrabandConfig.getFormats,
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Vector(
+      exclude[DirectMissingMethodProblem]("sbt.Exit.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.Reboot.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.TemplateResolverInfo.apply"),
+      // dropped private[sbt] method
+      exclude[DirectMissingMethodProblem]("sbt.BasicCommands.compatCommands"),
+      // dropped mainly internal command strings holder
+      exclude[MissingClassProblem]("sbt.BasicCommandStrings$Compat$"),
+      exclude[DirectMissingMethodProblem]("sbt.BasicCommands.rebootOptionParser"),
+      // Changed the signature of Server method. nacho cheese.
+      exclude[DirectMissingMethodProblem]("sbt.internal.server.Server.*"),
+      // Added method to ServerInstance. This is also internal.
+      exclude[ReversedMissingMethodProblem]("sbt.internal.server.ServerInstance.*"),
+      // Added method to CommandChannel. internal.
+      exclude[ReversedMissingMethodProblem]("sbt.internal.CommandChannel.*"),
+      // Added an overload to reboot. The overload is private[sbt].
+      exclude[ReversedMissingMethodProblem]("sbt.StateOps.reboot"),
+      // Replace nailgun socket stuff
+      exclude[MissingClassProblem]("sbt.internal.NG*"),
+      exclude[MissingClassProblem]("sbt.internal.ReferenceCountedFileDescriptor"),
+      // made private[sbt] method private[this]
+      exclude[DirectMissingMethodProblem]("sbt.State.handleException"),
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.CommandSource.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.CommandSource.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.Exec.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.Exec.copy$default$*"),
+      // internal
+      exclude[ReversedMissingMethodProblem]("sbt.internal.client.ServerConnection.*"),
+      exclude[MissingTypesProblem]("sbt.internal.server.ServerConnection*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.server.ServerConnection.*")
+    ),
+    unmanagedSources in (Compile, headerCreate) := {
+      val old = (unmanagedSources in (Compile, headerCreate)).value
+      old filterNot { x =>
+        (x.getName startsWith "NG") || (x.getName == "ReferenceCountedFileDescriptor.java")
+      }
+    },
+  )
+  .configure(
+    addSbtIO,
+    addSbtCompilerInterface,
+    addSbtCompilerClasspath,
+    addSbtLmCore,
+    addSbtZinc
+  )
+
+// The core macro project defines the main logic of the DSL, abstracted
+// away from several sbt implementors (tasks, settings, et cetera).
+lazy val coreMacrosProj = (project in file("core-macros"))
+  .dependsOn(collectionProj)
+  .settings(
+    baseSettings :+ (crossScalaVersions := (scala212 :: scala213 :: Nil)),
+    name := "Core Macros",
+    libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value,
+    SettingKey[Boolean]("exportPipelining") := false,
+    mimaSettings,
   )
 
 // Fixes scope=Scope for Setting (core defined in collectionProj) to define the settings system used in build definitions
-lazy val mainSettingsProj = (project in file("main-settings")).
-  dependsOn(commandProj, stdTaskProj).
-  settings(
+lazy val mainSettingsProj = (project in file("main-settings"))
+  .dependsOn(
+    completeProj,
+    commandProj,
+    stdTaskProj,
+    coreMacrosProj,
+    utilLogging,
+    utilCache,
+    utilRelation,
+  )
+  .settings(
     testedBaseSettings,
     name := "Main Settings",
-    libraryDependencies ++= Seq(utilCache, utilApplyMacro, compilerInterface, utilRelation,
-      utilLogging, sbtIO, utilCompletion, compilerClasspath, libraryManagement)
+    testOptions in Test ++= {
+      val cp = (Test / fullClasspathAsJars).value.map(_.data).mkString(java.io.File.pathSeparator)
+      val framework = TestFrameworks.ScalaTest
+      Tests.Argument(framework, s"-Dsbt.server.classpath=$cp") ::
+        Tests.Argument(framework, s"-Dsbt.server.version=${version.value}") ::
+        Tests.Argument(framework, s"-Dsbt.server.scala.version=${scalaVersion.value}") :: Nil
+    },
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      exclude[IncompatibleSignatureProblem]("sbt.Previous#References.getReferences"),
+      exclude[IncompatibleSignatureProblem]("sbt.Def.delegate"),
+      exclude[IncompatibleSignatureProblem]("sbt.Def.add"),
+      exclude[IncompatibleSignatureProblem]("sbt.Def.grouped"),
+      exclude[IncompatibleSignatureProblem]("sbt.Def.compile"),
+      exclude[IncompatibleSignatureProblem]("sbt.Def.asTransform"),
+      exclude[DirectMissingMethodProblem]("sbt.Def.StaticScopes"),
+      exclude[IncompatibleSignatureProblem]("sbt.Previous.this"),
+      exclude[DirectMissingMethodProblem]("sbt.BuildRef.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.ScopeMask.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.Def.intersect"),
+      exclude[DirectMissingMethodProblem]("sbt.LocalProject.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.pure"),
+      exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.flatten"),
+      exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.map"),
+      exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.app"),
+      exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.pure"),
+      exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.map"),
+      exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.app"),
+      exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.pure"),
+      exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.pure"),
+      exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.flatten"),
+      exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.map"),
+      exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.app"),
+      exclude[DirectMissingMethodProblem]("sbt.std.FullInstance.flatten"),
+      exclude[DirectMissingMethodProblem]("sbt.Scope.display012StyleMasked"),
+      // added a method to a sealed trait
+      exclude[InheritedNewAbstractMethodProblem]("sbt.Scoped.canEqual"),
+      exclude[InheritedNewAbstractMethodProblem]("sbt.ScopedTaskable.canEqual"),
+      // widened ScopedTaskable parameter to (new) supertype Taskable
+      exclude[IncompatibleSignatureProblem]("sbt.Scoped#RichTaskable*.this"),
+      exclude[IncompatibleSignatureProblem]("sbt.TupleSyntax.t*ToTable*"),
+    ),
+  )
+  .configure(
+    addSbtIO,
+    addSbtCompilerInterface,
+    addSbtCompilerClasspath,
+    addSbtLmCore
   )
 
-// The main integration project for sbt.  It brings all of the Projsystems together, configures them, and provides for overriding conventions.
-lazy val mainProj = (project in file("main")).
-  dependsOn(actionsProj, mainSettingsProj, runProj, commandProj).
-  settings(
+lazy val zincLmIntegrationProj = (project in file("zinc-lm-integration"))
+  .settings(
+    name := "Zinc LM Integration",
+    testedBaseSettings,
+    testOptions in Test +=
+      Tests.Argument(TestFrameworks.ScalaTest, s"-Dsbt.zinc.version=$zincVersion"),
+    mimaSettingsSince(sbt13Plus),
+    mimaBinaryIssueFilters ++= Seq(
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.inc.ZincComponentCompiler*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.inc.ZincComponentCompiler*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.inc.ZincLMHelper.update"),
+    ),
+    libraryDependencies += launcherInterface,
+  )
+  .configure(addSbtZincCompileCore, addSbtLmCore, addSbtLmIvyTest)
+
+// The main integration project for sbt.  It brings all of the projects together, configures them, and provides for overriding conventions.
+lazy val mainProj = (project in file("main"))
+  .enablePlugins(ContrabandPlugin)
+  .dependsOn(
+    logicProj,
+    actionsProj,
+    mainSettingsProj,
+    runProj,
+    commandProj,
+    collectionProj,
+    scriptedPluginProj,
+    zincLmIntegrationProj,
+    utilLogging,
+  )
+  .settings(
     testedBaseSettings,
     name := "Main",
-    libraryDependencies ++= scalaXml.value ++ Seq(launcherInterface, compilerInterface,
-      sbtIO, utilLogging, utilLogic, libraryManagement, zincCompile)
+    checkPluginCross := {
+      val sv = scalaVersion.value
+      val f = baseDirectory.value / "src" / "main" / "scala" / "sbt" / "PluginCross.scala"
+      if (sv.startsWith("2.12") && !IO.readLines(f).exists(_.contains(s""""$sv""""))) {
+        sys.error(s"PluginCross.scala does not match up with the scalaVersion $sv")
+      }
+    },
+    libraryDependencies ++=
+      (Seq(scalaXml, launcherInterface, caffeine, lmCoursierShaded) ++ log4jModules),
+    libraryDependencies ++= (scalaVersion.value match {
+      case v if v.startsWith("2.12.") => List()
+      case _                          => List(scalaPar)
+    }),
+    managedSourceDirectories in Compile +=
+      baseDirectory.value / "src" / "main" / "contraband-scala",
+    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
+    testOptions in Test += Tests
+      .Argument(TestFrameworks.ScalaCheck, "-minSuccessfulTests", "1000"),
+    SettingKey[Boolean]("usePipelining") := false,
+    mimaSettings,
+    mimaBinaryIssueFilters ++= Vector(
+      // New and changed methods on KeyIndex. internal.
+      exclude[ReversedMissingMethodProblem]("sbt.internal.KeyIndex.*"),
+      // internal
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.*"),
+      // Changed signature or removed private[sbt] methods
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.unmanagedLibs0"),
+      exclude[DirectMissingMethodProblem]("sbt.Defaults.allTestGroupsTask"),
+      exclude[DirectMissingMethodProblem]("sbt.Plugins.topologicalSort"),
+      exclude[IncompatibleMethTypeProblem]("sbt.Defaults.allTestGroupsTask"),
+      exclude[DirectMissingMethodProblem]("sbt.StandardMain.shutdownHook"),
+      exclude[DirectMissingMethodProblem]("sbt.nio.Keys.compileBinaryFileInputs"),
+      exclude[DirectMissingMethodProblem]("sbt.nio.Keys.compileSourceFileInputs"),
+      exclude[MissingClassProblem]("sbt.internal.ResourceLoaderImpl"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.ConfigIndex.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.Inspect.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.ProjectIndex.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.BuildIndex.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.server.BuildServerReporter.*"),
+      exclude[VirtualStaticMemberProblem]("sbt.internal.server.LanguageServerProtocol.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.librarymanagement.IvyXml.*"),
+      exclude[IncompatibleSignatureProblem]("sbt.ScriptedPlugin.*Settings"),
+      exclude[IncompatibleSignatureProblem]("sbt.plugins.SbtPlugin.*Settings"),
+      // Removed private internal classes
+      exclude[MissingClassProblem]("sbt.internal.ReverseLookupClassLoaderHolder$BottomClassLoader"),
+      exclude[MissingClassProblem](
+        "sbt.internal.ReverseLookupClassLoaderHolder$ReverseLookupClassLoader$ResourceLoader"
+      ),
+      exclude[MissingClassProblem]("sbt.internal.ReverseLookupClassLoaderHolder$ClassLoadingLock"),
+      exclude[MissingClassProblem](
+        "sbt.internal.ReverseLookupClassLoaderHolder$ReverseLookupClassLoader"
+      ),
+      exclude[MissingClassProblem]("sbt.internal.LayeredClassLoaderImpl"),
+      exclude[MissingClassProblem]("sbt.internal.FileManagement"),
+      exclude[MissingClassProblem]("sbt.internal.FileManagement$"),
+      exclude[MissingClassProblem]("sbt.internal.FileManagement$CopiedFileTreeRepository"),
+      exclude[MissingClassProblem]("sbt.internal.server.LanguageServerReporter*"),
+      exclude[MissingClassProblem]("sbt.internal.ExternalHooks"),
+      exclude[MissingClassProblem]("sbt.internal.ExternalHooks$"),
+      // false positives
+      exclude[DirectMissingMethodProblem]("sbt.plugins.IvyPlugin.requires"),
+      exclude[DirectMissingMethodProblem]("sbt.plugins.JUnitXmlReportPlugin.requires"),
+      exclude[DirectMissingMethodProblem]("sbt.plugins.Giter8TemplatePlugin.requires"),
+      exclude[DirectMissingMethodProblem]("sbt.plugins.JvmPlugin.requires"),
+      exclude[DirectMissingMethodProblem]("sbt.plugins.SbtPlugin.requires"),
+      exclude[DirectMissingMethodProblem]("sbt.ResolvedClasspathDependency.apply"),
+      exclude[DirectMissingMethodProblem]("sbt.ClasspathDependency.apply"),
+      exclude[IncompatibleSignatureProblem]("sbt.plugins.SemanticdbPlugin.globalSettings"),
+      // File -> Source
+      exclude[DirectMissingMethodProblem]("sbt.Defaults.cleanFilesTask"),
+      exclude[IncompatibleSignatureProblem]("sbt.Defaults.resourceConfigPaths"),
+      exclude[IncompatibleSignatureProblem]("sbt.Defaults.sourceConfigPaths"),
+      exclude[IncompatibleSignatureProblem]("sbt.Defaults.configPaths"),
+      exclude[IncompatibleSignatureProblem]("sbt.Defaults.paths"),
+      exclude[IncompatibleSignatureProblem]("sbt.Keys.csrPublications"),
+      exclude[IncompatibleSignatureProblem](
+        "sbt.coursierint.CoursierArtifactsTasks.coursierPublicationsTask"
+      ),
+      exclude[IncompatibleSignatureProblem](
+        "sbt.coursierint.CoursierArtifactsTasks.coursierPublicationsTask"
+      ),
+      exclude[IncompatibleSignatureProblem]("sbt.coursierint.LMCoursier.coursierConfiguration"),
+      exclude[IncompatibleSignatureProblem]("sbt.coursierint.LMCoursier.publicationsSetting"),
+      exclude[IncompatibleSignatureProblem]("sbt.Project.inThisBuild"),
+      exclude[IncompatibleSignatureProblem]("sbt.Project.inConfig"),
+      exclude[IncompatibleSignatureProblem]("sbt.Project.inTask"),
+      exclude[IncompatibleSignatureProblem]("sbt.Project.inScope"),
+      exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inThisBuild"),
+      exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inConfig"),
+      exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inTask"),
+      exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inScope"),
+      exclude[MissingTypesProblem]("sbt.internal.Load*"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.Load*"),
+      exclude[MissingTypesProblem]("sbt.internal.server.NetworkChannel"),
+      // IvyConfiguration was replaced by InlineIvyConfiguration in the generic
+      // signature, this does not break compatibility regardless of what
+      // cast a compiler might have inserted based on the old signature
+      // since we're returning the same values as before.
+      exclude[IncompatibleSignatureProblem]("sbt.Classpaths.mkIvyConfiguration"),
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.server.Definition*"),
+      exclude[IncompatibleTemplateDefProblem]("sbt.internal.server.LanguageServerProtocol"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.warnInsecureProtocol"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.warnInsecureProtocolInModules"),
+      exclude[MissingClassProblem]("sbt.internal.ExternalHooks*"),
+      // This seems to be a mima problem. The older constructor still exists but
+      // mima seems to incorrectly miss the secondary constructor that provides
+      // the binary compatible version.
+      exclude[IncompatibleMethTypeProblem]("sbt.internal.server.NetworkChannel.this"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.DeprecatedContinuous.taskDefinitions"),
+      exclude[MissingClassProblem]("sbt.internal.SettingsGraph*"),
+      // Tasks include non-Files, but it's ok
+      exclude[IncompatibleSignatureProblem]("sbt.Defaults.outputConfigPaths"),
+      // private[sbt]
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.trackedExportedProducts"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.trackedExportedJarProducts"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.unmanagedDependencies0"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.internalDependenciesImplTask"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.internalDependencyJarsImplTask"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.interDependencies"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.productsTask"),
+      exclude[DirectMissingMethodProblem]("sbt.Classpaths.jarProductsTask"),
+      exclude[DirectMissingMethodProblem]("sbt.StandardMain.cache"),
+      // internal logging apis,
+      exclude[IncompatibleSignatureProblem]("sbt.internal.LogManager*"),
+      exclude[MissingTypesProblem]("sbt.internal.RelayAppender"),
+      exclude[MissingClassProblem]("sbt.internal.TaskProgress$ProgressThread"),
+      // internal implementation
+      exclude[MissingClassProblem](
+        "sbt.internal.XMainConfiguration$ModifiedConfiguration$ModifiedAppProvider$ModifiedScalaProvider$"
+      ),
+      // internal impl
+      exclude[IncompatibleSignatureProblem]("sbt.internal.Act.configIdent"),
+      exclude[IncompatibleSignatureProblem]("sbt.internal.Act.taskAxis"),
+      // private[sbt] method, used to call the correct sourcePositionMapper
+      exclude[DirectMissingMethodProblem]("sbt.Defaults.foldMappers"),
+    )
+  )
+  .configure(
+    addSbtIO,
+    addSbtLmCore,
+    addSbtLmIvy,
+    addSbtCompilerInterface,
+    addSbtZincCompile
   )
 
 // Strictly for bringing implicits and aliases from subsystems into the top-level sbt namespace through a single package object
 //  technically, we need a dependency on all of mainProj's dependencies, but we don't do that since this is strictly an integration project
 //  with the sole purpose of providing certain identifiers without qualification (with a package object)
-lazy val sbtProj = (project in file("sbt")).
-  dependsOn(mainProj, scriptedSbtProj % "test->test").
-  settings(
-    baseSettings,
+lazy val sbtProj = (project in file("sbt"))
+  .dependsOn(mainProj)
+  .settings(
+    testedBaseSettings,
     name := "sbt",
     normalizedName := "sbt",
-    crossScalaVersions := Seq(scala211),
+    version := {
+      if (scalaVersion.value == baseScalaVersion) version.value
+      else version2_13.value
+    },
+    crossScalaVersions := Seq(baseScalaVersion),
     crossPaths := false,
-    libraryDependencies ++= Seq(compilerBrdige)
+    crossTarget := { target.value / scalaVersion.value },
+    javaOptions ++= Seq("-Xdebug", "-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005"),
+    mimaSettings,
+    mimaBinaryIssueFilters ++= sbtIgnoredProblems,
+  )
+  .settings(
+    Test / run / connectInput := true,
+    Test / run / outputStrategy := Some(StdoutOutput),
+    Test / run / fork := true,
+    testOptions in Test ++= {
+      val cp = (Test / fullClasspathAsJars).value.map(_.data).mkString(java.io.File.pathSeparator)
+      val framework = TestFrameworks.ScalaTest
+      Tests.Argument(framework, s"-Dsbt.server.classpath=$cp") ::
+        Tests.Argument(framework, s"-Dsbt.server.version=${version.value}") ::
+        Tests.Argument(framework, s"-Dsbt.server.scala.version=${scalaVersion.value}") :: Nil
+    },
+  )
+  .configure(addSbtIO, addSbtCompilerBridge)
+
+lazy val serverTestProj = (project in file("server-test"))
+  .dependsOn(sbtProj % "compile->test", scriptedSbtReduxProj % "compile->test")
+  .settings(
+    testedBaseSettings,
+    crossScalaVersions := Seq(baseScalaVersion),
+    publish / skip := true,
+    // make server tests serial
+    Test / watchTriggers += baseDirectory.value.toGlob / "src" / "server-test" / **,
+    Test / parallelExecution := false,
+    Test / run / connectInput := true,
+    Test / run / outputStrategy := Some(StdoutOutput),
+    Test / run / fork := true,
+    Test / sourceGenerators += Def.task {
+      val rawClasspath =
+        (Compile / fullClasspathAsJars).value.map(_.data).mkString(java.io.File.pathSeparator)
+      val cp =
+        if (scala.util.Properties.isWin) rawClasspath.replaceAllLiterally("\\", "\\\\")
+        else rawClasspath
+      val content = {
+        s"""|
+            |package testpkg
+            |
+            |object TestProperties {
+            |  val classpath = "$cp"
+            |  val version = "${version.value}"
+            |  val scalaVersion = "${scalaVersion.value}"
+            |}
+          """.stripMargin
+      }
+      val file = (Test / target).value / "generated" / "src" / "test" / "scala" / "testpkg" / "TestProperties.scala"
+      IO.write(file, content)
+      file :: Nil
+    },
   )
 
-def scriptedTask: Def.Initialize[InputTask[Unit]] = Def.inputTask {
-  val result = scriptedSource(dir => (s: State) => Scripted.scriptedParser(dir)).parsed
-  publishLocalBinAll.value
-  // These two projects need to be visible in a repo even if the default
-  // local repository is hidden, so we publish them to an alternate location and add
-  // that alternate repo to the running scripted test (in Scripted.scriptedpreScripted).
-  // (altLocalPublish in interfaceProj).value
-  // (altLocalPublish in compileInterfaceProj).value
-  Scripted.doScripted((sbtLaunchJar in bundledLauncherProj).value, (fullClasspath in scriptedSbtProj in Test).value,
-    (scalaInstance in scriptedSbtProj).value,
-    scriptedSource.value, scriptedBufferLog.value, result, scriptedPrescripted.value, scriptedLaunchOpts.value)
+val isWin = scala.util.Properties.isWin
+val buildThinClient =
+  inputKey[JPath]("generate a java implementation of the thin client")
+val thinClientClasspath =
+  taskKey[Seq[JPath]]("Generate the classpath for thin client (compacted for windows)")
+val thinClientNativeImageCommand = taskKey[String]("The native image command")
+val thinClientNativeImageOptions = settingKey[Seq[String]]("The native image options")
+val thinClientNativeImageClass = settingKey[String]("The class for the native image")
+val buildNativeThinClient = taskKey[JPath]("Generate a native executable")
+// Use a TaskKey rather than SettingKey for nativeInstallDirectory so it can left unset by default
+val nativeInstallDirectory = taskKey[JPath]("The install directory for the native executable")
+val installNativeThinClient = inputKey[JPath]("Install the native executable")
+val nativeThinClientPath = settingKey[JPath]("The location of the native executable")
+lazy val sbtClientProj = (project in file("client"))
+  .dependsOn(commandProj)
+  .settings(
+    commonBaseSettings,
+    scalaVersion := "2.12.11", // The thin client does not build with 2.12.12
+    publish / skip := true,
+    name := "sbt-client",
+    mimaPreviousArtifacts := Set.empty,
+    crossPaths := false,
+    exportJars := true,
+    libraryDependencies += jansi,
+    libraryDependencies += scalatest % "test",
+    /*
+     * On windows, the raw classpath is too large to be a command argument to an
+     * external process so we create symbolic links with short names to get the
+     * classpath length under the limit.
+     */
+    thinClientClasspath := {
+      val original = (Compile / fullClasspathAsJars).value.map(_.data)
+      val outputDir = target.value / "thinclientcp"
+      IO.createDirectory(outputDir)
+      Files.walk(outputDir.toPath).forEach {
+        case f if f.getFileName.toString.endsWith(".jar") => Files.deleteIfExists(f)
+        case _                                            =>
+      }
+      original.zipWithIndex.map {
+        case (f, i) => Files.createSymbolicLink(outputDir.toPath / s"$i.jar", f.toPath)
+      }
+    },
+    thinClientNativeImageCommand := System.getProperty("sbt.native-image", "native-image").toString,
+    buildNativeThinClient / name := s"sbtn${if (isWin) ".exe" else ""}",
+    nativeThinClientPath := target.value.toPath / "bin" / (buildNativeThinClient / name).value,
+    thinClientNativeImageClass := "sbt.client.Client",
+    buildNativeThinClient := {
+      val hasChanges = thinClientClasspath.outputFileChanges.hasChanges
+      val cpString =
+        thinClientClasspath.value.map(_.getFileName).mkString(java.io.File.pathSeparator)
+      val prefix = Seq(thinClientNativeImageCommand.value, "-cp", cpString)
+      val full = prefix ++ thinClientNativeImageOptions.value :+ thinClientNativeImageClass.value
+      val dir = target.value
+      if (hasChanges || !Files.exists(nativeThinClientPath.value)) {
+        val pb = new java.lang.ProcessBuilder(full: _*)
+        pb.directory(dir / "thinclientcp")
+        val proc = pb.start()
+        val thread = new Thread {
+          setDaemon(true)
+          val is = proc.getInputStream
+          val es = proc.getErrorStream
+
+          override def run(): Unit = {
+            Thread.sleep(100)
+            while (proc.isAlive) {
+              if (is.available > 0 || es.available > 0) {
+                while (is.available > 0) System.out.print(is.read.toChar)
+                while (es.available > 0) System.err.print(es.read.toChar)
+              }
+              if (proc.isAlive) Thread.sleep(10)
+            }
+          }
+        }
+        thread.start()
+        proc.waitFor(5, java.util.concurrent.TimeUnit.MINUTES)
+        assert(proc.exitValue == 0, s"Exit value ${proc.exitValue} was nonzero")
+      }
+      nativeThinClientPath.value
+    },
+    thinClientNativeImageOptions := Seq(
+      "--no-fallback",
+      s"--initialize-at-run-time=sbt.client",
+      "--verbose",
+      "-H:IncludeResourceBundles=jline.console.completer.CandidateListCompletionHandler",
+      "-H:+ReportExceptionStackTraces",
+      "-H:-ParseRuntimeOptions",
+      s"-H:Name=${target.value / "bin" / "sbtn"}",
+    ),
+    buildThinClient := {
+      val isFish = Def.spaceDelimited("").parsed.headOption.fold(false)(_ == "--fish")
+      val ext = if (isWin) ".bat" else if (isFish) ".fish" else ".sh"
+      val output = target.value.toPath / "bin" / s"${if (isFish) "fish-" else ""}client$ext"
+      java.nio.file.Files.createDirectories(output.getParent)
+      val cp = (Compile / fullClasspathAsJars).value.map(_.data)
+      val args =
+        if (isWin) "%*" else if (isFish) s"$$argv" else s"$$*"
+      java.nio.file.Files.write(
+        output,
+        s"""
+        |${if (isWin) "@echo off" else s"#!/usr/bin/env ${if (isFish) "fish" else "sh"}"}
+        |
+        |java -cp ${cp.mkString(java.io.File.pathSeparator)} sbt.client.Client --jna $args
+        """.stripMargin.linesIterator.toSeq.tail.mkString("\n").getBytes
+      )
+      output.toFile.setExecutable(true)
+      output
+    },
+  )
+
+/*
+lazy val sbtBig = (project in file(".big"))
+  .dependsOn(sbtProj)
+  .settings(
+    name := "sbt-big",
+    normalizedName := "sbt-big",
+    crossPaths := false,
+    assemblyShadeRules.in(assembly) := {
+      val packagesToBeShaded = Seq(
+        "fastparse",
+        "jawn",
+        "scalapb",
+      )
+      packagesToBeShaded.map( prefix => {
+        ShadeRule.rename(s"$prefix.**" -> s"sbt.internal.$prefix.@1").inAll
+      })
+    },
+    assemblyMergeStrategy in assembly := {
+      case "LICENSE" | "NOTICE" => MergeStrategy.first
+      case x => (assemblyMergeStrategy in assembly).value(x)
+    },
+    artifact.in(Compile, packageBin) := artifact.in(Compile, assembly).value,
+    assemblyOption.in(assembly) ~= { _.copy(includeScala = false) },
+    addArtifact(artifact.in(Compile, packageBin), assembly),
+    pomPostProcess := { node =>
+      new RuleTransformer(new RewriteRule {
+        override def transform(node: XmlNode): XmlNodeSeq = node match {
+          case e: Elem if node.label == "dependency" =>
+            Comment(
+              "the dependency that was here has been absorbed via sbt-assembly"
+            )
+          case _ => node
+        }
+      }).transform(node).head
+    },
+  )
+ */
+
+// util projects used by Zinc and Lm
+lazy val lowerUtils = (project in (file("internal") / "lower"))
+  .aggregate(lowerUtilProjects.map(p => LocalProject(p.id)): _*)
+  .settings(
+    publish / skip := true,
+    crossScalaVersions := Nil,
+  )
+
+lazy val upperModules = (project in (file("internal") / "upper"))
+  .aggregate(
+    ((allProjects diff lowerUtilProjects)
+      diff Seq(bundledLauncherProj)).map(p => LocalProject(p.id)): _*
+  )
+  .settings(
+    publish / skip := true,
+    crossScalaVersions := Nil,
+  )
+
+lazy val sbtIgnoredProblems = {
+  Vector(
+    exclude[IncompatibleSignatureProblem]("sbt.package.some"),
+    exclude[IncompatibleSignatureProblem]("sbt.package.inThisBuild"),
+    exclude[IncompatibleSignatureProblem]("sbt.package.inConfig"),
+    exclude[IncompatibleSignatureProblem]("sbt.package.inTask"),
+    exclude[IncompatibleSignatureProblem]("sbt.package.inScope"),
+    exclude[MissingClassProblem]("buildinfo.BuildInfo"),
+    exclude[MissingClassProblem]("buildinfo.BuildInfo$"),
+    // Added more items to Import trait.
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$WatchSource_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.WatchSource"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.AnyPath"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$**_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$*_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$ChangedFiles_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$AnyPath_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$Glob_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$RecursiveGlob_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$RelativeGlob_="),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.*"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.**"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.ChangedFiles"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.RecursiveGlob"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.Glob"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.RelativeGlob"),
+    // Dropped in favour of kind-projector's polymorphic lambda literals
+    exclude[DirectMissingMethodProblem]("sbt.Import.Param"),
+    exclude[DirectMissingMethodProblem]("sbt.package.Param"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.SemanticSelector"),
+    exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$SemanticSelector_="),
+    // Dropped in favour of plain scala.Function, and its compose method
+    exclude[DirectMissingMethodProblem]("sbt.package.toFn1"),
+  )
 }
 
-def scriptedUnpublishedTask: Def.Initialize[InputTask[Unit]] = Def.inputTask {
-  val result = scriptedSource(dir => (s: State) => Scripted.scriptedParser(dir)).parsed
-  Scripted.doScripted((sbtLaunchJar in bundledLauncherProj).value, (fullClasspath in scriptedSbtProj in Test).value,
-    (scalaInstance in scriptedSbtProj).value,
-    scriptedSource.value, scriptedBufferLog.value, result, scriptedPrescripted.value, scriptedLaunchOpts.value)
+def runNpm(command: String, base: File, log: sbt.internal.util.ManagedLogger) = {
+  import scala.sys.process._
+  try {
+    val exitCode = Process(s"npm $command", Option(base)) ! log
+    if (exitCode != 0) throw new Exception("Process returned exit code: " + exitCode)
+  } catch {
+    case e: java.io.IOException => log.warn("failed to run npm " + e.getMessage)
+  }
+}
+
+lazy val vscodePlugin = (project in file("vscode-sbt-scala"))
+  .settings(
+    bspEnabled := false,
+    crossPaths := false,
+    crossScalaVersions := Seq(baseScalaVersion),
+    skip in publish := true,
+    compile in Compile := {
+      val _ = update.value
+      runNpm("run compile", baseDirectory.value, streams.value.log)
+      sbt.internal.inc.Analysis.empty
+    },
+    update := {
+      val old = update.value
+      val t = target.value / "updated"
+      val base = baseDirectory.value
+      val log = streams.value.log
+      if (t.exists) ()
+      else {
+        runNpm("install", base, log)
+        IO.touch(t)
+      }
+      old
+    },
+    cleanFiles ++= {
+      val base = baseDirectory.value
+      Vector(
+        target.value / "updated",
+        base / "node_modules",
+        base / "client" / "node_modules",
+        base / "client" / "server",
+        base / "client" / "out",
+        base / "server" / "node_modules"
+      ) filter { _.exists }
+    }
+  )
+
+def scriptedTask(launch: Boolean): Def.Initialize[InputTask[Unit]] = Def.inputTask {
+  val _ = publishLocalBinAll.value
+  val launchJar = s"-Dsbt.launch.jar=${(bundledLauncherProj / Compile / packageBin).value}"
+  Scripted.doScripted(
+    (scalaInstance in scriptedSbtReduxProj).value,
+    scriptedSource.value,
+    scriptedBufferLog.value,
+    Def.setting(Scripted.scriptedParser(scriptedSource.value)).parsed,
+    scriptedPrescripted.value,
+    scriptedLaunchOpts.value ++ (if (launch) Some(launchJar) else None),
+    scalaVersion.value,
+    version.value,
+    (scriptedSbtReduxProj / Test / fullClasspathAsJars).value
+      .map(_.data)
+      .filterNot(_.getName.contains("scala-compiler")),
+    streams.value.log
+  )
 }
 
 lazy val publishLauncher = TaskKey[Unit]("publish-launcher")
 
-lazy val myProvided = config("provided") intransitive
+def allProjects =
+  Seq(
+    logicProj,
+    completeProj,
+    testingProj,
+    testAgentProj,
+    taskProj,
+    stdTaskProj,
+    runProj,
+    scriptedSbtReduxProj,
+    scriptedSbtOldProj,
+    scriptedPluginProj,
+    dependencyTreeProj,
+    protocolProj,
+    actionsProj,
+    commandProj,
+    mainSettingsProj,
+    zincLmIntegrationProj,
+    mainProj,
+    sbtProj,
+    bundledLauncherProj,
+    sbtClientProj,
+  ) ++ lowerUtilProjects
 
-def allProjects = Seq(
-  testingProj, testAgentProj, taskProj, stdTaskProj, runProj,
-  scriptedSbtProj, scriptedPluginProj,
-  actionsProj, commandProj, mainSettingsProj, mainProj, sbtProj, bundledLauncherProj)
+// These need to be cross published to 2.12 and 2.13 for Zinc
+lazy val lowerUtilProjects =
+  Seq(
+    collectionProj,
+    coreMacrosProj,
+    utilCache,
+    utilControl,
+    utilInterface,
+    utilLogging,
+    utilPosition,
+    utilRelation,
+    utilScripted,
+    utilTracking
+  )
 
-def projectsWithMyProvided = allProjects.map(p => p.copy(configurations = (p.configurations.filter(_ != Provided)) :+ myProvided))
-lazy val nonRoots = projectsWithMyProvided.map(p => LocalProject(p.id))
+lazy val nonRoots = allProjects.map(p => LocalProject(p.id))
 
-def rootSettings = fullDocSettings ++
-  Util.publishPomSettings ++ otherRootSettings ++ Formatting.sbtFilesSettings ++
-  Transform.conscriptSettings(bundledLauncherProj)
-def otherRootSettings = Seq(
-  scripted <<= scriptedTask,
-  scriptedUnpublished <<= scriptedUnpublishedTask,
-  scriptedSource := (sourceDirectory in sbtProj).value / "sbt-test",
-  // scriptedPrescripted := { addSbtAlternateResolver _ },
-  scriptedLaunchOpts := List("-XX:MaxPermSize=256M", "-Xmx1G"),
-  publishAll := { val _ = (publishLocal).all(ScopeFilter(inAnyProject)).value },
-  publishLocalBinAll := { val _ = (publishLocalBin).all(ScopeFilter(inAnyProject)).value },
-  aggregate in bintrayRelease := false
-) ++ inConfig(Scripted.RepoOverrideTest)(Seq(
-  scriptedPrescripted := { _ => () },
-  scriptedLaunchOpts := {
-    List("-XX:MaxPermSize=256M", "-Xmx1G", "-Dsbt.override.build.repos=true",
-      s"""-Dsbt.repository.config=${ scriptedSource.value / "repo.config" }""")
-  },
-  scripted <<= scriptedTask,
-  scriptedUnpublished <<= scriptedUnpublishedTask,
-  scriptedSource := (sourceDirectory in sbtProj).value / "repo-override-test"
-))
+ThisBuild / scriptedBufferLog := true
+ThisBuild / scriptedPrescripted := { _ =>
+}
 
-// def addSbtAlternateResolver(scriptedRoot: File) = {
-//   val resolver = scriptedRoot / "project" / "AddResolverPlugin.scala"
-//   if (!resolver.exists) {
-//     IO.write(resolver, s"""import sbt._
-//                           |import Keys._
-//                           |
-//                           |object AddResolverPlugin extends AutoPlugin {
-//                           |  override def requires = sbt.plugins.JvmPlugin
-//                           |  override def trigger = allRequirements
-//                           |
-//                           |  override lazy val projectSettings = Seq(resolvers += alternativeLocalResolver)
-//                           |  lazy val alternativeLocalResolver = Resolver.file("$altLocalRepoName", file("$altLocalRepoPath"))(Resolver.ivyStylePatterns)
-//                           |}
-//                           |""".stripMargin)
-//   }
-// }
+def otherRootSettings =
+  Seq(
+    scripted := scriptedTask(false).evaluated,
+    scriptedUnpublished := scriptedTask(false).evaluated,
+    scriptedSource := (sourceDirectory in sbtProj).value / "sbt-test",
+    watchTriggers in scripted += scriptedSource.value.toGlob / **,
+    watchTriggers in scriptedUnpublished := (watchTriggers in scripted).value,
+    scriptedLaunchOpts := List("-Xmx1500M", "-Xms512M", "-server") :::
+      (sys.props.get("sbt.ivy.home") match {
+        case Some(home) => List(s"-Dsbt.ivy.home=$home")
+        case _          => Nil
+      }),
+    publishLocalBinAll := {
+      val _ = (Compile / publishLocalBin).all(scriptedProjects).value
+    },
+  ) ++ inConfig(Scripted.RepoOverrideTest)(
+    Seq(
+      scriptedLaunchOpts := List(
+        "-Xmx1500M",
+        "-Xms512M",
+        "-server",
+        "-Dsbt.override.build.repos=true",
+        s"""-Dsbt.repository.config=${scriptedSource.value / "repo.config"}"""
+      ) :::
+        (sys.props.get("sbt.ivy.home") match {
+          case Some(home) => List(s"-Dsbt.ivy.home=$home")
+          case _          => Nil
+        }),
+      scripted := scriptedTask(true).evaluated,
+      scriptedUnpublished := scriptedTask(true).evaluated,
+      scriptedSource := (sourceDirectory in sbtProj).value / "repo-override-test"
+    )
+  )
 
 lazy val docProjects: ScopeFilter = ScopeFilter(
-  inAnyProject -- inProjects(sbtRoot, sbtProj, scriptedSbtProj, scriptedPluginProj),
+  inAnyProject -- inProjects(
+    sbtRoot,
+    sbtProj,
+    scriptedSbtReduxProj,
+    scriptedSbtOldProj,
+    scriptedPluginProj,
+    upperModules,
+    lowerUtils,
+  ),
   inConfigurations(Compile)
 )
-def fullDocSettings = Util.baseScalacOptions ++ Docs.settings ++ Sxr.settings ++ Seq(
-  scalacOptions += "-Ymacro-no-expand", // for both sxr and doc
-  sources in sxr := {
-    val allSources = (sources ?? Nil).all(docProjects).value
-    allSources.flatten.distinct
-  }, //sxr
-  sources in (Compile, doc) := (sources in sxr).value, // doc
-  Sxr.sourceDirectories := {
-    val allSourceDirectories = (sourceDirectories ?? Nil).all(docProjects).value
-    allSourceDirectories.flatten
-  },
-  fullClasspath in sxr := (externalDependencyClasspath in Compile in sbtProj).value,
-  dependencyClasspath in (Compile, doc) := (fullClasspath in sxr).value
-)
-
-lazy val safeUnitTests = taskKey[Unit]("Known working tests (for both 2.10 and 2.11)")
-lazy val safeProjects: ScopeFilter = ScopeFilter(
-  inProjects(mainSettingsProj, mainProj,
-    actionsProj, runProj, stdTaskProj),
-  inConfigurations(Test)
-)
-lazy val otherUnitTests = taskKey[Unit]("Unit test other projects")
-lazy val otherProjects: ScopeFilter = ScopeFilter(
-  inProjects(
-    testingProj, testAgentProj, taskProj,
-    scriptedSbtProj, scriptedPluginProj,
-    commandProj, mainSettingsProj, mainProj,
-    sbtProj),
-  inConfigurations(Test)
-)
+lazy val javafmtOnCompile = taskKey[Unit]("Formats java sources before compile")
+lazy val scriptedProjects = ScopeFilter(inAnyProject -- inProjects(vscodePlugin))
 
 def customCommands: Seq[Setting[_]] = Seq(
-  commands += Command.command("setupBuildScala211") { state =>
-    s"""set scalaVersion in ThisBuild := "$scala211" """ ::
+  commands += Command.command("setupBuildScala212") { state =>
+    s"""set scalaVersion in ThisBuild := "$scala212" """ ::
       state
   },
-  safeUnitTests := {
-    test.all(safeProjects).value
-  },
-  otherUnitTests := {
-    test.all(otherProjects).value
+  commands += Command.command("whitesourceOnPush") { state =>
+    sys.env.get("TRAVIS_EVENT_TYPE") match {
+      case Some("push") =>
+        "whitesourceCheckPolicies" ::
+          "whitesourceUpdate" ::
+          state
+      case _ => state
+    }
   },
   commands += Command.command("release-sbt-local") { state =>
     "clean" ::
-    "so compile" ::
-    "so publishLocal" ::
-    "reload" ::
-    state
+      "so compile" ::
+      "so publishLocal" ::
+      "reload" ::
+      state
   },
-  /** There are several complications with sbt's build.
-   * First is the fact that interface project is a Java-only project
-   * that uses source generator from datatype subproject in Scala 2.10.6.
-   *
-   * Second is the fact that all subprojects are released with crossPaths
-   * turned off for the sbt's Scala version 2.10.6, but some of them are also
-   * cross published against 2.11.1 with crossPaths turned on.
-   *
-   * `so compile` handles 2.10.x/2.11.x cross building.
-   */
-  commands += Command.command("release-sbt") { state =>
+  commands += Command.command("publishLocalAllModule") { state =>
+    val extracted = Project.extract(state)
+    import extracted._
+    val sv = get(scalaVersion)
+    val projs = structure.allProjectRefs
+    val ioOpt = projs find { case ProjectRef(_, id)   => id == "ioRoot"; case _ => false }
+    val utilOpt = projs find { case ProjectRef(_, id) => id == "utilRoot"; case _ => false }
+    val lmOpt = projs find { case ProjectRef(_, id)   => id == "lmRoot"; case _ => false }
+    val zincOpt = projs find { case ProjectRef(_, id) => id == "zincRoot"; case _ => false }
+    (ioOpt map { case ProjectRef(build, _)            => "{" + build.toString + "}/publishLocal" }).toList :::
+      (utilOpt map { case ProjectRef(build, _)        => "{" + build.toString + "}/publishLocal" }).toList :::
+      (lmOpt map { case ProjectRef(build, _)          => "{" + build.toString + "}/publishLocal" }).toList :::
+      (zincOpt map {
+        case ProjectRef(build, _) =>
+          val zincSv = get(scalaVersion in ProjectRef(build, "zinc"))
+          val csv = get(crossScalaVersions in ProjectRef(build, "compilerBridge")).toList
+          (csv flatMap { bridgeSv =>
+            s"++$bridgeSv" :: ("{" + build.toString + "}compilerBridge/publishLocal") :: Nil
+          }) :::
+            List(s"++$zincSv", "{" + build.toString + "}/publishLocal")
+      }).getOrElse(Nil) :::
+      List(s"++$sv", "publishLocal") :::
+      state
+  },
+  commands += Command.command("releaseLowerUtils") { state =>
     // TODO - Any sort of validation
     "clean" ::
-      "conscript-configs" ::
-      "so compile" ::
-      "so publishSigned" ::
+      "+lowerUtils/compile" ::
+      "+lowerUtils/publishSigned" ::
+      s"++$scala212" ::
+      state
+  },
+  commands += Command.command("release") { state =>
+    // TODO - Any sort of validation
+    "clean" ::
+      "conscriptConfigs" ::
+      "upperModules/compile" ::
+      "upperModules/publishSigned" ::
+      "bundledLauncherProj/publishSigned" ::
       "bundledLauncherProj/publishLauncher" ::
       state
   },
-  // stamp-version doesn't work with ++ or "so".
-  commands += Command.command("release-nightly") { state =>
-    "stamp-version" ::
-      "clean" ::
-      "compile" ::
-      "publish" ::
-      "bintrayRelease" ::
-      state
-  }
 )
+
+ThisBuild / pomIncludeRepository := { _ =>
+  false
+}
+ThisBuild / publishTo := {
+  val nexus = "https://oss.sonatype.org/"
+  if (isSnapshot.value) Some("snapshots" at nexus + "content/repositories/snapshots")
+  else Some("releases" at nexus + "service/local/staging/deploy/maven2")
+}
+ThisBuild / publishMavenStyle := true
+ThisBuild / whitesourceProduct := "Lightbend Reactive Platform"
+ThisBuild / whitesourceAggregateProjectName := {
+  // note this can get detached on tag build etc
+  val b = sys.process.Process("git rev-parse --abbrev-ref HEAD").!!.trim
+  val Stable = """1\.([0-9]+)\.x""".r
+  b match {
+    case Stable(y) => "sbt-1." + y.toString + "-stable"
+    case _         => "sbt-master"
+  }
+}
+ThisBuild / whitesourceAggregateProjectToken := {
+  (ThisBuild / whitesourceAggregateProjectName).value match {
+    case "sbt-master"     => "e7a1e55518c0489a98e9c7430c8b2ccd53d9f97c12ed46148b592ebe4c8bf128"
+    case "sbt-1.3-stable" => "7e38cbb4d2fc4599835cd5d2cfb41b150597a4147b15424bb65841664ab2ec0d"
+    case "sbt-1.2-stable" => "54f2313767aa47198971e65595670ee16e1ad0000d20458588e72d3ac2c34763"
+    case _                => "" // it's ok to fail here
+  }
+}
+ThisBuild / whitesourceIgnoredScopes ++= Seq("plugin", "scalafmt", "sxr")
+ThisBuild / whitesourceFailOnError := sys.env.contains("WHITESOURCE_PASSWORD") // fail if pwd is present
+ThisBuild / whitesourceForceCheckAllDependencies := true
diff --git a/client/completions/_sbtn b/client/completions/_sbtn
new file mode 100755
index 000000000..c388ee092
--- /dev/null
+++ b/client/completions/_sbtn
@@ -0,0 +1,5 @@
+#compdef sbtn
+
+COMPLETE="--completions=${words[@]}"
+COMPLETIONS=($(sbtn --no-tab ${COMPLETE}))
+_alternative 'arguments:custom arg:($COMPLETIONS)'
diff --git a/client/completions/sbtn.bash b/client/completions/sbtn.bash
new file mode 100644
index 000000000..6fcb9fff1
--- /dev/null
+++ b/client/completions/sbtn.bash
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+_do_sbtn_completions() {
+  COMPREPLY=($(sbtn "--completions=${COMP_LINE}"))
+}
+
+complete -F _do_sbtn_completions sbtn
diff --git a/client/completions/sbtn.fish b/client/completions/sbtn.fish
new file mode 100755
index 000000000..e5a2d7a02
--- /dev/null
+++ b/client/completions/sbtn.fish
@@ -0,0 +1,4 @@
+function __sbtcomp
+  sbtn --completions="$argv"
+end
+complete --command sbtn -f --arguments '(__sbtcomp (commandline -cp))'
diff --git a/client/completions/sbtn.ps1 b/client/completions/sbtn.ps1
new file mode 100644
index 000000000..0e8b7d851
--- /dev/null
+++ b/client/completions/sbtn.ps1
@@ -0,0 +1,10 @@
+$scriptblock = {
+  param($commandName, $line, $position)
+  $len = $line.ToString().length
+  $spaces = " " * ($position - $len)
+  $arg="--completions=$line$spaces"
+  & 'sbtn.exe' @('--no-tab', '--no-stderr', $arg)
+}
+Set-Alias -Name sbtn -Value sbtn.exe
+Register-ArgumentCompleter -CommandName sbtn.exe -ScriptBlock $scriptBlock
+Register-ArgumentCompleter -CommandName sbtn -ScriptBlock $scriptBlock
diff --git a/client/src/main/java/sbt/client/Client.java b/client/src/main/java/sbt/client/Client.java
new file mode 100644
index 000000000..bf9f120bb
--- /dev/null
+++ b/client/src/main/java/sbt/client/Client.java
@@ -0,0 +1,26 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.client;
+
+import sbt.internal.client.NetworkClient;
+import java.nio.file.Paths;
+import org.fusesource.jansi.AnsiConsole;
+
+public class Client {
+  public static void main(final String[] args) {
+    boolean isWin = System.getProperty("os.name").toLowerCase().startsWith("win");
+    try {
+      if (isWin) AnsiConsole.systemInstall();
+      NetworkClient.main(args);
+    } catch (final Throwable t) {
+      t.printStackTrace();
+    } finally {
+      if (isWin) AnsiConsole.systemUninstall();
+    }
+  }
+}
diff --git a/client/src/main/resources/META-INF/native-image/reflect-config.json b/client/src/main/resources/META-INF/native-image/reflect-config.json
new file mode 100644
index 000000000..a2b39abca
--- /dev/null
+++ b/client/src/main/resources/META-INF/native-image/reflect-config.json
@@ -0,0 +1,18 @@
+[
+  {
+    "name":"java.lang.ProcessBuilder",
+    "methods":[{"name":"redirectInput","parameterTypes":["java.lang.ProcessBuilder$Redirect"] }]
+  },
+  {
+    "name":"java.lang.ProcessBuilder$Redirect",
+    "fields":[{"name":"INHERIT"}]
+  },
+  {
+    "name":"java.lang.System",
+    "methods":[{"name":"console","parameterTypes":[] }]
+  },
+  {
+    "name":"jline.UnixTerminal",
+    "methods":[{"name":"<init>","parameterTypes":[] }]
+  }
+]
diff --git a/client/src/main/resources/META-INF/native-image/resource-config.json b/client/src/main/resources/META-INF/native-image/resource-config.json
new file mode 100644
index 000000000..0bc65dde4
--- /dev/null
+++ b/client/src/main/resources/META-INF/native-image/resource-config.json
@@ -0,0 +1,22 @@
+{
+    "resources":[
+        {"pattern":"jline/console/completer/CandidateListCompletionHandler.properties"},
+        {"pattern":"org/jline/utils/ansi.caps"},
+        {"pattern":"org/jline/utils/capabilities.txt"},
+        {"pattern":"org/jline/utils/colors.txt"},
+	{"pattern":"org/jline/utils/dumb-color.caps"},
+	{"pattern":"org/jline/utils/xterm.caps"},
+	{"pattern":"org/jline/utils/xterm-256color.caps"},
+	{"pattern":"org/jline/utils/windows-256color.caps"},
+	{"pattern":"org/jline/utils/screen-256color.caps"},
+	{"pattern":"org/jline/utils/windows.caps"},
+	{"pattern":"org/jline/utils/windows-conemu.caps"},
+	{"pattern":"org/jline/utils/dumb.caps"},
+	{"pattern":"org/jline/utils/windows-vtp.caps"},
+	{"pattern":"org/jline/utils/screen.caps"},
+	{"pattern":"library.properties"},
+        {"pattern":"darwin/x86_64/libsbtipcsocket.dylib"},
+        {"pattern":"linux/x86_64/libsbtipcsocket.so"},
+        {"pattern":"win32/x86_64/sbtipcsocket.dll"}
+    ]
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala
new file mode 100644
index 000000000..e87b13a21
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala
@@ -0,0 +1,322 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package appmacro
+
+import scala.reflect._
+import macros._
+import ContextUtil.{ DynamicDependencyError, DynamicReferenceError }
+
+object ContextUtil {
+  final val DynamicDependencyError = "Illegal dynamic dependency"
+  final val DynamicReferenceError = "Illegal dynamic reference"
+
+  /**
+   * Constructs an object with utility methods for operating in the provided macro context `c`.
+   * Callers should explicitly specify the type parameter as `c.type` in order to preserve the path dependent types.
+   */
+  def apply[C <: blackbox.Context with Singleton](c: C): ContextUtil[C] = new ContextUtil(c: C)
+
+  /**
+   * Helper for implementing a no-argument macro that is introduced via an implicit.
+   * This method removes the implicit conversion and evaluates the function `f` on the target of the conversion.
+   *
+   * Given `myImplicitConversion(someValue).extensionMethod`, where `extensionMethod` is a macro that uses this
+   * method, the result of this method is `f(<Tree of someValue>)`.
+   */
+  def selectMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(f: (c.Expr[Any], c.Position) => c.Expr[T]): c.Expr[T] = {
+    import c.universe._
+
+    c.macroApplication match {
+      case s @ Select(Apply(_, t :: Nil), _) => f(c.Expr[Any](t), s.pos)
+      case a @ Apply(_, t :: Nil)            => f(c.Expr[Any](t), a.pos)
+      case x                                 => unexpectedTree(x)
+    }
+  }
+
+  def unexpectedTree[C <: blackbox.Context](tree: C#Tree): Nothing =
+    sys.error("Unexpected macro application tree (" + tree.getClass + "): " + tree)
+}
+
+/**
+ * Utility methods for macros.  Several methods assume that the context's universe is a full compiler
+ * (`scala.tools.nsc.Global`).
+ * This is not thread safe due to the underlying Context and related data structures not being thread safe.
+ * Use `ContextUtil[c.type](c)` to construct.
+ */
+final class ContextUtil[C <: blackbox.Context](val ctx: C) {
+  import ctx.universe.{ Apply => ApplyTree, _ }
+  import internal.decorators._
+
+  val powerContext = ctx.asInstanceOf[reflect.macros.runtime.Context]
+  val global: powerContext.universe.type = powerContext.universe
+  def callsiteTyper: global.analyzer.Typer = powerContext.callsiteTyper
+  val initialOwner: Symbol = callsiteTyper.context.owner.asInstanceOf[ctx.universe.Symbol]
+
+  lazy val alistType = ctx.typeOf[AList[KList]]
+  lazy val alist: Symbol = alistType.typeSymbol.companion
+  lazy val alistTC: Type = alistType.typeConstructor
+
+  /** Modifiers for a local val.*/
+  lazy val localModifiers = Modifiers(NoFlags)
+
+  def getPos(sym: Symbol) = if (sym eq null) NoPosition else sym.pos
+
+  /**
+   * Constructs a unique term name with the given prefix within this Context.
+   * (The current implementation uses Context.freshName, which increments
+   */
+  def freshTermName(prefix: String) = TermName(ctx.freshName("$" + prefix))
+
+  /**
+   * Constructs a new, synthetic, local ValDef Type `tpe`, a unique name,
+   * Position `pos`, an empty implementation (no rhs), and owned by `owner`.
+   */
+  def freshValDef(tpe: Type, pos: Position, owner: Symbol): ValDef = {
+    val SYNTHETIC = (1 << 21).toLong.asInstanceOf[FlagSet]
+    val sym = owner.newTermSymbol(freshTermName("q"), pos, SYNTHETIC)
+    setInfo(sym, tpe)
+    val vd = internal.valDef(sym, EmptyTree)
+    vd.setPos(pos)
+    vd
+  }
+
+  lazy val parameterModifiers = Modifiers(Flag.PARAM)
+
+  /**
+   * Collects all definitions in the tree for use in checkReferences.
+   * This excludes definitions in wrapped expressions because checkReferences won't allow nested dereferencing anyway.
+   */
+  def collectDefs(
+      tree: Tree,
+      isWrapper: (String, Type, Tree) => Boolean
+  ): collection.Set[Symbol] = {
+    val defs = new collection.mutable.HashSet[Symbol]
+    // adds the symbols for all non-Ident subtrees to `defs`.
+    val process = new Traverser {
+      override def traverse(t: Tree) = t match {
+        case _: Ident => ()
+        case ApplyTree(TypeApply(Select(_, nme), tpe :: Nil), qual :: Nil)
+            if isWrapper(nme.decodedName.toString, tpe.tpe, qual) =>
+          ()
+        case tree =>
+          if (tree.symbol ne null) {
+            defs += tree.symbol
+            ()
+          }
+          super.traverse(tree)
+      }
+    }
+    process.traverse(tree)
+    defs
+  }
+
+  /**
+   * A reference is illegal if it is to an M instance defined within the scope of the macro call.
+   * As an approximation, disallow referenced to any local definitions `defs`.
+   */
+  def illegalReference(defs: collection.Set[Symbol], sym: Symbol, mType: Type): Boolean =
+    sym != null && sym != NoSymbol && defs.contains(sym) && {
+      sym match {
+        case m: MethodSymbol => m.returnType.erasure <:< mType
+        case _               => sym.typeSignature <:< mType
+      }
+    }
+
+  /**
+   * A reference is illegal if it is to an M instance defined within the scope of the macro call.
+   * As an approximation, disallow referenced to any local definitions `defs`.
+   */
+  def illegalReference(defs: collection.Set[Symbol], sym: Symbol): Boolean =
+    illegalReference(defs, sym, weakTypeOf[Any])
+
+  type PropertyChecker = (String, Type, Tree) => Boolean
+
+  /**
+   * A function that checks the provided tree for illegal references to M instances defined in the
+   *  expression passed to the macro and for illegal dereferencing of M instances.
+   */
+  def checkReferences(
+      defs: collection.Set[Symbol],
+      isWrapper: PropertyChecker,
+      mType: Type
+  ): Tree => Unit = {
+    case s @ ApplyTree(TypeApply(Select(_, nme), tpe :: Nil), qual :: Nil) =>
+      if (isWrapper(nme.decodedName.toString, tpe.tpe, qual)) {
+        ctx.error(s.pos, DynamicDependencyError)
+      }
+    case id @ Ident(name) if illegalReference(defs, id.symbol, mType) =>
+      ctx.error(id.pos, DynamicReferenceError + ": " + name)
+    case _ => ()
+  }
+
+  @deprecated("Use that variant that specifies the M instance types to exclude", since = "1.3.0")
+  /**
+   * A function that checks the provided tree for illegal references to M instances defined in the
+   *  expression passed to the macro and for illegal dereferencing of M instances.
+   */
+  def checkReferences(defs: collection.Set[Symbol], isWrapper: PropertyChecker): Tree => Unit =
+    checkReferences(defs, isWrapper, weakTypeOf[Any])
+
+  /** Constructs a ValDef with a parameter modifier, a unique name, with the provided Type and with an empty rhs. */
+  def freshMethodParameter(tpe: Type): ValDef =
+    ValDef(parameterModifiers, freshTermName("p"), TypeTree(tpe), EmptyTree)
+
+  /** Constructs a ValDef with local modifiers and a unique name. */
+  def localValDef(tpt: Tree, rhs: Tree): ValDef =
+    ValDef(localModifiers, freshTermName("q"), tpt, rhs)
+
+  /** Constructs a tuple value of the right TupleN type from the provided inputs.*/
+  def mkTuple(args: List[Tree]): Tree =
+    global.gen.mkTuple(args.asInstanceOf[List[global.Tree]]).asInstanceOf[ctx.universe.Tree]
+
+  def setSymbol[_Tree](t: _Tree, sym: Symbol): Unit = {
+    t.asInstanceOf[global.Tree].setSymbol(sym.asInstanceOf[global.Symbol])
+    ()
+  }
+  def setInfo(sym: Symbol, tpe: Type): Unit = {
+    sym.asInstanceOf[global.Symbol].setInfo(tpe.asInstanceOf[global.Type])
+    ()
+  }
+
+  /** Creates a new, synthetic type variable with the specified `owner`. */
+  def newTypeVariable(owner: Symbol, prefix: String = "T0"): TypeSymbol =
+    owner
+      .asInstanceOf[global.Symbol]
+      .newSyntheticTypeParam(prefix, 0L)
+      .asInstanceOf[ctx.universe.TypeSymbol]
+
+  /** The type representing the type constructor `[X] X` */
+  lazy val idTC: Type = {
+    val tvar = newTypeVariable(NoSymbol)
+    internal.polyType(tvar :: Nil, refVar(tvar))
+  }
+
+  /** A Type that references the given type variable. */
+  def refVar(variable: TypeSymbol): Type = variable.toTypeConstructor
+
+  /** Constructs a new, synthetic type variable that is a type constructor. For example, in type Y[L[x]], L is such a type variable. */
+  def newTCVariable(owner: Symbol): TypeSymbol = {
+    val tc = newTypeVariable(owner)
+    val arg = newTypeVariable(tc, "x");
+    tc.setInfo(internal.polyType(arg :: Nil, emptyTypeBounds))
+    tc
+  }
+
+  /** >: Nothing <: Any */
+  def emptyTypeBounds: TypeBounds =
+    internal.typeBounds(definitions.NothingClass.toType, definitions.AnyClass.toType)
+
+  /** Creates a new anonymous function symbol with Position `pos`. */
+  def functionSymbol(pos: Position): Symbol =
+    callsiteTyper.context.owner
+      .newAnonymousFunctionValue(pos.asInstanceOf[global.Position])
+      .asInstanceOf[ctx.universe.Symbol]
+
+  def functionType(args: List[Type], result: Type): Type = {
+    val tpe = global.definitions
+      .functionType(args.asInstanceOf[List[global.Type]], result.asInstanceOf[global.Type])
+    tpe.asInstanceOf[Type]
+  }
+
+  /** Create a Tree that references the `val` represented by `vd`, copying attributes from `replaced`. */
+  def refVal(replaced: Tree, vd: ValDef): Tree =
+    treeCopy.Ident(replaced, vd.name).setSymbol(vd.symbol)
+
+  /** Creates a Function tree using `functionSym` as the Symbol and changing `initialOwner` to `functionSym` in `body`.*/
+  def createFunction(params: List[ValDef], body: Tree, functionSym: Symbol): Tree = {
+    changeOwner(body, initialOwner, functionSym)
+    val f = Function(params, body)
+    setSymbol(f, functionSym)
+    f
+  }
+
+  def changeOwner(tree: Tree, prev: Symbol, next: Symbol): Unit =
+    new ChangeOwnerAndModuleClassTraverser(
+      prev.asInstanceOf[global.Symbol],
+      next.asInstanceOf[global.Symbol]
+    ).traverse(tree.asInstanceOf[global.Tree])
+
+  // Workaround copied from scala/async:can be removed once https://github.com/scala/scala/pull/3179 is merged.
+  private[this] class ChangeOwnerAndModuleClassTraverser(
+      oldowner: global.Symbol,
+      newowner: global.Symbol
+  ) extends global.ChangeOwnerTraverser(oldowner, newowner) {
+    override def traverse(tree: global.Tree): Unit = {
+      tree match {
+        case _: global.DefTree => change(tree.symbol.moduleClass)
+        case _                 =>
+      }
+      super.traverse(tree)
+    }
+  }
+
+  /** Returns the Symbol that references the statically accessible singleton `i`. */
+  def singleton[T <: AnyRef with Singleton](i: T)(implicit it: ctx.TypeTag[i.type]): Symbol =
+    it.tpe match {
+      case SingleType(_, sym) if !sym.isFreeTerm && sym.isStatic => sym
+      case x                                                     => sys.error("Instance must be static (was " + x + ").")
+    }
+
+  def select(t: Tree, name: String): Tree = Select(t, TermName(name))
+
+  /** Returns the symbol for the non-private method named `name` for the class/module `obj`. */
+  def method(obj: Symbol, name: String): Symbol = {
+    val ts: Type = obj.typeSignature
+    val m: global.Symbol = ts.asInstanceOf[global.Type].nonPrivateMember(global.newTermName(name))
+    m.asInstanceOf[Symbol]
+  }
+
+  /**
+   * Returns a Type representing the type constructor tcp.<name>.  For example, given
+   *  `object Demo { type M[x] = List[x] }`, the call `extractTC(Demo, "M")` will return a type representing
+   * the type constructor `[x] List[x]`.
+   */
+  def extractTC(tcp: AnyRef with Singleton, name: String)(
+      implicit it: ctx.TypeTag[tcp.type]
+  ): ctx.Type = {
+    val itTpe = it.tpe.asInstanceOf[global.Type]
+    val m = itTpe.nonPrivateMember(global.newTypeName(name))
+    val tc = itTpe.memberInfo(m).asInstanceOf[ctx.universe.Type]
+    assert(tc != NoType && tc.takesTypeArgs, "Invalid type constructor: " + tc)
+    tc
+  }
+
+  /**
+   * Substitutes wrappers in tree `t` with the result of `subWrapper`.
+   * A wrapper is a Tree of the form `f[T](v)` for which isWrapper(<Tree of f>, <Underlying Type>, <qual>.target) returns true.
+   * Typically, `f` is a `Select` or `Ident`.
+   * The wrapper is replaced with the result of `subWrapper(<Type of T>, <Tree of v>, <wrapper Tree>)`
+   */
+  def transformWrappers(
+      t: Tree,
+      subWrapper: (String, Type, Tree, Tree) => Converted[ctx.type]
+  ): Tree = {
+    // the main tree transformer that replaces calls to InputWrapper.wrap(x) with
+    //  plain Idents that reference the actual input value
+    object appTransformer extends Transformer {
+      override def transform(tree: Tree): Tree =
+        tree match {
+          case ApplyTree(TypeApply(Select(_, nme), targ :: Nil), qual :: Nil) =>
+            subWrapper(nme.decodedName.toString, targ.tpe, qual, tree) match {
+              case Converted.Success(t, finalTx) =>
+                changeOwner(qual, currentOwner, initialOwner) // Fixes https://github.com/sbt/sbt/issues/1150
+                finalTx(t)
+              case Converted.Failure(p, m)       => ctx.abort(p, m)
+              case _: Converted.NotApplicable[_] => super.transform(tree)
+            }
+          case _ => super.transform(tree)
+        }
+    }
+    appTransformer.atOwner(initialOwner) {
+      appTransformer.transform(t)
+    }
+  }
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/Convert.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/Convert.scala
new file mode 100644
index 000000000..a3e3a754b
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/Convert.scala
@@ -0,0 +1,51 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package appmacro
+
+import scala.reflect._
+import macros._
+import Types.idFun
+
+abstract class Convert {
+  def apply[T: c.WeakTypeTag](c: blackbox.Context)(nme: String, in: c.Tree): Converted[c.type]
+  def asPredicate(c: blackbox.Context): (String, c.Type, c.Tree) => Boolean =
+    (n, tpe, tree) => {
+      val tag = c.WeakTypeTag(tpe)
+      apply(c)(n, tree)(tag).isSuccess
+    }
+}
+sealed trait Converted[C <: blackbox.Context with Singleton] {
+  def isSuccess: Boolean
+  def transform(f: C#Tree => C#Tree): Converted[C]
+}
+object Converted {
+  def NotApplicable[C <: blackbox.Context with Singleton] = new NotApplicable[C]
+  final case class Failure[C <: blackbox.Context with Singleton](
+      position: C#Position,
+      message: String
+  ) extends Converted[C] {
+    def isSuccess = false
+    def transform(f: C#Tree => C#Tree): Converted[C] = new Failure(position, message)
+  }
+  final class NotApplicable[C <: blackbox.Context with Singleton] extends Converted[C] {
+    def isSuccess = false
+    def transform(f: C#Tree => C#Tree): Converted[C] = this
+  }
+  final case class Success[C <: blackbox.Context with Singleton](
+      tree: C#Tree,
+      finalTransform: C#Tree => C#Tree
+  ) extends Converted[C] {
+    def isSuccess = true
+    def transform(f: C#Tree => C#Tree): Converted[C] = Success(f(tree), finalTransform)
+  }
+  object Success {
+    def apply[C <: blackbox.Context with Singleton](tree: C#Tree): Success[C] =
+      Success(tree, idFun)
+  }
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/Instance.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/Instance.scala
new file mode 100644
index 000000000..35e2d7dc6
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/Instance.scala
@@ -0,0 +1,230 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package appmacro
+
+import sbt.internal.util.Classes.Applicative
+import sbt.internal.util.Types.Id
+
+/**
+ * The separate hierarchy from Applicative/Monad is for two reasons.
+ *
+ * 1. The type constructor is represented as an abstract type because a TypeTag cannot represent a type constructor directly.
+ * 2. The applicative interface is uncurried.
+ */
+trait Instance {
+  type M[x]
+  def app[K[L[x]], Z](in: K[M], f: K[Id] => Z)(implicit a: AList[K]): M[Z]
+  def map[S, T](in: M[S], f: S => T): M[T]
+  def pure[T](t: () => T): M[T]
+}
+
+trait MonadInstance extends Instance {
+  def flatten[T](in: M[M[T]]): M[T]
+}
+
+import scala.reflect.macros._
+
+object Instance {
+  type Aux[M0[_]] = Instance { type M[x] = M0[x] }
+  type Aux2[M0[_], N[_]] = Instance { type M[x] = M0[N[x]] }
+
+  final val ApplyName = "app"
+  final val FlattenName = "flatten"
+  final val PureName = "pure"
+  final val MapName = "map"
+  final val InstanceTCName = "M"
+
+  final class Input[U <: Universe with Singleton](
+      val tpe: U#Type,
+      val expr: U#Tree,
+      val local: U#ValDef
+  )
+  trait Transform[C <: blackbox.Context with Singleton, N[_]] {
+    def apply(in: C#Tree): C#Tree
+  }
+  def idTransform[C <: blackbox.Context with Singleton]: Transform[C, Id] = in => in
+
+  /**
+   * Implementation of a macro that provides a direct syntax for applicative functors and monads.
+   * It is intended to be used in conjunction with another macro that conditions the inputs.
+   *
+   * This method processes the Tree `t` to find inputs of the form `wrap[T]( input )`
+   * This form is typically constructed by another macro that pretends to be able to get a value of type `T`
+   * from a value convertible to `M[T]`.  This `wrap(input)` form has two main purposes.
+   * First, it identifies the inputs that should be transformed.
+   * Second, it allows the input trees to be wrapped for later conversion into the appropriate `M[T]` type by `convert`.
+   * This wrapping is necessary because applying the first macro must preserve the original type,
+   * but it is useful to delay conversion until the outer, second macro is called.  The `wrap` method accomplishes this by
+   * allowing the original `Tree` and `Type` to be hidden behind the raw `T` type.  This method will remove the call to `wrap`
+   * so that it is not actually called at runtime.
+   *
+   * Each `input` in each expression of the form `wrap[T]( input )` is transformed by `convert`.
+   * This transformation converts the input Tree to a Tree of type `M[T]`.
+   * The original wrapped expression `wrap(input)` is replaced by a reference to a new local `val x: T`, where `x` is a fresh name.
+   * These converted inputs are passed to `builder` as well as the list of these synthetic `ValDef`s.
+   * The `TupleBuilder` instance constructs a tuple (Tree) from the inputs and defines the right hand side of the vals
+   * that unpacks the tuple containing the results of the inputs.
+   *
+   * The constructed tuple of inputs and the code that unpacks the results of the inputs are then passed to the `i`,
+   * which is an implementation of `Instance` that is statically accessible.
+   * An Instance defines a applicative functor associated with a specific type constructor and, if it implements MonadInstance as well, a monad.
+   * Typically, it will be either a top-level module or a stable member of a top-level module (such as a val or a nested module).
+   * The `with Singleton` part of the type verifies some cases at macro compilation time,
+   *  while the full check for static accessibility is done at macro expansion time.
+   * Note: Ideally, the types would verify that `i: MonadInstance` when `t.isRight`.
+   * With the various dependent types involved, this is not worth it.
+   *
+   * The `t` argument is the argument of the macro that will be transformed as described above.
+   * If the macro that calls this method is for a multi-input map (app followed by map),
+   * `t` should be the argument wrapped in Left.
+   * If this is for multi-input flatMap (app followed by flatMap),
+   *  this should be the argument wrapped in Right.
+   */
+  def contImpl[T, N[_]](
+      c: blackbox.Context,
+      i: Instance with Singleton,
+      convert: Convert,
+      builder: TupleBuilder,
+      linter: LinterDSL
+  )(
+      t: Either[c.Expr[T], c.Expr[i.M[T]]],
+      inner: Transform[c.type, N]
+  )(
+      implicit tt: c.WeakTypeTag[T],
+      nt: c.WeakTypeTag[N[T]],
+      it: c.TypeTag[i.type]
+  ): c.Expr[i.M[N[T]]] = {
+    import c.universe.{ Apply => ApplyTree, _ }
+
+    val util = ContextUtil[c.type](c)
+    val mTC: Type = util.extractTC(i, InstanceTCName)
+    val mttpe: Type = appliedType(mTC, nt.tpe :: Nil).dealias
+
+    // the tree for the macro argument
+    val (tree, treeType) = t match {
+      case Left(l)  => (l.tree, nt.tpe.dealias)
+      case Right(r) => (r.tree, mttpe)
+    }
+    // the Symbol for the anonymous function passed to the appropriate Instance.map/flatMap/pure method
+    // this Symbol needs to be known up front so that it can be used as the owner of synthetic vals
+    val functionSym = util.functionSymbol(tree.pos)
+
+    val instanceSym = util.singleton(i)
+    // A Tree that references the statically accessible Instance that provides the actual implementations of map, flatMap, ...
+    val instance = Ident(instanceSym)
+
+    val isWrapper: (String, Type, Tree) => Boolean = convert.asPredicate(c)
+
+    // Local definitions `defs` in the macro.  This is used to ensure references are to M instances defined outside of the macro call.
+    // Also `refCount` is the number of references, which is used to create the private, synthetic method containing the body
+    val defs = util.collectDefs(tree, isWrapper)
+    val checkQual: Tree => Unit = util.checkReferences(defs, isWrapper, mttpe.erasure)
+
+    type In = Input[c.universe.type]
+    var inputs = List[In]()
+
+    // transforms the original tree into calls to the Instance functions pure, map, ...,
+    //  resulting in a value of type M[T]
+    def makeApp(body: Tree): Tree =
+      inputs match {
+        case Nil      => pure(body)
+        case x :: Nil => single(body, x)
+        case xs       => arbArity(body, xs)
+      }
+
+    // no inputs, so construct M[T] via Instance.pure or pure+flatten
+    def pure(body: Tree): Tree = {
+      val typeApplied = TypeApply(util.select(instance, PureName), TypeTree(treeType) :: Nil)
+      val f = util.createFunction(Nil, body, functionSym)
+      val p = ApplyTree(typeApplied, f :: Nil)
+      if (t.isLeft) p else flatten(p)
+    }
+    // m should have type M[M[T]]
+    // the returned Tree will have type M[T]
+    def flatten(m: Tree): Tree = {
+      val typedFlatten = TypeApply(util.select(instance, FlattenName), TypeTree(tt.tpe) :: Nil)
+      ApplyTree(typedFlatten, m :: Nil)
+    }
+
+    // calls Instance.map or flatmap directly, skipping the intermediate Instance.app that is unnecessary for a single input
+    def single(body: Tree, input: In): Tree = {
+      val variable = input.local
+      val param =
+        treeCopy.ValDef(variable, util.parameterModifiers, variable.name, variable.tpt, EmptyTree)
+      val typeApplied =
+        TypeApply(util.select(instance, MapName), variable.tpt :: (TypeTree(treeType): Tree) :: Nil)
+      val f = util.createFunction(param :: Nil, body, functionSym)
+      val mapped = ApplyTree(typeApplied, input.expr :: f :: Nil)
+      if (t.isLeft) mapped else flatten(mapped)
+    }
+
+    // calls Instance.app to get the values for all inputs and then calls Instance.map or flatMap to evaluate the body
+    def arbArity(body: Tree, inputs: List[In]): Tree = {
+      val result = builder.make(c)(mTC, inputs)
+      val param = util.freshMethodParameter(appliedType(result.representationC, util.idTC :: Nil))
+      val bindings = result.extract(param)
+      val f = util.createFunction(param :: Nil, Block(bindings, body), functionSym)
+      val ttt = TypeTree(treeType)
+      val typedApp =
+        TypeApply(util.select(instance, ApplyName), TypeTree(result.representationC) :: ttt :: Nil)
+      val app =
+        ApplyTree(ApplyTree(typedApp, result.input :: f :: Nil), result.alistInstance :: Nil)
+      if (t.isLeft) app else flatten(app)
+    }
+
+    // Called when transforming the tree to add an input.
+    //  For `qual` of type M[A], and a `selection` qual.value,
+    //  the call is addType(Type A, Tree qual)
+    // The result is a Tree representing a reference to
+    //  the bound value of the input.
+    def addType(tpe: Type, qual: Tree, selection: Tree): Tree = {
+      qual.foreach(checkQual)
+      val vd = util.freshValDef(tpe, qual.pos, functionSym)
+      inputs ::= new Input(tpe, qual, vd)
+      util.refVal(selection, vd)
+    }
+    def sub(name: String, tpe: Type, qual: Tree, replace: Tree): Converted[c.type] = {
+      val tag = c.WeakTypeTag[T](tpe)
+      convert[T](c)(name, qual)(tag) transform { tree =>
+        addType(tpe, tree, replace)
+      }
+    }
+
+    // applies the transformation
+    linter.runLinter(c)(tree)
+    val tx = util.transformWrappers(tree, (n, tpe, t, replace) => sub(n, tpe, t, replace))
+    // resetting attributes must be: a) local b) done here and not wider or else there are obscure errors
+    val tr = makeApp(inner(tx))
+    val noWarn = q"""($tr: @_root_.scala.annotation.nowarn("cat=other-pure-statement"))"""
+    c.Expr[i.M[N[T]]](noWarn)
+  }
+
+  import Types._
+
+  implicit def applicativeInstance[A[_]](implicit ap: Applicative[A]): Instance.Aux[A] =
+    new Instance {
+      type M[x] = A[x]
+      def app[K[L[x]], Z](in: K[A], f: K[Id] => Z)(implicit a: AList[K]) = a.apply[A, Z](in, f)
+      def map[S, T](in: A[S], f: S => T) = ap.map(f, in)
+      def pure[S](s: () => S): M[S] = ap.pure(s())
+    }
+
+  def compose[A[_], B[_]](implicit a: Aux[A], b: Aux[B]): Instance.Aux2[A, B] =
+    new Composed[A, B](a, b)
+  // made a public, named, unsealed class because of trouble with macros and inference when the Instance is not an object
+  class Composed[A[_], B[_]](a: Aux[A], b: Aux[B]) extends Instance {
+    type M[x] = A[B[x]]
+    def pure[S](s: () => S): A[B[S]] = a.pure(() => b.pure(s))
+    def map[S, T](in: M[S], f: S => T): M[T] = a.map(in, (bv: B[S]) => b.map(bv, f))
+    def app[K[L[x]], Z](in: K[M], f: K[Id] => Z)(implicit alist: AList[K]): A[B[Z]] = {
+      val g: K[B] => B[Z] = in => b.app[K, Z](in, f)
+      a.app[AList.SplitK[K, B]#l, B[Z]](in, g)(AList.asplit(alist))
+    }
+  }
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/KListBuilder.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/KListBuilder.scala
new file mode 100644
index 000000000..6d2ae0a50
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/KListBuilder.scala
@@ -0,0 +1,85 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package appmacro
+
+import scala.reflect._
+import macros._
+
+/** A `TupleBuilder` that uses a KList as the tuple representation.*/
+object KListBuilder extends TupleBuilder {
+  def make(
+      c: blackbox.Context
+  )(mt: c.Type, inputs: Inputs[c.universe.type]): BuilderResult[c.type] =
+    new BuilderResult[c.type] {
+      val ctx: c.type = c
+      val util = ContextUtil[c.type](c)
+      import c.universe.{ Apply => ApplyTree, _ }
+      import util._
+
+      val knilType = c.typeOf[KNil]
+      val knil = Ident(knilType.typeSymbol.companion)
+      val kconsTpe = c.typeOf[KCons[Int, KNil, List]]
+      val kcons = kconsTpe.typeSymbol.companion
+      val mTC: Type = mt.asInstanceOf[c.universe.Type]
+      val kconsTC: Type = kconsTpe.typeConstructor
+
+      /** This is the L in the type function [L[x]] ...  */
+      val tcVariable: TypeSymbol = newTCVariable(util.initialOwner)
+
+      /** Instantiates KCons[h, t <: KList[L], L], where L is the type constructor variable */
+      def kconsType(h: Type, t: Type): Type =
+        appliedType(kconsTC, h :: t :: refVar(tcVariable) :: Nil)
+
+      def bindKList(prev: ValDef, revBindings: List[ValDef], params: List[ValDef]): List[ValDef] =
+        params match {
+          case (x @ ValDef(mods, name, tpt, _)) :: xs =>
+            val rhs = select(Ident(prev.name), "head")
+            val head = treeCopy.ValDef(x, mods, name, tpt, rhs)
+            util.setSymbol(head, x.symbol)
+            val tail = localValDef(TypeTree(), select(Ident(prev.name), "tail"))
+            val base = head :: revBindings
+            bindKList(tail, if (xs.isEmpty) base else tail :: base, xs)
+          case Nil => revBindings.reverse
+        }
+
+      private[this] def makeKList(
+          revInputs: Inputs[c.universe.type],
+          klist: Tree,
+          klistType: Type
+      ): Tree =
+        revInputs match {
+          case in :: tail =>
+            val next = ApplyTree(
+              TypeApply(
+                Ident(kcons),
+                TypeTree(in.tpe) :: TypeTree(klistType) :: TypeTree(mTC) :: Nil
+              ),
+              in.expr :: klist :: Nil
+            )
+            makeKList(tail, next, appliedType(kconsTC, in.tpe :: klistType :: mTC :: Nil))
+          case Nil => klist
+        }
+
+      /** The input trees combined in a KList */
+      val klist = makeKList(inputs.reverse, knil, knilType)
+
+      /**
+       * The input types combined in a KList type.  The main concern is tracking the heterogeneous types.
+       * The type constructor is tcVariable, so that it can be applied to [X] X or M later.
+       * When applied to `M`, this type gives the type of the `input` KList.
+       */
+      val klistType: Type = inputs.foldRight(knilType)((in, klist) => kconsType(in.tpe, klist))
+
+      val representationC = internal.polyType(tcVariable :: Nil, klistType)
+      val input = klist
+      val alistInstance: ctx.universe.Tree =
+        TypeApply(select(Ident(alist), "klist"), TypeTree(representationC) :: Nil)
+      def extract(param: ValDef) = bindKList(param, Nil, inputs.map(_.local))
+    }
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/LinterDSL.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/LinterDSL.scala
new file mode 100644
index 000000000..fb42f2e2e
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/LinterDSL.scala
@@ -0,0 +1,20 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util.appmacro
+
+import scala.reflect.macros.blackbox
+
+trait LinterDSL {
+  def runLinter(ctx: blackbox.Context)(tree: ctx.Tree): Unit
+}
+
+object LinterDSL {
+  object Empty extends LinterDSL {
+    override def runLinter(ctx: blackbox.Context)(tree: ctx.Tree): Unit = ()
+  }
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/MixedBuilder.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/MixedBuilder.scala
new file mode 100644
index 000000000..abcde7c80
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/MixedBuilder.scala
@@ -0,0 +1,27 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package appmacro
+
+import scala.reflect._
+import macros._
+
+/**
+ * A builder that uses `TupleN` as the representation for small numbers of inputs (up to `TupleNBuilder.MaxInputs`)
+ * and `KList` for larger numbers of inputs. This builder cannot handle fewer than 2 inputs.
+ */
+object MixedBuilder extends TupleBuilder {
+  def make(
+      c: blackbox.Context
+  )(mt: c.Type, inputs: Inputs[c.universe.type]): BuilderResult[c.type] = {
+    val delegate =
+      if (inputs.size > TupleNBuilder.MaxInputs) (KListBuilder: TupleBuilder)
+      else (TupleNBuilder: TupleBuilder)
+    delegate.make(c)(mt, inputs)
+  }
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/StringTypeTag.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/StringTypeTag.scala
new file mode 100644
index 000000000..faeda9245
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/StringTypeTag.scala
@@ -0,0 +1,27 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util.appmacro
+
+import scala.reflect.macros.blackbox
+
+object StringTypeTag {
+  def impl[A: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
+    import c.universe._
+    val tpe = weakTypeOf[A]
+    def typeToString(tpe: Type): String = tpe match {
+      case TypeRef(_, sym, args) if args.nonEmpty =>
+        val typeCon = tpe.typeSymbol.fullName
+        val typeArgs = args map typeToString
+        s"""$typeCon[${typeArgs.mkString(",")}]"""
+      case _ => tpe.toString
+    }
+
+    val key = Literal(Constant(typeToString(tpe)))
+    q"new sbt.internal.util.StringTypeTag[$tpe]($key)"
+  }
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/TupleBuilder.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/TupleBuilder.scala
new file mode 100644
index 000000000..14afc4eb4
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/TupleBuilder.scala
@@ -0,0 +1,64 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package appmacro
+
+import scala.reflect._
+import macros._
+
+/**
+ * A `TupleBuilder` abstracts the work of constructing a tuple data structure such as a `TupleN` or `KList`
+ * and extracting values from it.  The `Instance` macro implementation will (roughly) traverse the tree of its argument
+ * and ultimately obtain a list of expressions with type `M[T]` for different types `T`.
+ * The macro constructs an `Input` value for each of these expressions that contains the `Type` for `T`,
+ * the `Tree` for the expression, and a `ValDef` that will hold the value for the input.
+ *
+ * `TupleBuilder.apply` is provided with the list of `Input`s and is expected to provide three values in the returned BuilderResult.
+ * First, it returns the constructed tuple data structure Tree in `input`.
+ * Next, it provides the type constructor `representationC` that, when applied to M, gives the type of tuple data structure.
+ * For example, a builder that constructs a `Tuple3` for inputs `M[Int]`, `M[Boolean]`, and `M[String]`
+ * would provide a Type representing `[L[x]] (L[Int], L[Boolean], L[String])`.  The `input` method
+ * would return a value whose type is that type constructor applied to M, or `(M[Int], M[Boolean], M[String])`.
+ *
+ * Finally, the `extract` method provides a list of vals that extract information from the applied input.
+ * The type of the applied input is the type constructor applied to `Id` (`[X] X`).
+ * The returned list of ValDefs should be the ValDefs from `inputs`, but with non-empty right-hand sides.
+ */
+trait TupleBuilder {
+
+  /** A convenience alias for a list of inputs (associated with a Universe of type U). */
+  type Inputs[U <: Universe with Singleton] = List[Instance.Input[U]]
+
+  /** Constructs a one-time use Builder for Context `c` and type constructor `tcType`. */
+  def make(
+      c: blackbox.Context
+  )(tcType: c.Type, inputs: Inputs[c.universe.type]): BuilderResult[c.type]
+}
+
+trait BuilderResult[C <: blackbox.Context with Singleton] {
+  val ctx: C
+  import ctx.universe._
+
+  /**
+   * Represents the higher-order type constructor `[L[x]] ...` where `...` is the
+   * type of the data structure containing the added expressions,
+   * except that it is abstracted over the type constructor applied to each heterogeneous part of the type .
+   */
+  def representationC: PolyType
+
+  /** The instance of AList for the input.  For a `representationC` of `[L[x]]`, this `Tree` should have a `Type` of `AList[L]`*/
+  def alistInstance: Tree
+
+  /** Returns the completed value containing all expressions added to the builder. */
+  def input: Tree
+
+  /* The list of definitions that extract values from a value of type `$representationC[Id]`.
+	* The returned value should be identical to the `ValDef`s provided to the `TupleBuilder.make` method but with
+	* non-empty right hand sides. Each `ValDef` may refer to `param` and previous `ValDef`s in the list.*/
+  def extract(param: ValDef): List[ValDef]
+}
diff --git a/core-macros/src/main/scala/sbt/internal/util/appmacro/TupleNBuilder.scala b/core-macros/src/main/scala/sbt/internal/util/appmacro/TupleNBuilder.scala
new file mode 100644
index 000000000..e47e06b11
--- /dev/null
+++ b/core-macros/src/main/scala/sbt/internal/util/appmacro/TupleNBuilder.scala
@@ -0,0 +1,67 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package appmacro
+
+import scala.tools.nsc.Global
+import scala.reflect._
+import macros._
+
+/**
+ * A builder that uses a TupleN as the tuple representation.
+ * It is limited to tuples of size 2 to `MaxInputs`.
+ */
+object TupleNBuilder extends TupleBuilder {
+
+  /** The largest number of inputs that this builder can handle. */
+  final val MaxInputs = 11
+  final val TupleMethodName = "tuple"
+
+  def make(
+      c: blackbox.Context
+  )(mt: c.Type, inputs: Inputs[c.universe.type]): BuilderResult[c.type] =
+    new BuilderResult[c.type] {
+      val util = ContextUtil[c.type](c)
+      import c.universe._
+      import util._
+
+      val global: Global = c.universe.asInstanceOf[Global]
+
+      val ctx: c.type = c
+      val representationC: PolyType = {
+        val tcVariable: Symbol = newTCVariable(util.initialOwner)
+        val tupleTypeArgs = inputs.map(
+          in => internal.typeRef(NoPrefix, tcVariable, in.tpe :: Nil).asInstanceOf[global.Type]
+        )
+        val tuple = global.definitions.tupleType(tupleTypeArgs)
+        internal.polyType(tcVariable :: Nil, tuple.asInstanceOf[Type])
+      }
+
+      val input: Tree = mkTuple(inputs.map(_.expr))
+      val alistInstance: Tree = {
+        val selectTree = select(Ident(alist), TupleMethodName + inputs.size.toString)
+        TypeApply(selectTree, inputs.map(in => TypeTree(in.tpe)))
+      }
+      def extract(param: ValDef): List[ValDef] = bindTuple(param, Nil, inputs.map(_.local), 1)
+
+      def bindTuple(
+          param: ValDef,
+          revBindings: List[ValDef],
+          params: List[ValDef],
+          i: Int
+      ): List[ValDef] =
+        params match {
+          case (x @ ValDef(mods, name, tpt, _)) :: xs =>
+            val rhs = select(Ident(param.name), "_" + i.toString)
+            val newVal = treeCopy.ValDef(x, mods, name, tpt, rhs)
+            util.setSymbol(newVal, x.symbol)
+            bindTuple(param, newVal :: revBindings, xs, i + 1)
+          case Nil => revBindings.reverse
+        }
+    }
+}
diff --git a/dependency-tree/src/main/scala/sbt/plugins/DependencyTreePlugin.scala b/dependency-tree/src/main/scala/sbt/plugins/DependencyTreePlugin.scala
new file mode 100644
index 000000000..1fbaabd70
--- /dev/null
+++ b/dependency-tree/src/main/scala/sbt/plugins/DependencyTreePlugin.scala
@@ -0,0 +1,26 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package plugins
+
+object DependencyTreePlugin extends AutoPlugin {
+  object autoImport extends DependencyTreeKeys
+  override def trigger = AllRequirements
+  override def requires = MiniDependencyTreePlugin
+
+  val configurations = Vector(Compile, Test, IntegrationTest, Runtime, Provided, Optional)
+
+  // MiniDependencyTreePlugin provides baseBasicReportingSettings for Compile and Test
+  override def projectSettings: Seq[Def.Setting[_]] =
+    ((configurations diff Vector(Compile, Test)) flatMap { config =>
+      inConfig(config)(DependencyTreeSettings.baseBasicReportingSettings)
+    }) ++
+      (configurations flatMap { config =>
+        inConfig(config)(DependencyTreeSettings.baseFullReportingSettings)
+      })
+}
diff --git a/internal/util-collection/NOTICE b/internal/util-collection/NOTICE
new file mode 100644
index 000000000..db1ba7e33
--- /dev/null
+++ b/internal/util-collection/NOTICE
@@ -0,0 +1,4 @@
+sbt: Collection Component
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under BSD-3-Clause license (see LICENSE)
diff --git a/internal/util-collection/src/main/scala-2.12/sbt/internal/util/Par.scala b/internal/util-collection/src/main/scala-2.12/sbt/internal/util/Par.scala
new file mode 100644
index 000000000..34e939244
--- /dev/null
+++ b/internal/util-collection/src/main/scala-2.12/sbt/internal/util/Par.scala
@@ -0,0 +1,13 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+import scala.collection.parallel.ParSeq
+
+private[util] object Par {
+  def apply[R](s: Seq[R]): ParSeq[R] = s.par
+}
diff --git a/internal/util-collection/src/main/scala-2.12/sbt/internal/util/WrappedMap.scala b/internal/util-collection/src/main/scala-2.12/sbt/internal/util/WrappedMap.scala
new file mode 100644
index 000000000..6a8caf80f
--- /dev/null
+++ b/internal/util-collection/src/main/scala-2.12/sbt/internal/util/WrappedMap.scala
@@ -0,0 +1,17 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import scala.collection.JavaConverters._
+private[util] class WrappedMap[K, V](val jmap: java.util.Map[K, V]) extends Map[K, V] {
+  def +[V1 >: V](kv: (K, V1)): scala.collection.immutable.Map[K, V1] =
+    jmap.asScala.toMap + kv
+  def -(key: K): scala.collection.immutable.Map[K, V] = jmap.asScala.toMap - key
+  def get(key: K): Option[V] = Option(jmap.get(key))
+  def iterator: Iterator[(K, V)] = jmap.asScala.iterator
+}
diff --git a/internal/util-collection/src/main/scala-2.13/sbt/internal/util/Par.scala b/internal/util-collection/src/main/scala-2.13/sbt/internal/util/Par.scala
new file mode 100644
index 000000000..d7fa1d766
--- /dev/null
+++ b/internal/util-collection/src/main/scala-2.13/sbt/internal/util/Par.scala
@@ -0,0 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+import scala.collection.parallel.CollectionConverters._
+import scala.collection.parallel.ParSeq
+
+private[util] object Par {
+  def apply[R](s: Seq[R]): ParSeq[R] = s.par
+}
diff --git a/internal/util-collection/src/main/scala-2.13/sbt/internal/util/WrappedMap.scala b/internal/util-collection/src/main/scala-2.13/sbt/internal/util/WrappedMap.scala
new file mode 100644
index 000000000..8d8a29e1d
--- /dev/null
+++ b/internal/util-collection/src/main/scala-2.13/sbt/internal/util/WrappedMap.scala
@@ -0,0 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import scala.collection.JavaConverters._
+private[util] class WrappedMap[K, V](val jmap: java.util.Map[K, V]) extends Map[K, V] {
+  def removed(key: K): scala.collection.immutable.Map[K, V] = jmap.asScala.toMap.removed(key)
+  def updated[V1 >: V](key: K, value: V1): scala.collection.immutable.Map[K, V1] =
+    jmap.asScala.toMap.updated(key, value)
+
+  def get(key: K): Option[V] = Option(jmap.get(key))
+  def iterator: Iterator[(K, V)] = jmap.asScala.iterator
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/AList.scala b/internal/util-collection/src/main/scala/sbt/internal/util/AList.scala
new file mode 100644
index 000000000..ca10d2356
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/AList.scala
@@ -0,0 +1,389 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import Classes.Applicative
+import Types._
+
+/**
+ * An abstraction over a higher-order type constructor `K[x[y]]` with the purpose of abstracting
+ * over heterogeneous sequences like `KList` and `TupleN` with elements with a common type
+ * constructor as well as homogeneous sequences `Seq[M[T]]`.
+ */
+trait AList[K[L[x]]] {
+  def transform[M[_], N[_]](value: K[M], f: M ~> N): K[N]
+  def traverse[M[_], N[_], P[_]](value: K[M], f: M ~> (N ∙ P)#l)(
+      implicit np: Applicative[N]
+  ): N[K[P]]
+  def foldr[M[_], A](value: K[M], f: (M[_], A) => A, init: A): A
+
+  def toList[M[_]](value: K[M]): List[M[_]] = foldr[M, List[M[_]]](value, _ :: _, Nil)
+
+  def apply[M[_], C](value: K[M], f: K[Id] => C)(implicit a: Applicative[M]): M[C] =
+    a.map(f, traverse[M, M, Id](value, idK[M])(a))
+}
+
+object AList {
+  type Empty = AList[ConstK[Unit]#l]
+
+  /** AList for Unit, which represents a sequence that is always empty.*/
+  val empty: Empty = new Empty {
+    def transform[M[_], N[_]](in: Unit, f: M ~> N) = ()
+    def foldr[M[_], T](in: Unit, f: (M[_], T) => T, init: T) = init
+    override def apply[M[_], C](in: Unit, f: Unit => C)(implicit app: Applicative[M]): M[C] =
+      app.pure(f(()))
+    def traverse[M[_], N[_], P[_]](in: Unit, f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[Unit] = np.pure(())
+  }
+
+  type SeqList[T] = AList[λ[L[x] => List[L[T]]]]
+
+  /** AList for a homogeneous sequence. */
+  def seq[T]: SeqList[T] = new SeqList[T] {
+    def transform[M[_], N[_]](s: List[M[T]], f: M ~> N) = s.map(f.fn[T])
+    def foldr[M[_], A](s: List[M[T]], f: (M[_], A) => A, init: A): A =
+      s.reverse.foldLeft(init)((t, m) => f(m, t))
+
+    override def apply[M[_], C](s: List[M[T]], f: List[T] => C)(
+        implicit ap: Applicative[M]
+    ): M[C] = {
+      def loop[V](in: List[M[T]], g: List[T] => V): M[V] =
+        in match {
+          case Nil => ap.pure(g(Nil))
+          case x :: xs =>
+            val h = (ts: List[T]) => (t: T) => g(t :: ts)
+            ap.apply(loop(xs, h), x)
+        }
+      loop(s, f)
+    }
+
+    def traverse[M[_], N[_], P[_]](s: List[M[T]], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[List[P[T]]] = ???
+  }
+
+  /** AList for the arbitrary arity data structure KList. */
+  def klist[KL[M[_]] <: KList.Aux[M, KL]]: AList[KL] = new AList[KL] {
+    def transform[M[_], N[_]](k: KL[M], f: M ~> N) = k.transform(f)
+    def foldr[M[_], T](k: KL[M], f: (M[_], T) => T, init: T): T = k.foldr(f, init)
+    override def apply[M[_], C](k: KL[M], f: KL[Id] => C)(implicit app: Applicative[M]): M[C] =
+      k.apply(f)(app)
+    def traverse[M[_], N[_], P[_]](k: KL[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[KL[P]] = k.traverse[N, P](f)(np)
+    override def toList[M[_]](k: KL[M]) = k.toList
+  }
+
+  type Single[A] = AList[λ[L[x] => L[A]]]
+
+  /** AList for a single value. */
+  def single[A]: Single[A] = new Single[A] {
+    def transform[M[_], N[_]](a: M[A], f: M ~> N) = f(a)
+    def foldr[M[_], T](a: M[A], f: (M[_], T) => T, init: T): T = f(a, init)
+    def traverse[M[_], N[_], P[_]](a: M[A], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[P[A]] = f(a)
+  }
+
+  /** Example: calling `AList.SplitK[K, Task]#l` returns the type lambda `A[x] => K[A[Task[x]]`. */
+  sealed trait SplitK[K[L[x]], B[x]] { type l[A[x]] = K[(A ∙ B)#l] }
+
+  type ASplit[K[L[x]], B[x]] = AList[SplitK[K, B]#l]
+
+  /** AList that operates on the outer type constructor `A` of a composition `[x] A[B[x]]` for type constructors `A` and `B`. */
+  def asplit[K[L[x]], B[x]](base: AList[K]): ASplit[K, B] = new ASplit[K, B] {
+    type Split[L[x]] = K[(L ∙ B)#l]
+
+    def transform[M[_], N[_]](value: Split[M], f: M ~> N): Split[N] =
+      base.transform[(M ∙ B)#l, (N ∙ B)#l](value, nestCon[M, N, B](f))
+
+    def traverse[M[_], N[_], P[_]](value: Split[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[Split[P]] = {
+      val g = nestCon[M, (N ∙ P)#l, B](f)
+      base.traverse[(M ∙ B)#l, N, (P ∙ B)#l](value, g)(np)
+    }
+
+    def foldr[M[_], A](value: Split[M], f: (M[_], A) => A, init: A): A =
+      base.foldr[(M ∙ B)#l, A](value, f, init)
+  }
+
+  // TODO: auto-generate
+  sealed trait T2K[A, B] { type l[L[x]] = (L[A], L[B]) }
+  type T2List[A, B] = AList[T2K[A, B]#l]
+  def tuple2[A, B]: T2List[A, B] = new T2List[A, B] {
+    type T2[M[_]] = (M[A], M[B])
+    def transform[M[_], N[_]](t: T2[M], f: M ~> N): T2[N] = (f(t._1), f(t._2))
+    def foldr[M[_], T](t: T2[M], f: (M[_], T) => T, init: T): T = f(t._1, f(t._2, init))
+    def traverse[M[_], N[_], P[_]](t: T2[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[T2[P]] = {
+      val g = (Tuple2.apply[P[A], P[B]] _).curried
+      np.apply(np.map(g, f(t._1)), f(t._2))
+    }
+  }
+
+  sealed trait T3K[A, B, C] { type l[L[x]] = (L[A], L[B], L[C]) }
+  type T3List[A, B, C] = AList[T3K[A, B, C]#l]
+  def tuple3[A, B, C]: T3List[A, B, C] = new T3List[A, B, C] {
+    type T3[M[_]] = (M[A], M[B], M[C])
+    def transform[M[_], N[_]](t: T3[M], f: M ~> N) = (f(t._1), f(t._2), f(t._3))
+    def foldr[M[_], T](t: T3[M], f: (M[_], T) => T, init: T): T = f(t._1, f(t._2, f(t._3, init)))
+    def traverse[M[_], N[_], P[_]](t: T3[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[T3[P]] = {
+      val g = (Tuple3.apply[P[A], P[B], P[C]] _).curried
+      np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3))
+    }
+  }
+
+  sealed trait T4K[A, B, C, D] { type l[L[x]] = (L[A], L[B], L[C], L[D]) }
+  type T4List[A, B, C, D] = AList[T4K[A, B, C, D]#l]
+  def tuple4[A, B, C, D]: T4List[A, B, C, D] = new T4List[A, B, C, D] {
+    type T4[M[_]] = (M[A], M[B], M[C], M[D])
+    def transform[M[_], N[_]](t: T4[M], f: M ~> N) = (f(t._1), f(t._2), f(t._3), f(t._4))
+    def foldr[M[_], T](t: T4[M], f: (M[_], T) => T, init: T): T =
+      f(t._1, f(t._2, f(t._3, f(t._4, init))))
+    def traverse[M[_], N[_], P[_]](t: T4[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[T4[P]] = {
+      val g = (Tuple4.apply[P[A], P[B], P[C], P[D]] _).curried
+      np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4))
+    }
+  }
+
+  sealed trait T5K[A, B, C, D, E] { type l[L[x]] = (L[A], L[B], L[C], L[D], L[E]) }
+  type T5List[A, B, C, D, E] = AList[T5K[A, B, C, D, E]#l]
+  def tuple5[A, B, C, D, E]: T5List[A, B, C, D, E] = new T5List[A, B, C, D, E] {
+    type T5[M[_]] = (M[A], M[B], M[C], M[D], M[E])
+    def transform[M[_], N[_]](t: T5[M], f: M ~> N) = (f(t._1), f(t._2), f(t._3), f(t._4), f(t._5))
+    def foldr[M[_], T](t: T5[M], f: (M[_], T) => T, init: T): T =
+      f(t._1, f(t._2, f(t._3, f(t._4, f(t._5, init)))))
+    def traverse[M[_], N[_], P[_]](t: T5[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[T5[P]] = {
+      val g = (Tuple5.apply[P[A], P[B], P[C], P[D], P[E]] _).curried
+      np.apply(np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4)), f(t._5))
+    }
+  }
+
+  sealed trait T6K[A, B, C, D, E, F] { type l[L[x]] = (L[A], L[B], L[C], L[D], L[E], L[F]) }
+  type T6List[A, B, C, D, E, F] = AList[T6K[A, B, C, D, E, F]#l]
+  def tuple6[A, B, C, D, E, F]: T6List[A, B, C, D, E, F] = new T6List[A, B, C, D, E, F] {
+    type T6[M[_]] = (M[A], M[B], M[C], M[D], M[E], M[F])
+    def transform[M[_], N[_]](t: T6[M], f: M ~> N) =
+      (f(t._1), f(t._2), f(t._3), f(t._4), f(t._5), f(t._6))
+    def foldr[M[_], T](t: T6[M], f: (M[_], T) => T, init: T): T =
+      f(t._1, f(t._2, f(t._3, f(t._4, f(t._5, f(t._6, init))))))
+    def traverse[M[_], N[_], P[_]](t: T6[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[T6[P]] = {
+      val g = (Tuple6.apply[P[A], P[B], P[C], P[D], P[E], P[F]] _).curried
+      np.apply(
+        np.apply(
+          np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4)),
+          f(t._5)
+        ),
+        f(t._6)
+      )
+    }
+  }
+
+  sealed trait T7K[A, B, C, D, E, F, G] {
+    type l[L[x]] = (L[A], L[B], L[C], L[D], L[E], L[F], L[G])
+  }
+  type T7List[A, B, C, D, E, F, G] = AList[T7K[A, B, C, D, E, F, G]#l]
+  def tuple7[A, B, C, D, E, F, G]: T7List[A, B, C, D, E, F, G] = new T7List[A, B, C, D, E, F, G] {
+    type T7[M[_]] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G])
+    def transform[M[_], N[_]](t: T7[M], f: M ~> N) =
+      (f(t._1), f(t._2), f(t._3), f(t._4), f(t._5), f(t._6), f(t._7))
+    def foldr[M[_], T](t: T7[M], f: (M[_], T) => T, init: T): T =
+      f(t._1, f(t._2, f(t._3, f(t._4, f(t._5, f(t._6, f(t._7, init)))))))
+    def traverse[M[_], N[_], P[_]](t: T7[M], f: M ~> (N ∙ P)#l)(
+        implicit np: Applicative[N]
+    ): N[T7[P]] = {
+      val g = (Tuple7.apply[P[A], P[B], P[C], P[D], P[E], P[F], P[G]] _).curried
+      np.apply(
+        np.apply(
+          np.apply(
+            np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4)),
+            f(t._5)
+          ),
+          f(t._6)
+        ),
+        f(t._7)
+      )
+    }
+  }
+
+  sealed trait T8K[A, B, C, D, E, F, G, H] {
+    type l[L[x]] = (L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H])
+  }
+  type T8List[A, B, C, D, E, F, G, H] = AList[T8K[A, B, C, D, E, F, G, H]#l]
+  def tuple8[A, B, C, D, E, F, G, H]: T8List[A, B, C, D, E, F, G, H] =
+    new T8List[A, B, C, D, E, F, G, H] {
+      type T8[M[_]] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H])
+      def transform[M[_], N[_]](t: T8[M], f: M ~> N) =
+        (f(t._1), f(t._2), f(t._3), f(t._4), f(t._5), f(t._6), f(t._7), f(t._8))
+      def foldr[M[_], T](t: T8[M], f: (M[_], T) => T, init: T): T =
+        f(t._1, f(t._2, f(t._3, f(t._4, f(t._5, f(t._6, f(t._7, f(t._8, init))))))))
+      def traverse[M[_], N[_], P[_]](t: T8[M], f: M ~> (N ∙ P)#l)(
+          implicit np: Applicative[N]
+      ): N[T8[P]] = {
+        val g = (Tuple8.apply[P[A], P[B], P[C], P[D], P[E], P[F], P[G], P[H]] _).curried
+        np.apply(
+          np.apply(
+            np.apply(
+              np.apply(
+                np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4)),
+                f(t._5)
+              ),
+              f(t._6)
+            ),
+            f(t._7)
+          ),
+          f(t._8)
+        )
+      }
+    }
+
+  sealed trait T9K[A, B, C, D, E, F, G, H, I] {
+    type l[L[x]] = (L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H], L[I])
+  }
+  type T9List[A, B, C, D, E, F, G, H, I] = AList[T9K[A, B, C, D, E, F, G, H, I]#l]
+  def tuple9[A, B, C, D, E, F, G, H, I]: T9List[A, B, C, D, E, F, G, H, I] =
+    new T9List[A, B, C, D, E, F, G, H, I] {
+      type T9[M[_]] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I])
+      def transform[M[_], N[_]](t: T9[M], f: M ~> N) =
+        (f(t._1), f(t._2), f(t._3), f(t._4), f(t._5), f(t._6), f(t._7), f(t._8), f(t._9))
+      def foldr[M[_], T](t: T9[M], f: (M[_], T) => T, init: T): T =
+        f(t._1, f(t._2, f(t._3, f(t._4, f(t._5, f(t._6, f(t._7, f(t._8, f(t._9, init)))))))))
+      def traverse[M[_], N[_], P[_]](t: T9[M], f: M ~> (N ∙ P)#l)(
+          implicit np: Applicative[N]
+      ): N[T9[P]] = {
+        val g = (Tuple9.apply[P[A], P[B], P[C], P[D], P[E], P[F], P[G], P[H], P[I]] _).curried
+        np.apply(
+          np.apply(
+            np.apply(
+              np.apply(
+                np.apply(
+                  np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4)),
+                  f(t._5)
+                ),
+                f(t._6)
+              ),
+              f(t._7)
+            ),
+            f(t._8)
+          ),
+          f(t._9)
+        )
+      }
+    }
+
+  sealed trait T10K[A, B, C, D, E, F, G, H, I, J] {
+    type l[L[x]] = (L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H], L[I], L[J])
+  }
+  type T10List[A, B, C, D, E, F, G, H, I, J] = AList[T10K[A, B, C, D, E, F, G, H, I, J]#l]
+  def tuple10[A, B, C, D, E, F, G, H, I, J]: T10List[A, B, C, D, E, F, G, H, I, J] =
+    new T10List[A, B, C, D, E, F, G, H, I, J] {
+      type T10[M[_]] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J])
+      def transform[M[_], N[_]](t: T10[M], f: M ~> N) =
+        (f(t._1), f(t._2), f(t._3), f(t._4), f(t._5), f(t._6), f(t._7), f(t._8), f(t._9), f(t._10))
+      def foldr[M[_], T](t: T10[M], f: (M[_], T) => T, init: T): T =
+        f(
+          t._1,
+          f(t._2, f(t._3, f(t._4, f(t._5, f(t._6, f(t._7, f(t._8, f(t._9, f(t._10, init)))))))))
+        )
+      def traverse[M[_], N[_], P[_]](t: T10[M], f: M ~> (N ∙ P)#l)(
+          implicit np: Applicative[N]
+      ): N[T10[P]] = {
+        val g =
+          (Tuple10.apply[P[A], P[B], P[C], P[D], P[E], P[F], P[G], P[H], P[I], P[J]] _).curried
+        np.apply(
+          np.apply(
+            np.apply(
+              np.apply(
+                np.apply(
+                  np.apply(
+                    np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4)),
+                    f(t._5)
+                  ),
+                  f(t._6)
+                ),
+                f(t._7)
+              ),
+              f(t._8)
+            ),
+            f(t._9)
+          ),
+          f(t._10)
+        )
+      }
+    }
+
+  sealed trait T11K[A, B, C, D, E, F, G, H, I, J, K] {
+    type l[L[x]] = (L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H], L[I], L[J], L[K])
+  }
+  type T11List[A, B, C, D, E, F, G, H, I, J, K] = AList[T11K[A, B, C, D, E, F, G, H, I, J, K]#l]
+  def tuple11[A, B, C, D, E, F, G, H, I, J, K]: T11List[A, B, C, D, E, F, G, H, I, J, K] =
+    new T11List[A, B, C, D, E, F, G, H, I, J, K] {
+      type T11[M[_]] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K])
+      def transform[M[_], N[_]](t: T11[M], f: M ~> N) =
+        (
+          f(t._1),
+          f(t._2),
+          f(t._3),
+          f(t._4),
+          f(t._5),
+          f(t._6),
+          f(t._7),
+          f(t._8),
+          f(t._9),
+          f(t._10),
+          f(t._11)
+        )
+      def foldr[M[_], T](t: T11[M], f: (M[_], T) => T, init: T): T =
+        f(
+          t._1,
+          f(
+            t._2,
+            f(t._3, f(t._4, f(t._5, f(t._6, f(t._7, f(t._8, f(t._9, f(t._10, f(t._11, init)))))))))
+          )
+        )
+      def traverse[M[_], N[_], P[_]](t: T11[M], f: M ~> (N ∙ P)#l)(
+          implicit np: Applicative[N]
+      ): N[T11[P]] = {
+        val g = (Tuple11
+          .apply[P[A], P[B], P[C], P[D], P[E], P[F], P[G], P[H], P[I], P[J], P[K]] _).curried
+        np.apply(
+          np.apply(
+            np.apply(
+              np.apply(
+                np.apply(
+                  np.apply(
+                    np.apply(
+                      np.apply(np.apply(np.apply(np.map(g, f(t._1)), f(t._2)), f(t._3)), f(t._4)),
+                      f(t._5)
+                    ),
+                    f(t._6)
+                  ),
+                  f(t._7)
+                ),
+                f(t._8)
+              ),
+              f(t._9)
+            ),
+            f(t._10)
+          ),
+          f(t._11)
+        )
+      }
+    }
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Attributes.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Attributes.scala
new file mode 100644
index 000000000..0c1d2cf2c
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/Attributes.scala
@@ -0,0 +1,278 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import Types._
+import scala.reflect.Manifest
+import sbt.util.OptJsonWriter
+
+// T must be invariant to work properly.
+//  Because it is sealed and the only instances go through AttributeKey.apply,
+//  a single AttributeKey instance cannot conform to AttributeKey[T] for different Ts
+
+/**
+ * A key in an [[AttributeMap]] that constrains its associated value to be of type `T`.
+ * The key is uniquely defined by its `label` and type `T`, represented at runtime by `manifest`.
+ */
+sealed trait AttributeKey[T] {
+
+  /** The runtime evidence for `T`. */
+  def manifest: Manifest[T]
+
+  /** The label is the identifier for the key and is camelCase by convention. */
+  def label: String
+
+  /** An optional, brief description of the key. */
+  def description: Option[String]
+
+  /**
+   * In environments that support delegation, looking up this key when it has no associated value
+   * will delegate to the values associated with these keys.
+   * The delegation proceeds in order the keys are returned here.
+   */
+  def extend: Seq[AttributeKey[_]]
+
+  /**
+   * Specifies whether this key is a local, anonymous key (`true`) or not (`false`).
+   * This is typically only used for programmatic, intermediate keys that should not be referenced outside of a specific scope.
+   */
+  def isLocal: Boolean
+
+  /** Identifies the relative importance of a key among other keys.*/
+  def rank: Int
+
+  def optJsonWriter: OptJsonWriter[T]
+
+}
+
+private[sbt] abstract class SharedAttributeKey[T] extends AttributeKey[T] {
+  override final def toString = label
+  override final def hashCode = label.hashCode
+  override final def equals(o: Any) =
+    (this eq o.asInstanceOf[AnyRef]) || (o match {
+      case a: SharedAttributeKey[t] => a.label == this.label && a.manifest == this.manifest
+      case _                        => false
+    })
+  final def isLocal: Boolean = false
+}
+
+object AttributeKey {
+  def apply[T: Manifest: OptJsonWriter](name: String): AttributeKey[T] =
+    make(name, None, Nil, Int.MaxValue)
+
+  def apply[T: Manifest: OptJsonWriter](name: String, rank: Int): AttributeKey[T] =
+    make(name, None, Nil, rank)
+
+  def apply[T: Manifest: OptJsonWriter](name: String, description: String): AttributeKey[T] =
+    apply(name, description, Nil)
+
+  def apply[T: Manifest: OptJsonWriter](
+      name: String,
+      description: String,
+      rank: Int
+  ): AttributeKey[T] =
+    apply(name, description, Nil, rank)
+
+  def apply[T: Manifest: OptJsonWriter](
+      name: String,
+      description: String,
+      extend: Seq[AttributeKey[_]]
+  ): AttributeKey[T] =
+    apply(name, description, extend, Int.MaxValue)
+
+  def apply[T: Manifest: OptJsonWriter](
+      name: String,
+      description: String,
+      extend: Seq[AttributeKey[_]],
+      rank: Int
+  ): AttributeKey[T] =
+    make(name, Some(description), extend, rank)
+
+  private[sbt] def copyWithRank[T](a: AttributeKey[T], rank: Int): AttributeKey[T] =
+    make(a.label, a.description, a.extend, rank)(a.manifest, a.optJsonWriter)
+
+  private[this] def make[T](
+      name: String,
+      description0: Option[String],
+      extend0: Seq[AttributeKey[_]],
+      rank0: Int
+  )(implicit mf: Manifest[T], ojw: OptJsonWriter[T]): AttributeKey[T] =
+    new SharedAttributeKey[T] {
+      require(
+        name.headOption.exists(_.isLower),
+        s"A named attribute key must start with a lowercase letter: $name"
+      )
+
+      def manifest = mf
+      val label = Util.hyphenToCamel(name)
+      def description = description0
+      def extend = extend0
+      def rank = rank0
+      def optJsonWriter = ojw
+    }
+
+  private[sbt] def local[T](implicit mf: Manifest[T], ojw: OptJsonWriter[T]): AttributeKey[T] =
+    new AttributeKey[T] {
+      def manifest = mf
+      def label = LocalLabel
+      def description = None
+      def extend = Nil
+      override def toString = label
+      def isLocal: Boolean = true
+      def rank = Int.MaxValue
+      val optJsonWriter = ojw
+    }
+
+  private[sbt] final val LocalLabel = "$" + "local"
+
+}
+
+/**
+ * An immutable map where a key is the tuple `(String,T)` for a fixed type `T` and can only be associated with values of type `T`.
+ * It is therefore possible for this map to contain mappings for keys with the same label but different types.
+ * Excluding this possibility is the responsibility of the client if desired.
+ */
+trait AttributeMap {
+
+  /**
+   * Gets the value of type `T` associated with the key `k`.
+   * If a key with the same label but different type is defined, this method will fail.
+   */
+  def apply[T](k: AttributeKey[T]): T
+
+  /**
+   * Gets the value of type `T` associated with the key `k` or `None` if no value is associated.
+   * If a key with the same label but a different type is defined, this method will return `None`.
+   */
+  def get[T](k: AttributeKey[T]): Option[T]
+
+  /**
+   * Returns this map without the mapping for `k`.
+   * This method will not remove a mapping for a key with the same label but a different type.
+   */
+  def remove[T](k: AttributeKey[T]): AttributeMap
+
+  /**
+   * Returns true if this map contains a mapping for `k`.
+   * If a key with the same label but a different type is defined in this map, this method will return `false`.
+   */
+  def contains[T](k: AttributeKey[T]): Boolean
+
+  /**
+   * Adds the mapping `k -> value` to this map, replacing any existing mapping for `k`.
+   * Any mappings for keys with the same label but different types are unaffected.
+   */
+  def put[T](k: AttributeKey[T], value: T): AttributeMap
+
+  /** All keys with defined mappings.  There may be multiple keys with the same `label`, but different types. */
+  def keys: Iterable[AttributeKey[_]]
+
+  /** Adds the mappings in `o` to this map, with mappings in `o` taking precedence over existing mappings.*/
+  def ++(o: Iterable[AttributeEntry[_]]): AttributeMap
+
+  /** Combines the mappings in `o` with the mappings in this map, with mappings in `o` taking precedence over existing mappings.*/
+  def ++(o: AttributeMap): AttributeMap
+
+  /** All mappings in this map.  The [[AttributeEntry]] type preserves the typesafety of mappings, although the specific types are unknown.*/
+  def entries: Iterable[AttributeEntry[_]]
+
+  /** `true` if there are no mappings in this map, `false` if there are. */
+  def isEmpty: Boolean
+
+  /**
+   * Adds the mapping `k -> opt.get` if opt is Some.
+   * Otherwise, it returns this map without the mapping for `k`.
+   */
+  private[sbt] def setCond[T](k: AttributeKey[T], opt: Option[T]): AttributeMap
+}
+
+object AttributeMap {
+
+  /** An [[AttributeMap]] without any mappings. */
+  val empty: AttributeMap = new BasicAttributeMap(Map.empty)
+
+  /** Constructs an [[AttributeMap]] containing the given `entries`. */
+  def apply(entries: Iterable[AttributeEntry[_]]): AttributeMap = empty ++ entries
+
+  /** Constructs an [[AttributeMap]] containing the given `entries`.*/
+  def apply(entries: AttributeEntry[_]*): AttributeMap = empty ++ entries
+
+  /** Presents an `AttributeMap` as a natural transformation. */
+  implicit def toNatTrans(map: AttributeMap): AttributeKey ~> Id = λ[AttributeKey ~> Id](map(_))
+}
+
+private class BasicAttributeMap(private val backing: Map[AttributeKey[_], Any])
+    extends AttributeMap {
+
+  def isEmpty: Boolean = backing.isEmpty
+  def apply[T](k: AttributeKey[T]) = backing(k).asInstanceOf[T]
+  def get[T](k: AttributeKey[T]) = backing.get(k).asInstanceOf[Option[T]]
+  def remove[T](k: AttributeKey[T]): AttributeMap = new BasicAttributeMap(backing - k)
+  def contains[T](k: AttributeKey[T]) = backing.contains(k)
+
+  def put[T](k: AttributeKey[T], value: T): AttributeMap =
+    new BasicAttributeMap(backing.updated(k, value: Any))
+
+  def keys: Iterable[AttributeKey[_]] = backing.keys
+
+  def ++(o: Iterable[AttributeEntry[_]]): AttributeMap =
+    new BasicAttributeMap(o.foldLeft(backing)((b, e) => b.updated(e.key, e.value: Any)))
+
+  def ++(o: AttributeMap): AttributeMap = o match {
+    case bam: BasicAttributeMap =>
+      new BasicAttributeMap(Map(backing.toSeq ++ bam.backing.toSeq: _*))
+    case _ => o ++ this
+  }
+
+  def entries: Iterable[AttributeEntry[_]] =
+    backing.collect {
+      case (k: AttributeKey[kt], v) => AttributeEntry(k, v.asInstanceOf[kt])
+    }
+
+  private[sbt] def setCond[T](k: AttributeKey[T], opt: Option[T]): AttributeMap =
+    opt match {
+      case Some(v) => put(k, v)
+      case None    => remove(k)
+    }
+
+  override def toString = entries.mkString("(", ", ", ")")
+}
+
+// type inference required less generality
+/** A map entry where `key` is constrained to only be associated with a fixed value of type `T`. */
+final case class AttributeEntry[T](key: AttributeKey[T], value: T) {
+  override def toString = key.label + ": " + value
+}
+
+/** Associates a `metadata` map with `data`. */
+final case class Attributed[D](data: D)(val metadata: AttributeMap) {
+
+  /** Retrieves the associated value of `key` from the metadata. */
+  def get[T](key: AttributeKey[T]): Option[T] = metadata.get(key)
+
+  /** Defines a mapping `key -> value` in the metadata. */
+  def put[T](key: AttributeKey[T], value: T): Attributed[D] =
+    Attributed(data)(metadata.put(key, value))
+
+  /** Transforms the data by applying `f`. */
+  def map[T](f: D => T): Attributed[T] = Attributed(f(data))(metadata)
+
+}
+
+object Attributed {
+
+  /** Extracts the underlying data from the sequence `in`. */
+  def data[T](in: Seq[Attributed[T]]): Seq[T] = in.map(_.data)
+
+  /** Associates empty metadata maps with each entry of `in`.*/
+  def blankSeq[T](in: Seq[T]): Seq[Attributed[T]] = in map blank
+
+  /** Associates an empty metadata map with `data`. */
+  def blank[T](data: T): Attributed[T] = Attributed(data)(AttributeMap.empty)
+
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Classes.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Classes.scala
new file mode 100644
index 000000000..2d7c7aeac
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/Classes.scala
@@ -0,0 +1,42 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+object Classes {
+  trait Applicative[M[_]] {
+    def apply[S, T](f: M[S => T], v: M[S]): M[T]
+    def pure[S](s: => S): M[S]
+    def map[S, T](f: S => T, v: M[S]): M[T]
+  }
+
+  trait Selective[M[_]] extends Applicative[M] {
+    def select[A, B](fab: M[Either[A, B]])(fn: M[A => B]): M[B]
+  }
+
+  trait Monad[M[_]] extends Applicative[M] {
+    def flatten[T](m: M[M[T]]): M[T]
+  }
+
+  implicit val optionMonad: Monad[Option] = new Monad[Option] {
+    def apply[S, T](f: Option[S => T], v: Option[S]) = (f, v) match {
+      case (Some(fv), Some(vv)) => Some(fv(vv))
+      case _                    => None
+    }
+
+    def pure[S](s: => S) = Some(s)
+    def map[S, T](f: S => T, v: Option[S]) = v map f
+    def flatten[T](m: Option[Option[T]]): Option[T] = m.flatten
+  }
+
+  implicit val listMonad: Monad[List] = new Monad[List] {
+    def apply[S, T](f: List[S => T], v: List[S]) = for (fv <- f; vv <- v) yield fv(vv)
+    def pure[S](s: => S) = s :: Nil
+    def map[S, T](f: S => T, v: List[S]) = v map f
+    def flatten[T](m: List[List[T]]): List[T] = m.flatten
+  }
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Dag.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Dag.scala
new file mode 100644
index 000000000..f5f584290
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/Dag.scala
@@ -0,0 +1,142 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+trait Dag[Node <: Dag[Node]] { self: Node =>
+
+  def dependencies: Iterable[Node]
+  def topologicalSort = Dag.topologicalSort(self)(_.dependencies)
+}
+object Dag {
+  import scala.collection.{ mutable, JavaConverters }
+  import JavaConverters.asScalaSetConverter
+
+  def topologicalSort[T](root: T)(dependencies: T => Iterable[T]): List[T] =
+    topologicalSort(root :: Nil)(dependencies)
+
+  def topologicalSort[T](nodes: Iterable[T])(dependencies: T => Iterable[T]): List[T] = {
+    val discovered = new mutable.HashSet[T]
+    val finished = (new java.util.LinkedHashSet[T]).asScala
+
+    def visitAll(nodes: Iterable[T]) = nodes foreach visit
+    def visit(node: T): Unit = {
+      if (!discovered(node)) {
+        discovered(node) = true;
+        try {
+          visitAll(dependencies(node));
+        } catch { case c: Cyclic => throw node :: c }
+        finished += node
+        ()
+      } else if (!finished(node))
+        throw new Cyclic(node)
+    }
+
+    visitAll(nodes)
+
+    finished.toList
+  }
+
+  // doesn't check for cycles
+  def topologicalSortUnchecked[T](node: T)(dependencies: T => Iterable[T]): List[T] =
+    topologicalSortUnchecked(node :: Nil)(dependencies)
+
+  def topologicalSortUnchecked[T](nodes: Iterable[T])(dependencies: T => Iterable[T]): List[T] = {
+    val discovered = new mutable.HashSet[T]
+    var finished: List[T] = Nil
+
+    def visitAll(nodes: Iterable[T]) = nodes foreach visit
+    def visit(node: T): Unit = {
+      if (!discovered(node)) {
+        discovered(node) = true
+        visitAll(dependencies(node))
+        finished ::= node
+      }
+    }
+
+    visitAll(nodes);
+    finished;
+  }
+
+  final class Cyclic(val value: Any, val all: List[Any], val complete: Boolean)
+      extends Exception(
+        "Cyclic reference involving " +
+          (if (complete) all.mkString("\n   ", "\n   ", "") else value)
+      ) {
+    def this(value: Any) = this(value, value :: Nil, false)
+    override def toString = getMessage
+
+    def ::(a: Any): Cyclic =
+      if (complete)
+        this
+      else if (a == value)
+        new Cyclic(value, all, true)
+      else
+        new Cyclic(value, a :: all, false)
+  }
+
+  /** A directed graph with edges labeled positive or negative. */
+  private[sbt] trait DirectedSignedGraph[Node] {
+
+    /**
+     * Directed edge type that tracks the sign and target (head) vertex.
+     * The sign can be obtained via [[isNegative]] and the target vertex via [[head]].
+     */
+    type Arrow
+
+    /** List of initial nodes. */
+    def nodes: List[Arrow]
+
+    /** Outgoing edges for `n`. */
+    def dependencies(n: Node): List[Arrow]
+
+    /** `true` if the edge `a` is "negative", false if it is "positive". */
+    def isNegative(a: Arrow): Boolean
+
+    /** The target of the directed edge `a`. */
+    def head(a: Arrow): Node
+
+  }
+
+  /**
+   * Traverses a directed graph defined by `graph` looking for a cycle that includes a "negative" edge.
+   * The directed edges are weighted by the caller as "positive" or "negative".
+   * If a cycle containing a "negative" edge is detected, its member edges are returned in order.
+   * Otherwise, the empty list is returned.
+   */
+  private[sbt] def findNegativeCycle[Node](graph: DirectedSignedGraph[Node]): List[graph.Arrow] = {
+    import graph._
+    val finished = new mutable.HashSet[Node]
+    val visited = new mutable.HashSet[Node]
+
+    def visit(edges: List[Arrow], stack: List[Arrow]): List[Arrow] = edges match {
+      case Nil => Nil
+      case edge :: tail =>
+        val node = head(edge)
+        if (!visited(node)) {
+          visited += node
+          visit(dependencies(node), edge :: stack) match {
+            case Nil =>
+              finished += node
+              visit(tail, stack)
+            case cycle => cycle
+          }
+        } else if (!finished(node)) {
+          // cycle. If a negative edge is involved, it is an error.
+          val between = edge :: stack.takeWhile(f => head(f) != node)
+          if (between exists isNegative)
+            between
+          else
+            visit(tail, stack)
+        } else
+          visit(tail, stack)
+    }
+
+    visit(graph.nodes, Nil)
+  }
+
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/HList.scala b/internal/util-collection/src/main/scala/sbt/internal/util/HList.scala
new file mode 100644
index 000000000..f0922a079
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/HList.scala
@@ -0,0 +1,40 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import Types._
+
+/**
+ * A minimal heterogeneous list type.  For background, see
+ * https://apocalisp.wordpress.com/2010/07/06/type-level-programming-in-scala-part-6a-heterogeneous-list basics/
+ */
+sealed trait HList {
+  type Wrap[M[_]] <: HList
+}
+
+sealed trait HNil extends HList {
+  type Wrap[M[_]] = HNil
+  def :+:[G](g: G): G :+: HNil = HCons(g, this)
+
+  override def toString = "HNil"
+}
+
+object HNil extends HNil
+
+final case class HCons[H, T <: HList](head: H, tail: T) extends HList {
+  type Wrap[M[_]] = M[H] :+: T#Wrap[M]
+  def :+:[G](g: G): G :+: H :+: T = HCons(g, this)
+
+  override def toString = head + " :+: " + tail.toString
+}
+
+object HList {
+  // contains no type information: not even A
+  implicit def fromList[A](list: Traversable[A]): HList =
+    list.foldLeft(HNil: HList)((hl, v) => HCons(v, hl))
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/HListFormats.scala b/internal/util-collection/src/main/scala/sbt/internal/util/HListFormats.scala
new file mode 100644
index 000000000..4143861b2
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/HListFormats.scala
@@ -0,0 +1,85 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package util
+
+import sjsonnew._
+import Types.:+:
+
+trait HListFormats {
+  implicit val lnilFormat1: JsonFormat[HNil] = forHNil(HNil: HNil)
+  implicit val lnilFormat2: JsonFormat[HNil.type] = forHNil(HNil)
+
+  private def forHNil[A <: HNil](hnil: A): JsonFormat[A] = new JsonFormat[A] {
+    def write[J](x: A, builder: Builder[J]): Unit = {
+      builder.beginArray()
+      builder.endArray()
+    }
+
+    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): A = jsOpt match {
+      case None     => hnil
+      case Some(js) => unbuilder.beginArray(js); unbuilder.endArray(); hnil
+    }
+  }
+
+  implicit def hconsFormat[H, T <: HList](
+      implicit hf: JsonFormat[H],
+      tf: HListJF[T]
+  ): JsonFormat[H :+: T] =
+    new JsonFormat[H :+: T] {
+      def write[J](hcons: H :+: T, builder: Builder[J]) = {
+        builder.beginArray()
+        hf.write(hcons.head, builder)
+        tf.write(hcons.tail, builder)
+        builder.endArray()
+      }
+
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+        case None => HCons(hf.read(None, unbuilder), tf.read(None, unbuilder))
+        case Some(js) =>
+          unbuilder.beginArray(js)
+          val hcons =
+            HCons(hf.read(Some(unbuilder.nextElement), unbuilder), tf.read(Some(js), unbuilder))
+          unbuilder.endArray()
+          hcons
+      }
+    }
+
+  trait HListJF[A <: HList] {
+    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): A
+    def write[J](obj: A, builder: Builder[J]): Unit
+  }
+
+  implicit def hconsHListJF[H, T <: HList](
+      implicit hf: JsonFormat[H],
+      tf: HListJF[T]
+  ): HListJF[H :+: T] =
+    new HListJF[H :+: T] {
+      def write[J](hcons: H :+: T, builder: Builder[J]) = {
+        hf.write(hcons.head, builder)
+        tf.write(hcons.tail, builder)
+      }
+
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+        case None => HCons(hf.read(None, unbuilder), tf.read(None, unbuilder))
+        case Some(js) =>
+          HCons(hf.read(Some(unbuilder.nextElement), unbuilder), tf.read(Some(js), unbuilder))
+      }
+    }
+
+  implicit val lnilHListJF1: HListJF[HNil] = hnilHListJF(HNil: HNil)
+  implicit val lnilHListJF2: HListJF[HNil.type] = hnilHListJF(HNil)
+
+  implicit def hnilHListJF[A <: HNil](hnil: A): HListJF[A] = new HListJF[A] {
+    def write[J](hcons: A, builder: Builder[J]) = ()
+    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = hnil
+  }
+}
+
+object HListFormats extends HListFormats
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/IDSet.scala b/internal/util-collection/src/main/scala/sbt/internal/util/IDSet.scala
new file mode 100644
index 000000000..b3cacdfe1
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/IDSet.scala
@@ -0,0 +1,60 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import scala.collection.JavaConverters._
+
+/** A mutable set interface that uses object identity to test for set membership.*/
+trait IDSet[T] {
+  def apply(t: T): Boolean
+  def contains(t: T): Boolean
+  def +=(t: T): Unit
+  def ++=(t: Iterable[T]): Unit
+  def -=(t: T): Boolean
+  def all: collection.Iterable[T]
+  def toList: List[T]
+  def isEmpty: Boolean
+  def foreach(f: T => Unit): Unit
+  def process[S](t: T)(ifSeen: S)(ifNew: => S): S
+}
+
+object IDSet {
+  implicit def toTraversable[T]: IDSet[T] => Traversable[T] = _.all
+  def apply[T](values: T*): IDSet[T] = fromIterable(values)
+
+  def apply[T](values: Iterable[T]): IDSet[T] = fromIterable(values)
+
+  private def fromIterable[T](values: Iterable[T]): IDSet[T] = {
+    val s = create[T]
+    s ++= values
+    s
+  }
+
+  def create[T]: IDSet[T] = new IDSet[T] {
+    private[this] val backing = new java.util.IdentityHashMap[T, AnyRef]
+    private[this] val Dummy: AnyRef = ""
+
+    def apply(t: T) = contains(t)
+    def contains(t: T) = backing.containsKey(t)
+    def foreach(f: T => Unit) = all foreach f
+    def +=(t: T) = { backing.put(t, Dummy); () }
+    def ++=(t: Iterable[T]) = t foreach +=
+    def -=(t: T) = if (backing.remove(t) eq null) false else true
+    def all = backing.keySet.asScala
+    def toList = all.toList
+    def isEmpty = backing.isEmpty
+
+    def process[S](t: T)(ifSeen: S)(ifNew: => S) =
+      if (contains(t)) ifSeen
+      else {
+        this += t; ifNew
+      }
+
+    override def toString = backing.toString
+  }
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/INode.scala b/internal/util-collection/src/main/scala/sbt/internal/util/INode.scala
new file mode 100644
index 000000000..3d7c86646
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/INode.scala
@@ -0,0 +1,230 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.lang.Runnable
+import java.util.concurrent.{ atomic, Executor, LinkedBlockingQueue }
+import atomic.{ AtomicBoolean, AtomicInteger }
+import Types.{ ConstK, Id }
+
+object EvaluationState extends Enumeration {
+  val New, Blocked, Ready, Calling, Evaluated = Value
+}
+
+abstract class EvaluateSettings[ScopeType] {
+  protected val init: Init[ScopeType]
+  import init._
+
+  protected def executor: Executor
+  protected def compiledSettings: Seq[Compiled[_]]
+
+  import EvaluationState.{ Value => EvaluationState, _ }
+
+  private[this] val complete = new LinkedBlockingQueue[Option[Throwable]]
+  private[this] val static = PMap.empty[ScopedKey, INode]
+  private[this] val allScopes: Set[ScopeType] = compiledSettings.map(_.key.scope).toSet
+
+  private[this] def getStatic[T](key: ScopedKey[T]): INode[T] =
+    static get key getOrElse sys.error("Illegal reference to key " + key)
+
+  private[this] val transform: Initialize ~> INode = λ[Initialize ~> INode] {
+    case k: Keyed[s, A1$] @unchecked => single(getStatic(k.scopedKey), k.transform)
+    case a: Apply[k, A1$] @unchecked =>
+      new MixedNode[k, A1$](
+        a.alist.transform[Initialize, INode](a.inputs, transform),
+        a.f,
+        a.alist
+      )
+    case b: Bind[s, A1$] @unchecked           => new BindNode[s, A1$](transform(b.in), x => transform(b.f(x)))
+    case v: Value[A1$] @unchecked             => constant(v.value)
+    case v: ValidationCapture[A1$] @unchecked => strictConstant(v.key: A1$)
+    case t: TransformCapture                  => strictConstant(t.f: A1$)
+    case o: Optional[s, A1$] @unchecked =>
+      o.a match {
+        case None    => constant(() => o.f(None))
+        case Some(i) => single[s, A1$](transform(i), x => o.f(Some(x)))
+      }
+    case x if x == StaticScopes =>
+      strictConstant(allScopes.asInstanceOf[A1$]) // can't convince scalac that StaticScopes => T == Set[Scope]
+  }
+
+  private[this] lazy val roots: Seq[INode[_]] = compiledSettings flatMap { cs =>
+    (cs.settings map { s =>
+      val t = transform(s.init)
+      static(s.key) = t
+      t
+    }): Seq[INode[_]]
+  }
+
+  private[this] val running = new AtomicInteger
+  private[this] val cancel = new AtomicBoolean(false)
+
+  def run(implicit delegates: ScopeType => Seq[ScopeType]): Settings[ScopeType] = {
+    assert(running.get() == 0, "Already running")
+    startWork()
+    roots.foreach(_.registerIfNew())
+    workComplete()
+    complete.take() foreach { ex =>
+      cancel.set(true)
+      throw ex
+    }
+    getResults(delegates)
+  }
+
+  private[this] def getResults(implicit delegates: ScopeType => Seq[ScopeType]) =
+    static.toTypedSeq.foldLeft(empty) {
+      case (ss, static.TPair(key, node)) =>
+        if (key.key.isLocal) ss else ss.set(key.scope, key.key, node.get)
+    }
+
+  private[this] val getValue = λ[INode ~> Id](_.get)
+
+  private[this] def submitEvaluate(node: INode[_]) = submit(node.evaluate())
+
+  private[this] def submitCallComplete[T](node: BindNode[_, T], value: T) =
+    submit(node.callComplete(value))
+
+  private[this] def submit(work: => Unit): Unit = {
+    startWork()
+    executor.execute(new Runnable { def run = if (!cancel.get()) run0(work) })
+  }
+
+  private[this] def run0(work: => Unit): Unit = {
+    try {
+      work
+    } catch { case e: Throwable => complete.put(Some(e)) }
+    workComplete()
+  }
+
+  private[this] def startWork(): Unit = { running.incrementAndGet(); () }
+
+  private[this] def workComplete(): Unit =
+    if (running.decrementAndGet() == 0)
+      complete.put(None)
+
+  private[this] sealed abstract class INode[T] {
+    private[this] var state: EvaluationState = New
+    private[this] var value: T = _
+    private[this] val blocking = new collection.mutable.ListBuffer[INode[_]]
+    private[this] var blockedOn: Int = 0
+    private[this] val calledBy = new collection.mutable.ListBuffer[BindNode[_, T]]
+
+    override def toString =
+      getClass.getName + " (state=" + state + ",blockedOn=" + blockedOn + ",calledBy=" + calledBy.size + ",blocking=" + blocking.size + "): " +
+        keyString
+
+    private[this] def keyString =
+      (static.toSeq.flatMap {
+        case (key, value) =>
+          if (value eq this) init.showFullKey.show(key) :: Nil else List.empty[String]
+      }).headOption getOrElse "non-static"
+
+    final def get: T = synchronized {
+      assert(value != null, toString + " not evaluated")
+      value
+    }
+
+    final def doneOrBlock(from: INode[_]): Boolean = synchronized {
+      val ready = state == Evaluated
+      if (!ready) {
+        blocking += from
+        ()
+      }
+      registerIfNew()
+      ready
+    }
+
+    final def isDone: Boolean = synchronized { state == Evaluated }
+    final def isNew: Boolean = synchronized { state == New }
+    final def isCalling: Boolean = synchronized { state == Calling }
+    final def registerIfNew(): Unit = synchronized { if (state == New) register() }
+
+    private[this] def register(): Unit = {
+      assert(state == New, "Already registered and: " + toString)
+      val deps = dependsOn
+      blockedOn = deps.size - deps.count(_.doneOrBlock(this))
+      if (blockedOn == 0)
+        schedule()
+      else
+        state = Blocked
+    }
+
+    final def schedule(): Unit = synchronized {
+      assert(state == New || state == Blocked, "Invalid state for schedule() call: " + toString)
+      state = Ready
+      submitEvaluate(this)
+    }
+
+    final def unblocked(): Unit = synchronized {
+      assert(state == Blocked, "Invalid state for unblocked() call: " + toString)
+      blockedOn -= 1
+      assert(blockedOn >= 0, "Negative blockedOn: " + blockedOn + " for " + toString)
+      if (blockedOn == 0) schedule()
+    }
+
+    final def evaluate(): Unit = synchronized { evaluate0() }
+
+    protected final def makeCall(source: BindNode[_, T], target: INode[T]): Unit = {
+      assert(state == Ready, "Invalid state for call to makeCall: " + toString)
+      state = Calling
+      target.call(source)
+    }
+
+    protected final def setValue(v: T): Unit = {
+      assert(
+        state != Evaluated,
+        "Already evaluated (trying to set value to " + v + "): " + toString
+      )
+      if (v == null) sys.error("Setting value cannot be null: " + keyString)
+      value = v
+      state = Evaluated
+      blocking foreach { _.unblocked() }
+      blocking.clear()
+      calledBy foreach { node =>
+        submitCallComplete(node, value)
+      }
+      calledBy.clear()
+    }
+
+    final def call(by: BindNode[_, T]): Unit = synchronized {
+      registerIfNew()
+      state match {
+        case Evaluated => submitCallComplete(by, value)
+        case _ =>
+          calledBy += by
+          ()
+      }
+    }
+
+    protected def dependsOn: Seq[INode[_]]
+    protected def evaluate0(): Unit
+  }
+
+  private[this] def strictConstant[T](v: T): INode[T] = constant(() => v)
+
+  private[this] def constant[T](f: () => T): INode[T] =
+    new MixedNode[ConstK[Unit]#l, T]((), _ => f(), AList.empty)
+
+  private[this] def single[S, T](in: INode[S], f: S => T): INode[T] =
+    new MixedNode[λ[L[x] => L[S]], T](in, f, AList.single[S])
+
+  private[this] final class BindNode[S, T](in: INode[S], f: S => INode[T]) extends INode[T] {
+    protected def dependsOn = in :: Nil
+    protected def evaluate0(): Unit = makeCall(this, f(in.get))
+    def callComplete(value: T): Unit = synchronized {
+      assert(isCalling, "Invalid state for callComplete(" + value + "): " + toString)
+      setValue(value)
+    }
+  }
+
+  private[this] final class MixedNode[K[L[x]], T](in: K[INode], f: K[Id] => T, alist: AList[K])
+      extends INode[T] {
+    protected def dependsOn = alist.toList(in)
+    protected def evaluate0(): Unit = setValue(f(alist.transform(in, getValue)))
+  }
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/KList.scala b/internal/util-collection/src/main/scala/sbt/internal/util/KList.scala
new file mode 100644
index 000000000..2761d8172
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/KList.scala
@@ -0,0 +1,70 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import Types._
+import Classes.Applicative
+
+/** A higher-kinded heterogeneous list of elements that share the same type constructor `M[_]`. */
+sealed trait KList[+M[_]] {
+  type Transform[N[_]] <: KList[N]
+
+  /** Apply the natural transformation `f` to each element. */
+  def transform[N[_]](f: M ~> N): Transform[N]
+
+  /** Folds this list using a function that operates on the homogeneous type of the elements of this list. */
+  def foldr[B](f: (M[_], B) => B, init: B): B
+
+  /** Applies `f` to the elements of this list in the applicative functor defined by `ap`. */
+  def apply[N[x] >: M[x], Z](f: Transform[Id] => Z)(implicit ap: Applicative[N]): N[Z]
+
+  /** Equivalent to `transform(f) . apply(x => x)`, this is the essence of the iterator at the level of natural transformations.*/
+  def traverse[N[_], P[_]](f: M ~> (N ∙ P)#l)(implicit np: Applicative[N]): N[Transform[P]]
+
+  /** Discards the heterogeneous type information and constructs a plain List from this KList's elements. */
+  def toList: List[M[_]]
+}
+object KList {
+  type Aux[+M[_], Transform0[N[_]]] = KList[M] { type Transform[N[_]] = Transform0[N] }
+}
+
+final case class KCons[H, +T <: KList[M], +M[_]](head: M[H], tail: T) extends KList[M] {
+  final type Transform[N[_]] = KCons[H, tail.Transform[N], N]
+
+  def transform[N[_]](f: M ~> N) = KCons(f(head), tail.transform(f))
+  def toList: List[M[_]] = head :: tail.toList
+
+  def apply[N[x] >: M[x], Z](f: Transform[Id] => Z)(implicit ap: Applicative[N]): N[Z] = {
+    val g = (t: tail.Transform[Id]) => (h: H) => f(KCons[H, tail.Transform[Id], Id](h, t))
+    ap.apply(tail.apply[N, H => Z](g), head)
+  }
+
+  def traverse[N[_], P[_]](f: M ~> (N ∙ P)#l)(implicit np: Applicative[N]): N[Transform[P]] = {
+    val tt: N[tail.Transform[P]] = tail.traverse[N, P](f)
+    val g = (t: tail.Transform[P]) => (h: P[H]) => KCons(h, t)
+    np.apply(np.map(g, tt), f(head))
+  }
+
+  def :^:[A, N[x] >: M[x]](h: N[A]) = KCons(h, this)
+  override def foldr[B](f: (M[_], B) => B, init: B): B = f(head, tail.foldr(f, init))
+}
+
+sealed abstract class KNil extends KList[NothingK] {
+  final type Transform[N[_]] = KNil
+  final def transform[N[_]](f: NothingK ~> N): Transform[N] = KNil
+  final def foldr[B](f: (NothingK[_], B) => B, init: B): B = init
+  final def toList = Nil
+  final def apply[N[x], Z](f: KNil => Z)(implicit ap: Applicative[N]): N[Z] = ap.pure(f(KNil))
+
+  final def traverse[N[_], P[_]](f: NothingK ~> (N ∙ P)#l)(implicit np: Applicative[N]): N[KNil] =
+    np.pure(KNil: KNil)
+}
+
+case object KNil extends KNil {
+  def :^:[M[_], H](h: M[H]): KCons[H, KNil, M] = KCons(h, this)
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/PMap.scala b/internal/util-collection/src/main/scala/sbt/internal/util/PMap.scala
new file mode 100644
index 000000000..ed90560ee
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/PMap.scala
@@ -0,0 +1,129 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import collection.mutable
+
+trait RMap[K[_], V[_]] {
+  def apply[T](k: K[T]): V[T]
+  def get[T](k: K[T]): Option[V[T]]
+  def contains[T](k: K[T]): Boolean
+  def toSeq: Seq[(K[_], V[_])]
+
+  def toTypedSeq: Seq[TPair[_]] = toSeq.map {
+    case (k: K[t], v) => TPair[t](k, v.asInstanceOf[V[t]])
+  }
+
+  def keys: Iterable[K[_]]
+  def values: Iterable[V[_]]
+  def isEmpty: Boolean
+
+  sealed case class TPair[T](key: K[T], value: V[T])
+}
+
+trait IMap[K[_], V[_]] extends (K ~> V) with RMap[K, V] {
+  def put[T](k: K[T], v: V[T]): IMap[K, V]
+  def remove[T](k: K[T]): IMap[K, V]
+  def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]): IMap[K, V]
+  def mapValues[V2[_]](f: V ~> V2): IMap[K, V2]
+  def mapSeparate[VL[_], VR[_]](f: V ~> λ[T => Either[VL[T], VR[T]]]): (IMap[K, VL], IMap[K, VR])
+}
+
+trait PMap[K[_], V[_]] extends (K ~> V) with RMap[K, V] {
+  def update[T](k: K[T], v: V[T]): Unit
+  def remove[T](k: K[T]): Option[V[T]]
+  def getOrUpdate[T](k: K[T], make: => V[T]): V[T]
+  def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]): V[T]
+}
+
+object PMap {
+  implicit def toFunction[K[_], V[_]](map: PMap[K, V]): K[_] => V[_] = k => map(k)
+  def empty[K[_], V[_]]: PMap[K, V] = new DelegatingPMap[K, V](new mutable.HashMap)
+}
+
+object IMap {
+
+  /**
+   * Only suitable for K that is invariant in its type parameter.
+   * Option and List keys are not suitable, for example,
+   *  because None &lt;:&lt; Option[String] and None &lt;: Option[Int].
+   */
+  def empty[K[_], V[_]]: IMap[K, V] = new IMap0[K, V](Map.empty)
+
+  private[sbt] def fromJMap[K[_], V[_]](map: java.util.Map[K[_], V[_]]): IMap[K, V] =
+    new IMap0[K, V](new WrappedMap(map))
+
+  private[sbt] class IMap0[K[_], V[_]](val backing: Map[K[_], V[_]])
+      extends AbstractRMap[K, V]
+      with IMap[K, V] {
+    def get[T](k: K[T]): Option[V[T]] = (backing get k).asInstanceOf[Option[V[T]]]
+    def put[T](k: K[T], v: V[T]) = new IMap0[K, V](backing.updated(k, v))
+    def remove[T](k: K[T]) = new IMap0[K, V](backing - k)
+
+    def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]) =
+      put(k, f(this get k getOrElse init))
+
+    def mapValues[V2[_]](f: V ~> V2) =
+      new IMap0[K, V2](Map(backing.iterator.map { case (k, v) => k -> f(v) }.toArray: _*))
+
+    def mapSeparate[VL[_], VR[_]](f: V ~> λ[T => Either[VL[T], VR[T]]]) = {
+      val left = new java.util.concurrent.ConcurrentHashMap[K[_], VL[_]]
+      val right = new java.util.concurrent.ConcurrentHashMap[K[_], VR[_]]
+      Par(backing.toVector).foreach {
+        case (k, v) =>
+          f(v) match {
+            case Left(l)  => left.put(k, l)
+            case Right(r) => right.put(k, r)
+          }
+      }
+      (new IMap0[K, VL](new WrappedMap(left)), new IMap0[K, VR](new WrappedMap(right)))
+    }
+
+    def toSeq = backing.toSeq
+    def keys = backing.keys
+    def values = backing.values
+    def isEmpty = backing.isEmpty
+
+    override def toString = backing.toString
+  }
+}
+
+abstract class AbstractRMap[K[_], V[_]] extends RMap[K, V] {
+  def apply[T](k: K[T]): V[T] = get(k).get
+  def contains[T](k: K[T]): Boolean = get(k).isDefined
+}
+
+/**
+ * Only suitable for K that is invariant in its type parameter.
+ * Option and List keys are not suitable, for example,
+ *  because None &lt;:&lt; Option[String] and None &lt;: Option[Int].
+ */
+class DelegatingPMap[K[_], V[_]](backing: mutable.Map[K[_], V[_]])
+    extends AbstractRMap[K, V]
+    with PMap[K, V] {
+  def get[T](k: K[T]): Option[V[T]] = cast[T](backing.get(k))
+  def update[T](k: K[T], v: V[T]): Unit = { backing(k) = v }
+  def remove[T](k: K[T]) = cast(backing.remove(k))
+  def getOrUpdate[T](k: K[T], make: => V[T]) = cast[T](backing.getOrElseUpdate(k, make))
+
+  def mapValue[T](k: K[T], init: V[T], f: V[T] => V[T]): V[T] = {
+    val v = f(this get k getOrElse init)
+    update(k, v)
+    v
+  }
+
+  def toSeq = backing.toSeq
+  def keys = backing.keys
+  def values = backing.values
+  def isEmpty = backing.isEmpty
+
+  private[this] def cast[T](v: V[_]): V[T] = v.asInstanceOf[V[T]]
+  private[this] def cast[T](o: Option[V[_]]): Option[V[T]] = o map cast[T]
+
+  override def toString = backing.toString
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Settings.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Settings.scala
new file mode 100644
index 000000000..f4110acc8
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/Settings.scala
@@ -0,0 +1,966 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import Types._
+import sbt.util.Show
+import Util.{ nil, nilSeq }
+
+sealed trait Settings[ScopeType] {
+  def data: Map[ScopeType, AttributeMap]
+  def keys(scope: ScopeType): Set[AttributeKey[_]]
+  def scopes: Set[ScopeType]
+  def definingScope(scope: ScopeType, key: AttributeKey[_]): Option[ScopeType]
+  def allKeys[T](f: (ScopeType, AttributeKey[_]) => T): Seq[T]
+  def get[T](scope: ScopeType, key: AttributeKey[T]): Option[T]
+  def getDirect[T](scope: ScopeType, key: AttributeKey[T]): Option[T]
+  def set[T](scope: ScopeType, key: AttributeKey[T], value: T): Settings[ScopeType]
+}
+
+private final class Settings0[ScopeType](
+    val data: Map[ScopeType, AttributeMap],
+    val delegates: ScopeType => Seq[ScopeType]
+) extends Settings[ScopeType] {
+
+  def scopes: Set[ScopeType] = data.keySet
+  def keys(scope: ScopeType) = data(scope).keys.toSet
+
+  def allKeys[T](f: (ScopeType, AttributeKey[_]) => T): Seq[T] =
+    data.flatMap { case (scope, map) => map.keys.map(k => f(scope, k)) }.toSeq
+
+  def get[T](scope: ScopeType, key: AttributeKey[T]): Option[T] =
+    delegates(scope).flatMap(sc => getDirect(sc, key)).headOption
+
+  def definingScope(scope: ScopeType, key: AttributeKey[_]): Option[ScopeType] =
+    delegates(scope).find(sc => getDirect(sc, key).isDefined)
+
+  def getDirect[T](scope: ScopeType, key: AttributeKey[T]): Option[T] =
+    (data get scope).flatMap(_ get key)
+
+  def set[T](scope: ScopeType, key: AttributeKey[T], value: T): Settings[ScopeType] = {
+    val map = data getOrElse (scope, AttributeMap.empty)
+    val newData = data.updated(scope, map.put(key, value))
+    new Settings0(newData, delegates)
+  }
+}
+
+// delegates should contain the input Scope as the first entry
+// this trait is intended to be mixed into an object
+trait Init[ScopeType] {
+
+  /** The Show instance used when a detailed String needs to be generated.
+   *  It is typically used when no context is available.
+   */
+  def showFullKey: Show[ScopedKey[_]]
+
+  sealed case class ScopedKey[T](scope: ScopeType, key: AttributeKey[T])
+      extends KeyedInitialize[T] {
+    def scopedKey = this
+  }
+
+  type SettingSeq[T] = Seq[Setting[T]]
+  type ScopedMap = IMap[ScopedKey, SettingSeq]
+  type CompiledMap = Map[ScopedKey[_], Compiled[_]]
+  type MapScoped = ScopedKey ~> ScopedKey
+  type ValidatedRef[T] = Either[Undefined, ScopedKey[T]]
+  type ValidatedInit[T] = Either[Seq[Undefined], Initialize[T]]
+  type ValidateRef = ScopedKey ~> ValidatedRef
+  type ScopeLocal = ScopedKey[_] => Seq[Setting[_]]
+  type MapConstant = ScopedKey ~> Option
+
+  private[sbt] abstract class ValidateKeyRef {
+    def apply[T](key: ScopedKey[T], selfRefOk: Boolean): ValidatedRef[T]
+  }
+
+  /**
+   * The result of this initialization is the composition of applied transformations.
+   * This can be useful when dealing with dynamic Initialize values.
+   */
+  lazy val capturedTransformations: Initialize[Initialize ~> Initialize] =
+    new TransformCapture(idK[Initialize])
+
+  def setting[T](
+      key: ScopedKey[T],
+      init: Initialize[T],
+      pos: SourcePosition = NoPosition
+  ): Setting[T] = new Setting[T](key, init, pos)
+
+  def valueStrict[T](value: T): Initialize[T] = pure(() => value)
+  def value[T](value: => T): Initialize[T] = pure(value _)
+  def pure[T](value: () => T): Initialize[T] = new Value(value)
+  def optional[T, U](i: Initialize[T])(f: Option[T] => U): Initialize[U] = new Optional(Some(i), f)
+
+  def update[T](key: ScopedKey[T])(f: T => T): Setting[T] =
+    setting[T](key, map(key)(f), NoPosition)
+
+  def bind[S, T](in: Initialize[S])(f: S => Initialize[T]): Initialize[T] = new Bind(f, in)
+
+  def map[S, T](in: Initialize[S])(f: S => T): Initialize[T] =
+    new Apply[λ[L[x] => L[S]], T](f, in, AList.single[S])
+
+  def app[K[L[x]], T](inputs: K[Initialize])(f: K[Id] => T)(
+      implicit alist: AList[K]
+  ): Initialize[T] = new Apply[K, T](f, inputs, alist)
+
+  def uniform[S, T](inputs: Seq[Initialize[S]])(f: Seq[S] => T): Initialize[T] =
+    new Apply[λ[L[x] => List[L[S]]], T](f, inputs.toList, AList.seq[S])
+
+  /**
+   * The result of this initialization is the validated `key`.
+   * No dependency is introduced on `key`.  If `selfRefOk` is true, validation will not fail if the key is referenced by a definition of `key`.
+   * That is, key := f(validated(key).value) is allowed only if `selfRefOk == true`.
+   */
+  private[sbt] final def validated[T](
+      key: ScopedKey[T],
+      selfRefOk: Boolean
+  ): ValidationCapture[T] =
+    new ValidationCapture(key, selfRefOk)
+
+  /**
+   * Constructs a derived setting that will be automatically defined in every scope where one of its dependencies
+   * is explicitly defined and the where the scope matches `filter`.
+   * A setting initialized with dynamic dependencies is only allowed if `allowDynamic` is true.
+   * Only the static dependencies are tracked, however.  Dependencies on previous values do not introduce a derived setting either.
+   */
+  final def derive[T](
+      s: Setting[T],
+      allowDynamic: Boolean = false,
+      filter: ScopeType => Boolean = const(true),
+      trigger: AttributeKey[_] => Boolean = const(true),
+      default: Boolean = false
+  ): Setting[T] = {
+    deriveAllowed(s, allowDynamic) foreach sys.error
+    val d = new DerivedSetting[T](s.key, s.init, s.pos, filter, trigger)
+    if (default) d.default() else d
+  }
+
+  def deriveAllowed[T](s: Setting[T], allowDynamic: Boolean): Option[String] = s.init match {
+    case _: Bind[_, _] if !allowDynamic => Some("Cannot derive from dynamic dependencies.")
+    case _                              => None
+  }
+
+  // id is used for equality
+  private[sbt] final def defaultSetting[T](s: Setting[T]): Setting[T] = s.default()
+
+  private[sbt] def defaultSettings(ss: Seq[Setting[_]]): Seq[Setting[_]] =
+    ss.map(s => defaultSetting(s))
+
+  private[this] final val nextID = new java.util.concurrent.atomic.AtomicLong
+  private[this] final def nextDefaultID(): Long = nextID.incrementAndGet()
+
+  def empty(implicit delegates: ScopeType => Seq[ScopeType]): Settings[ScopeType] =
+    new Settings0(Map.empty, delegates)
+
+  def asTransform(s: Settings[ScopeType]): ScopedKey ~> Id = λ[ScopedKey ~> Id](k => getValue(s, k))
+
+  def getValue[T](s: Settings[ScopeType], k: ScopedKey[T]) =
+    s.get(k.scope, k.key) getOrElse (throw new InvalidReference(k))
+
+  def asFunction[T](s: Settings[ScopeType]): ScopedKey[T] => T = k => getValue(s, k)
+
+  def mapScope(f: ScopeType => ScopeType): MapScoped = new MapScoped {
+    def apply[T](k: ScopedKey[T]): ScopedKey[T] = k.copy(scope = f(k.scope))
+  }
+
+  private final class InvalidReference(val key: ScopedKey[_])
+      extends RuntimeException(
+        "Internal settings error: invalid reference to " + showFullKey.show(key)
+      )
+
+  private[this] def applyDefaults(ss: Seq[Setting[_]]): Seq[Setting[_]] = {
+    val result = new java.util.LinkedHashSet[Setting[_]]
+    val others = new java.util.ArrayList[Setting[_]]
+    ss.foreach {
+      case u: DefaultSetting[_] => result.add(u)
+      case r                    => others.add(r)
+    }
+    result.addAll(others)
+    import scala.collection.JavaConverters._
+    result.asScala.toVector
+  }
+
+  def compiled(init: Seq[Setting[_]], actual: Boolean = true)(
+      implicit delegates: ScopeType => Seq[ScopeType],
+      scopeLocal: ScopeLocal,
+      display: Show[ScopedKey[_]]
+  ): CompiledMap = {
+    val initDefaults = applyDefaults(init)
+    // inject derived settings into scopes where their dependencies are directly defined
+    // and prepend per-scope settings
+    val derived = deriveAndLocal(initDefaults, mkDelegates(delegates))
+    // group by Scope/Key, dropping dead initializations
+    val sMap: ScopedMap = grouped(derived)
+    // delegate references to undefined values according to 'delegates'
+    val dMap: ScopedMap =
+      if (actual) delegate(sMap)(delegates, display) else sMap
+    // merge Seq[Setting[_]] into Compiled
+    compile(dMap)
+  }
+
+  @deprecated("Use makeWithCompiledMap", "1.4.0")
+  def make(init: Seq[Setting[_]])(
+      implicit delegates: ScopeType => Seq[ScopeType],
+      scopeLocal: ScopeLocal,
+      display: Show[ScopedKey[_]]
+  ): Settings[ScopeType] = makeWithCompiledMap(init)._2
+
+  def makeWithCompiledMap(init: Seq[Setting[_]])(
+      implicit delegates: ScopeType => Seq[ScopeType],
+      scopeLocal: ScopeLocal,
+      display: Show[ScopedKey[_]]
+  ): (CompiledMap, Settings[ScopeType]) = {
+    val cMap = compiled(init)(delegates, scopeLocal, display)
+    // order the initializations.  cyclic references are detected here.
+    val ordered: Seq[Compiled[_]] = sort(cMap)
+    // evaluation: apply the initializations.
+    try {
+      (cMap, applyInits(ordered))
+    } catch {
+      case rru: RuntimeUndefined =>
+        throw Uninitialized(cMap.keys.toSeq, delegates, rru.undefined, true)
+    }
+  }
+
+  def sort(cMap: CompiledMap): Seq[Compiled[_]] =
+    Dag.topologicalSort(cMap.values)(_.dependencies.map(cMap))
+
+  def compile(sMap: ScopedMap): CompiledMap = sMap match {
+    case m: IMap.IMap0[ScopedKey, SettingSeq] @unchecked =>
+      Par(m.backing.toVector)
+        .map {
+          case (k, ss) =>
+            val deps = ss.flatMap(_.dependencies).toSet
+            (
+              k,
+              new Compiled(k.asInstanceOf[ScopedKey[Any]], deps, ss.asInstanceOf[SettingSeq[Any]])
+            )
+        }
+        .toVector
+        .toMap
+    case _ =>
+      sMap.toTypedSeq.map {
+        case sMap.TPair(k, ss) =>
+          val deps = ss.flatMap(_.dependencies)
+          (k, new Compiled(k, deps, ss))
+      }.toMap
+  }
+
+  def grouped(init: Seq[Setting[_]]): ScopedMap = {
+    val result = new java.util.HashMap[ScopedKey[_], Seq[Setting[_]]]
+    init.foreach { s =>
+      result.putIfAbsent(s.key, Vector(s)) match {
+        case null =>
+        case ss   => result.put(s.key, if (s.definitive) Vector(s) else ss :+ s)
+      }
+    }
+    IMap.fromJMap[ScopedKey, SettingSeq](
+      result.asInstanceOf[java.util.Map[ScopedKey[_], SettingSeq[_]]]
+    )
+  }
+
+  def add[T](m: ScopedMap, s: Setting[T]): ScopedMap =
+    m.mapValue[T](s.key, Vector.empty[Setting[T]], ss => append(ss, s))
+
+  def append[T](ss: Seq[Setting[T]], s: Setting[T]): Seq[Setting[T]] =
+    if (s.definitive) Vector(s) else ss :+ s
+
+  def addLocal(init: Seq[Setting[_]])(implicit scopeLocal: ScopeLocal): Seq[Setting[_]] =
+    Par(init).map(_.dependencies flatMap scopeLocal).toVector.flatten ++ init
+
+  def delegate(sMap: ScopedMap)(
+      implicit delegates: ScopeType => Seq[ScopeType],
+      display: Show[ScopedKey[_]]
+  ): ScopedMap = {
+    def refMap(ref: Setting[_], isFirst: Boolean) = new ValidateKeyRef {
+      def apply[T](k: ScopedKey[T], selfRefOk: Boolean) =
+        delegateForKey(sMap, k, delegates(k.scope), ref, selfRefOk || !isFirst)
+    }
+
+    import scala.collection.JavaConverters._
+    val undefined = new java.util.ArrayList[Undefined]
+    val result = new java.util.concurrent.ConcurrentHashMap[ScopedKey[_], Any]
+    val backing = sMap.toSeq
+    Par(backing).foreach {
+      case (key, settings) =>
+        val valid = new java.util.ArrayList[Setting[_]]
+        val undefs = new java.util.ArrayList[Undefined]
+        def validate(s: Setting[_], first: Boolean): Unit = {
+          s.validateKeyReferenced(refMap(s, first)) match {
+            case Right(v) => valid.add(v); ()
+            case Left(us) => us.foreach(u => undefs.add(u))
+          }
+        }
+        settings.headOption match {
+          case Some(s) =>
+            validate(s, true)
+            settings.tail.foreach(validate(_, false))
+          case _ =>
+        }
+        if (undefs.isEmpty) result.put(key, valid.asScala.toVector)
+        else undefined.addAll(undefs)
+    }
+
+    if (undefined.isEmpty)
+      IMap.fromJMap[ScopedKey, SettingSeq](
+        result.asInstanceOf[java.util.Map[ScopedKey[_], SettingSeq[_]]]
+      )
+    else
+      throw Uninitialized(sMap.keys.toSeq, delegates, undefined.asScala.toList, false)
+  }
+
+  private[this] def delegateForKey[T](
+      sMap: ScopedMap,
+      k: ScopedKey[T],
+      scopes: Seq[ScopeType],
+      ref: Setting[_],
+      selfRefOk: Boolean
+  ): Either[Undefined, ScopedKey[T]] = {
+    val skeys = scopes.iterator.map(x => ScopedKey(x, k.key))
+    val definedAt = skeys.find(sk => (selfRefOk || ref.key != sk) && (sMap contains sk))
+    definedAt.toRight(Undefined(ref, k))
+  }
+
+  private[this] def applyInits(ordered: Seq[Compiled[_]])(
+      implicit delegates: ScopeType => Seq[ScopeType]
+  ): Settings[ScopeType] = {
+    val x =
+      java.util.concurrent.Executors.newFixedThreadPool(Runtime.getRuntime.availableProcessors)
+    try {
+      val eval: EvaluateSettings[ScopeType] = new EvaluateSettings[ScopeType] {
+        override val init: Init.this.type = Init.this
+        def compiledSettings = ordered
+        def executor = x
+      }
+      eval.run
+    } finally {
+      x.shutdown()
+    }
+  }
+
+  def showUndefined(
+      u: Undefined,
+      validKeys: Seq[ScopedKey[_]],
+      delegates: ScopeType => Seq[ScopeType]
+  )(
+      implicit display: Show[ScopedKey[_]]
+  ): String = {
+    val guessed = guessIntendedScope(validKeys, delegates, u.referencedKey)
+    val derived = u.defining.isDerived
+    val refString = display.show(u.defining.key)
+    val sourceString = if (derived) "" else parenPosString(u.defining)
+    val guessedString =
+      if (derived) ""
+      else guessed.map(g => "\n     Did you mean " + display.show(g) + " ?").toList.mkString
+    val derivedString =
+      if (derived) ", which is a derived setting that needs this key to be defined in this scope."
+      else ""
+    display.show(u.referencedKey) + " from " + refString + sourceString + derivedString + guessedString
+  }
+
+  private[this] def parenPosString(s: Setting[_]): String =
+    s.positionString match { case None => ""; case Some(s) => " (" + s + ")" }
+
+  def guessIntendedScope(
+      validKeys: Seq[ScopedKey[_]],
+      delegates: ScopeType => Seq[ScopeType],
+      key: ScopedKey[_]
+  ): Option[ScopedKey[_]] = {
+    val distances = validKeys.flatMap { validKey =>
+      refinedDistance(delegates, validKey, key).map(dist => (dist, validKey))
+    }
+    distances.sortBy(_._1).map(_._2).headOption
+  }
+
+  def refinedDistance(
+      delegates: ScopeType => Seq[ScopeType],
+      a: ScopedKey[_],
+      b: ScopedKey[_]
+  ): Option[Int] =
+    if (a.key != b.key || a == b) None
+    else {
+      val dist = delegates(a.scope).indexOf(b.scope)
+      if (dist < 0) None else Some(dist)
+    }
+
+  final class Uninitialized(val undefined: Seq[Undefined], override val toString: String)
+      extends Exception(toString)
+
+  final class Undefined private[sbt] (val defining: Setting[_], val referencedKey: ScopedKey[_])
+
+  final class RuntimeUndefined(val undefined: Seq[Undefined])
+      extends RuntimeException("References to undefined settings at runtime.") {
+    override def getMessage =
+      super.getMessage + undefined.map { u =>
+        "\n" + u.referencedKey + " referenced from " + u.defining
+      }.mkString
+  }
+
+  def Undefined(defining: Setting[_], referencedKey: ScopedKey[_]): Undefined =
+    new Undefined(defining, referencedKey)
+
+  def Uninitialized(
+      validKeys: Seq[ScopedKey[_]],
+      delegates: ScopeType => Seq[ScopeType],
+      keys: Seq[Undefined],
+      runtime: Boolean
+  )(implicit display: Show[ScopedKey[_]]): Uninitialized = {
+    assert(keys.nonEmpty)
+    val suffix = if (keys.length > 1) "s" else ""
+    val prefix = if (runtime) "Runtime reference" else "Reference"
+    val keysString =
+      keys.map(u => showUndefined(u, validKeys, delegates)).mkString("\n\n  ", "\n\n  ", "")
+    new Uninitialized(
+      keys,
+      prefix + suffix + " to undefined setting" + suffix + ": " + keysString + "\n "
+    )
+  }
+
+  final class Compiled[T](
+      val key: ScopedKey[T],
+      val dependencies: Iterable[ScopedKey[_]],
+      val settings: Seq[Setting[T]]
+  ) {
+    override def toString = showFullKey.show(key)
+  }
+
+  final class Flattened(val key: ScopedKey[_], val dependencies: Iterable[ScopedKey[_]])
+
+  def flattenLocals(compiled: CompiledMap): Map[ScopedKey[_], Flattened] = {
+    val locals = compiled flatMap {
+      case (key, comp) =>
+        if (key.key.isLocal) Seq(comp)
+        else nilSeq[Compiled[_]]
+    }
+    val ordered = Dag.topologicalSort(locals)(
+      _.dependencies.flatMap(
+        dep =>
+          if (dep.key.isLocal) Seq[Compiled[_]](compiled(dep))
+          else nilSeq[Compiled[_]]
+      )
+    )
+    def flatten(
+        cmap: Map[ScopedKey[_], Flattened],
+        key: ScopedKey[_],
+        deps: Iterable[ScopedKey[_]]
+    ): Flattened =
+      new Flattened(
+        key,
+        deps.flatMap(
+          dep => if (dep.key.isLocal) cmap(dep).dependencies else Seq[ScopedKey[_]](dep).toIterable
+        )
+      )
+
+    val empty = Map.empty[ScopedKey[_], Flattened]
+
+    val flattenedLocals = ordered.foldLeft(empty) { (cmap, c) =>
+      cmap.updated(c.key, flatten(cmap, c.key, c.dependencies))
+    }
+
+    compiled flatMap {
+      case (key, comp) =>
+        if (key.key.isLocal) nilSeq[(ScopedKey[_], Flattened)]
+        else
+          Seq[(ScopedKey[_], Flattened)]((key, flatten(flattenedLocals, key, comp.dependencies)))
+    }
+  }
+
+  def definedAtString(settings: Seq[Setting[_]]): String = {
+    val posDefined = settings.flatMap(_.positionString.toList)
+    if (posDefined.nonEmpty) {
+      val header =
+        if (posDefined.size == settings.size) "defined at:"
+        else
+          "some of the defining occurrences:"
+      header + (posDefined.distinct mkString ("\n\t", "\n\t", "\n"))
+    } else ""
+  }
+
+  /**
+   *  The intersect method was calling Seq.contains which is very slow compared
+   *  to converting the Seq to a Set and calling contains on the Set. This
+   *  private trait abstracts out the two ways that Seq[ScopeType] was actually
+   *  used, `contains` and `exists`. In mkDelegates, we can create and cache
+   *  instances of Delegates so that we don't have to repeatedly convert the
+   *  same Seq to Set. On a 2020 16" macbook pro, creating the compiled map
+   *  for the sbt project is roughly 2 seconds faster after this change
+   *  (about 3.5 seconds before compared to about 1.5 seconds after)
+   *
+   */
+  private trait Delegates {
+    def contains(s: ScopeType): Boolean
+    def exists(f: ScopeType => Boolean): Boolean
+  }
+  private[this] def mkDelegates(delegates: ScopeType => Seq[ScopeType]): ScopeType => Delegates = {
+    val delegateMap = new java.util.concurrent.ConcurrentHashMap[ScopeType, Delegates]
+    s =>
+      delegateMap.get(s) match {
+        case null =>
+          val seq = delegates(s)
+          val set = seq.toSet
+          val d = new Delegates {
+            override def contains(s: ScopeType): Boolean = set.contains(s)
+            override def exists(f: ScopeType => Boolean): Boolean = seq.exists(f)
+          }
+          delegateMap.put(s, d)
+          d
+        case d => d
+      }
+  }
+
+  /**
+   * Intersects two scopes, returning the more specific one if they intersect, or None otherwise.
+   */
+  private[sbt] def intersect(s1: ScopeType, s2: ScopeType)(
+      implicit delegates: ScopeType => Seq[ScopeType]
+  ): Option[ScopeType] = intersectDelegates(s1, s2, mkDelegates(delegates))
+
+  /**
+   * Intersects two scopes, returning the more specific one if they intersect, or None otherwise.
+   */
+  private def intersectDelegates(
+      s1: ScopeType,
+      s2: ScopeType,
+      delegates: ScopeType => Delegates
+  ): Option[ScopeType] =
+    if (delegates(s1).contains(s2)) Some(s1) // s1 is more specific
+    else if (delegates(s2).contains(s1)) Some(s2) // s2 is more specific
+    else None
+
+  private[this] def deriveAndLocal(init: Seq[Setting[_]], delegates: ScopeType => Delegates)(
+      implicit scopeLocal: ScopeLocal
+  ): Seq[Setting[_]] = {
+    import collection.mutable
+
+    final class Derived(val setting: DerivedSetting[_]) {
+      val dependencies = setting.dependencies.map(_.key)
+      def triggeredBy = dependencies.filter(setting.trigger)
+      val inScopes = new mutable.HashSet[ScopeType]
+      val outputs = new mutable.ListBuffer[Setting[_]]
+    }
+
+    final class Deriveds(val key: AttributeKey[_], val settings: mutable.ListBuffer[Derived]) {
+      def dependencies = settings.flatMap(_.dependencies)
+      // This is mainly for use in the cyclic reference error message
+      override def toString =
+        s"Derived settings for ${key.label}, ${definedAtString(settings.map(_.setting).toSeq)}"
+    }
+
+    // separate `derived` settings from normal settings (`defs`)
+    val (derived, rawDefs) =
+      Util.separate[Setting[_], Derived, Setting[_]](init) {
+        case d: DerivedSetting[_] => Left(new Derived(d)); case s => Right(s)
+      }
+    val defs = addLocal(rawDefs)(scopeLocal)
+
+    // group derived settings by the key they define
+    val derivsByDef = new mutable.HashMap[AttributeKey[_], Deriveds]
+    for (s <- derived) {
+      val key = s.setting.key.key
+      derivsByDef.getOrElseUpdate(key, new Deriveds(key, new mutable.ListBuffer)).settings += s
+    }
+
+    // index derived settings by triggering key.  This maps a key to the list of settings potentially derived from it.
+    val derivedBy = new mutable.HashMap[AttributeKey[_], mutable.ListBuffer[Derived]]
+    for (s <- derived; d <- s.triggeredBy)
+      derivedBy.getOrElseUpdate(d, new mutable.ListBuffer) += s
+
+    // Map a DerivedSetting[_] to the `Derived` struct wrapping it. Used to ultimately replace a DerivedSetting with
+    // the `Setting`s that were actually derived from it: `Derived.outputs`
+    val derivedToStruct: Map[DerivedSetting[_], Derived] = (derived map { s =>
+      s.setting -> s
+    }).toMap
+
+    // set of defined scoped keys, used to ensure a derived setting is only added if all dependencies are present
+    val defined = new mutable.HashSet[ScopedKey[_]]
+    def addDefs(ss: Seq[Setting[_]]): Unit = { for (s <- ss) defined += s.key }
+    addDefs(defs)
+
+    // true iff the scoped key is in `defined`, taking delegation into account
+    def isDefined(key: AttributeKey[_], scope: ScopeType) =
+      delegates(scope).exists(s => defined.contains(ScopedKey(s, key)))
+
+    // true iff all dependencies of derived setting `d` have a value (potentially via delegation) in `scope`
+    def allDepsDefined(d: Derived, scope: ScopeType, local: Set[AttributeKey[_]]): Boolean =
+      d.dependencies.forall(dep => local(dep) || isDefined(dep, scope))
+
+    // Returns the list of injectable derived settings and their local settings for `sk`.
+    // The settings are to be injected under `outputScope` = whichever scope is more specific of:
+    //   * the dependency's (`sk`) scope
+    //   * the DerivedSetting's scope in which it has been declared, `definingScope`
+    // provided that these two scopes intersect.
+    //  A derived setting is injectable if:
+    //   1. it has not been previously injected into outputScope
+    //   2. it applies to outputScope (as determined by its `filter`)
+    //   3. all of its dependencies are defined for outputScope (allowing for delegation)
+    // This needs to handle local settings because a derived setting wouldn't be injected if it's local setting didn't exist yet.
+    val deriveFor = (sk: ScopedKey[_]) => {
+      val derivedForKey: List[Derived] = derivedBy.get(sk.key).toList.flatten
+      val scope = sk.scope
+      def localAndDerived(d: Derived): Seq[Setting[_]] = {
+        def definingScope = d.setting.key.scope
+        val outputScope = intersectDelegates(scope, definingScope, delegates)
+        outputScope collect {
+          case s if !d.inScopes.contains(s) && d.setting.filter(s) =>
+            val local = d.dependencies.flatMap(dep => scopeLocal(ScopedKey(s, dep)))
+            if (allDepsDefined(d, s, local.map(_.key.key).toSet)) {
+              d.inScopes.add(s)
+              val out = local :+ d.setting.setScope(s)
+              d.outputs ++= out
+              out
+            } else
+              nilSeq
+        } getOrElse nilSeq
+      }
+      derivedForKey.flatMap(localAndDerived)
+    }
+
+    val processed = new mutable.HashSet[ScopedKey[_]]
+
+    // derives settings, transitively so that a derived setting can trigger another
+    def process(rem: List[Setting[_]]): Unit = rem match {
+      case s :: ss =>
+        val sk = s.key
+        val ds = if (processed.add(sk)) deriveFor(sk) else nil
+        addDefs(ds)
+        process(ds ::: ss)
+      case Nil =>
+    }
+    process(defs.toList)
+
+    // Take all the original defs and DerivedSettings along with locals, replace each DerivedSetting with the actual
+    // settings that were derived.
+    val allDefs = addLocal(init)(scopeLocal)
+    allDefs.flatMap {
+      case d: DerivedSetting[_] => (derivedToStruct get d map (_.outputs)).toSeq.flatten
+      case s                    => s :: nil
+    }
+  }
+
+  /** Abstractly defines a value of type `T`.
+   *
+   * Specifically it defines a node in a task graph,
+   * where the `dependencies` represents dependent nodes,
+   * and `evaluate` represents the calculation based on the existing body of knowledge.
+   *
+   * @tparam T the type of the value this defines.
+   */
+  sealed trait Initialize[T] {
+    def dependencies: Seq[ScopedKey[_]]
+    def apply[S](g: T => S): Initialize[S]
+
+    private[sbt] def mapReferenced(g: MapScoped): Initialize[T]
+    private[sbt] def mapConstant(g: MapConstant): Initialize[T]
+
+    private[sbt] def validateReferenced(g: ValidateRef): ValidatedInit[T] =
+      validateKeyReferenced(new ValidateKeyRef {
+        def apply[B](key: ScopedKey[B], selfRefOk: Boolean) = g(key)
+      })
+
+    private[sbt] def validateKeyReferenced(g: ValidateKeyRef): ValidatedInit[T]
+
+    def evaluate(map: Settings[ScopeType]): T
+    def zip[S](o: Initialize[S]): Initialize[(T, S)] = zipTupled(o)(idFun)
+    def zipWith[S, U](o: Initialize[S])(f: (T, S) => U): Initialize[U] = zipTupled(o)(f.tupled)
+    private[this] def zipTupled[S, U](o: Initialize[S])(f: ((T, S)) => U): Initialize[U] =
+      new Apply[λ[L[x] => (L[T], L[S])], U](f, (this, o), AList.tuple2[T, S])
+
+    /** A fold on the static attributes of this and nested Initializes. */
+    private[sbt] def processAttributes[S](init: S)(f: (S, AttributeMap) => S): S
+  }
+
+  object Initialize {
+    implicit def joinInitialize[T](s: Seq[Initialize[T]]): JoinInitSeq[T] = new JoinInitSeq(s)
+
+    final class JoinInitSeq[T](s: Seq[Initialize[T]]) {
+      def joinWith[S](f: Seq[T] => S): Initialize[S] = uniform(s)(f)
+      def join: Initialize[Seq[T]] = uniform(s)(idFun)
+    }
+
+    def join[T](inits: Seq[Initialize[T]]): Initialize[Seq[T]] = uniform(inits)(idFun)
+
+    def joinAny[M[_]](inits: Seq[Initialize[M[T]] forSome { type T }]): Initialize[Seq[M[_]]] =
+      join(inits.asInstanceOf[Seq[Initialize[M[_]]]])
+  }
+
+  object SettingsDefinition {
+    implicit def unwrapSettingsDefinition(d: SettingsDefinition): Seq[Setting[_]] = d.settings
+    implicit def wrapSettingsDefinition(ss: Seq[Setting[_]]): SettingsDefinition =
+      new SettingList(ss)
+  }
+
+  sealed trait SettingsDefinition {
+    def settings: Seq[Setting[_]]
+  }
+
+  final class SettingList(val settings: Seq[Setting[_]]) extends SettingsDefinition
+
+  sealed class Setting[T] private[Init] (
+      val key: ScopedKey[T],
+      val init: Initialize[T],
+      val pos: SourcePosition
+  ) extends SettingsDefinition {
+    def settings = this :: Nil
+    def definitive: Boolean = !init.dependencies.contains(key)
+    def dependencies: Seq[ScopedKey[_]] =
+      remove(init.dependencies.asInstanceOf[Seq[ScopedKey[T]]], key)
+    def mapReferenced(g: MapScoped): Setting[T] = make(key, init mapReferenced g, pos)
+
+    def validateReferenced(g: ValidateRef): Either[Seq[Undefined], Setting[T]] =
+      (init validateReferenced g).right.map(newI => make(key, newI, pos))
+
+    private[sbt] def validateKeyReferenced(g: ValidateKeyRef): Either[Seq[Undefined], Setting[T]] =
+      (init validateKeyReferenced g).right.map(newI => make(key, newI, pos))
+
+    def mapKey(g: MapScoped): Setting[T] = make(g(key), init, pos)
+    def mapInit(f: (ScopedKey[T], T) => T): Setting[T] = make(key, init(t => f(key, t)), pos)
+    def mapConstant(g: MapConstant): Setting[T] = make(key, init mapConstant g, pos)
+    def withPos(pos: SourcePosition) = make(key, init, pos)
+
+    def positionString: Option[String] = pos match {
+      case pos: FilePosition => Some(pos.path + ":" + pos.startLine)
+      case NoPosition        => None
+    }
+
+    private[sbt] def mapInitialize(f: Initialize[T] => Initialize[T]): Setting[T] =
+      make(key, f(init), pos)
+
+    override def toString = "setting(" + key + ") at " + pos
+
+    protected[this] def make[B](
+        key: ScopedKey[B],
+        init: Initialize[B],
+        pos: SourcePosition
+    ): Setting[B] = new Setting[B](key, init, pos)
+
+    protected[sbt] def isDerived: Boolean = false
+    private[sbt] def setScope(s: ScopeType): Setting[T] =
+      make(key.copy(scope = s), init.mapReferenced(mapScope(const(s))), pos)
+
+    /** Turn this setting into a `DefaultSetting` if it's not already, otherwise returns `this` */
+    private[sbt] def default(id: => Long = nextDefaultID()): DefaultSetting[T] =
+      DefaultSetting(key, init, pos, id)
+  }
+
+  private[Init] sealed class DerivedSetting[T](
+      sk: ScopedKey[T],
+      i: Initialize[T],
+      p: SourcePosition,
+      val filter: ScopeType => Boolean,
+      val trigger: AttributeKey[_] => Boolean
+  ) extends Setting[T](sk, i, p) {
+
+    override def make[B](key: ScopedKey[B], init: Initialize[B], pos: SourcePosition): Setting[B] =
+      new DerivedSetting[B](key, init, pos, filter, trigger)
+
+    protected[sbt] override def isDerived: Boolean = true
+
+    override def default(_id: => Long): DefaultSetting[T] =
+      new DerivedSetting[T](sk, i, p, filter, trigger) with DefaultSetting[T] { val id = _id }
+
+    override def toString = "derived " + super.toString
+  }
+
+  // Only keep the first occurrence of this setting and move it to the front so that it has lower precedence than non-defaults.
+  //  This is intended for internal sbt use only, where alternatives like Plugin.globalSettings are not available.
+  private[Init] sealed trait DefaultSetting[T] extends Setting[T] {
+    val id: Long
+
+    override def make[B](key: ScopedKey[B], init: Initialize[B], pos: SourcePosition): Setting[B] =
+      super.make(key, init, pos) default id
+
+    override final def hashCode = id.hashCode
+
+    override final def equals(o: Any): Boolean = o match {
+      case d: DefaultSetting[_] => d.id == id; case _ => false
+    }
+
+    override def toString = s"default($id) " + super.toString
+    override def default(id: => Long) = this
+  }
+
+  object DefaultSetting {
+    def apply[T](sk: ScopedKey[T], i: Initialize[T], p: SourcePosition, _id: Long) =
+      new Setting[T](sk, i, p) with DefaultSetting[T] { val id = _id }
+  }
+
+  private[this] def handleUndefined[T](vr: ValidatedInit[T]): Initialize[T] = vr match {
+    case Left(undefs) => throw new RuntimeUndefined(undefs)
+    case Right(x)     => x
+  }
+
+  private[this] lazy val getValidated = λ[ValidatedInit ~> Initialize](handleUndefined(_))
+
+  // mainly for reducing generated class count
+  private[this] def validateKeyReferencedT(g: ValidateKeyRef) =
+    λ[Initialize ~> ValidatedInit](_ validateKeyReferenced g)
+
+  private[this] def mapReferencedT(g: MapScoped) = λ[Initialize ~> Initialize](_ mapReferenced g)
+  private[this] def mapConstantT(g: MapConstant) = λ[Initialize ~> Initialize](_ mapConstant g)
+  private[this] def evaluateT(g: Settings[ScopeType]) = λ[Initialize ~> Id](_ evaluate g)
+
+  private[this] def deps(ls: Seq[Initialize[_]]): Seq[ScopedKey[_]] = ls.flatMap(_.dependencies)
+
+  /** An `Initialize[T]` associated with a `ScopedKey[S]`.
+   * @tparam S the type of the associated `ScopedKey`
+   * @tparam T the type of the value this `Initialize` defines.
+   */
+  sealed trait Keyed[S, T] extends Initialize[T] {
+    def scopedKey: ScopedKey[S]
+    def transform: S => T
+
+    final def dependencies = scopedKey :: Nil
+    final def apply[Z](g: T => Z): Initialize[Z] = new GetValue(scopedKey, g compose transform)
+    final def evaluate(ss: Settings[ScopeType]): T = transform(getValue(ss, scopedKey))
+    final def mapReferenced(g: MapScoped): Initialize[T] = new GetValue(g(scopedKey), transform)
+
+    private[sbt] final def validateKeyReferenced(g: ValidateKeyRef): ValidatedInit[T] =
+      g(scopedKey, false) match {
+        case Left(un)  => Left(un :: Nil)
+        case Right(nk) => Right(new GetValue(nk, transform))
+      }
+
+    final def mapConstant(g: MapConstant): Initialize[T] = g(scopedKey) match {
+      case None        => this
+      case Some(const) => new Value(() => transform(const))
+    }
+
+    private[sbt] def processAttributes[B](init: B)(f: (B, AttributeMap) => B): B = init
+  }
+
+  private[this] final class GetValue[S, T](val scopedKey: ScopedKey[S], val transform: S => T)
+      extends Keyed[S, T]
+
+  /** A `Keyed` where the type of the value and the associated `ScopedKey` are the same.
+   * @tparam T the type of both the value this `Initialize` defines and the type of the associated `ScopedKey`.
+   */
+  trait KeyedInitialize[T] extends Keyed[T, T] {
+    final val transform = idFun[T]
+  }
+
+  private[sbt] final class TransformCapture(val f: Initialize ~> Initialize)
+      extends Initialize[Initialize ~> Initialize] {
+    def dependencies = Nil
+    def apply[Z](g2: (Initialize ~> Initialize) => Z): Initialize[Z] = map(this)(g2)
+    def evaluate(ss: Settings[ScopeType]): Initialize ~> Initialize = f
+    def mapReferenced(g: MapScoped) = new TransformCapture(mapReferencedT(g) ∙ f)
+    def mapConstant(g: MapConstant) = new TransformCapture(mapConstantT(g) ∙ f)
+
+    def validateKeyReferenced(g: ValidateKeyRef) =
+      Right(new TransformCapture(getValidated ∙ validateKeyReferencedT(g) ∙ f))
+
+    private[sbt] def processAttributes[S](init: S)(f: (S, AttributeMap) => S): S = init
+  }
+
+  private[sbt] final class ValidationCapture[T](val key: ScopedKey[T], val selfRefOk: Boolean)
+      extends Initialize[ScopedKey[T]] {
+    def dependencies = Nil
+    def apply[Z](g2: ScopedKey[T] => Z): Initialize[Z] = map(this)(g2)
+    def evaluate(ss: Settings[ScopeType]) = key
+    def mapReferenced(g: MapScoped) = new ValidationCapture(g(key), selfRefOk)
+    def mapConstant(g: MapConstant) = this
+
+    def validateKeyReferenced(g: ValidateKeyRef) = g(key, selfRefOk) match {
+      case Left(un) => Left(un :: Nil)
+      case Right(k) => Right(new ValidationCapture(k, selfRefOk))
+    }
+
+    private[sbt] def processAttributes[S](init: S)(f: (S, AttributeMap) => S): S = init
+  }
+
+  private[sbt] final class Bind[S, T](val f: S => Initialize[T], val in: Initialize[S])
+      extends Initialize[T] {
+    def dependencies = in.dependencies
+    def apply[Z](g: T => Z): Initialize[Z] = new Bind[S, Z](s => f(s)(g), in)
+    def evaluate(ss: Settings[ScopeType]): T = f(in evaluate ss) evaluate ss
+    def mapReferenced(g: MapScoped) = new Bind[S, T](s => f(s) mapReferenced g, in mapReferenced g)
+
+    def validateKeyReferenced(g: ValidateKeyRef) = (in validateKeyReferenced g).right.map {
+      validIn =>
+        new Bind[S, T](s => handleUndefined(f(s) validateKeyReferenced g), validIn)
+    }
+
+    def mapConstant(g: MapConstant) = new Bind[S, T](s => f(s) mapConstant g, in mapConstant g)
+
+    private[sbt] def processAttributes[B](init: B)(f: (B, AttributeMap) => B): B =
+      in.processAttributes(init)(f)
+  }
+
+  private[sbt] final class Optional[S, T](val a: Option[Initialize[S]], val f: Option[S] => T)
+      extends Initialize[T] {
+    def dependencies = deps(a.toList)
+    def apply[Z](g: T => Z): Initialize[Z] = new Optional[S, Z](a, g compose f)
+    def mapReferenced(g: MapScoped) = new Optional(a map mapReferencedT(g).fn, f)
+
+    def validateKeyReferenced(g: ValidateKeyRef) = a match {
+      case None    => Right(this)
+      case Some(i) => Right(new Optional(i.validateKeyReferenced(g).right.toOption, f))
+    }
+
+    def mapConstant(g: MapConstant): Initialize[T] = new Optional(a map mapConstantT(g).fn, f)
+    def evaluate(ss: Settings[ScopeType]): T = f(a.flatMap(i => trapBadRef(evaluateT(ss)(i))))
+
+    // proper solution is for evaluate to be deprecated or for external use only and a new internal method returning Either be used
+    private[this] def trapBadRef[A](run: => A): Option[A] =
+      try Some(run)
+      catch { case _: InvalidReference => None }
+
+    private[sbt] def processAttributes[B](init: B)(f: (B, AttributeMap) => B): B = a match {
+      case None    => init
+      case Some(i) => i.processAttributes(init)(f)
+    }
+  }
+
+  private[sbt] final class Value[T](val value: () => T) extends Initialize[T] {
+    def dependencies = Nil
+    def mapReferenced(g: MapScoped) = this
+    def validateKeyReferenced(g: ValidateKeyRef) = Right(this)
+    def apply[S](g: T => S) = new Value[S](() => g(value()))
+    def mapConstant(g: MapConstant) = this
+    def evaluate(map: Settings[ScopeType]): T = value()
+    private[sbt] def processAttributes[S](init: S)(f: (S, AttributeMap) => S): S = init
+  }
+
+  private[sbt] final object StaticScopes extends Initialize[Set[ScopeType]] {
+    def dependencies = Nil
+    def mapReferenced(g: MapScoped) = this
+    def validateKeyReferenced(g: ValidateKeyRef) = Right(this)
+    def apply[S](g: Set[ScopeType] => S) = map(this)(g)
+    def mapConstant(g: MapConstant) = this
+    def evaluate(map: Settings[ScopeType]) = map.scopes
+    private[sbt] def processAttributes[S](init: S)(f: (S, AttributeMap) => S): S = init
+  }
+
+  private[sbt] final class Apply[K[L[x]], T](
+      val f: K[Id] => T,
+      val inputs: K[Initialize],
+      val alist: AList[K]
+  ) extends Initialize[T] {
+    def dependencies = deps(alist.toList(inputs))
+    def mapReferenced(g: MapScoped) = mapInputs(mapReferencedT(g))
+    def apply[S](g: T => S) = new Apply(g compose f, inputs, alist)
+    def mapConstant(g: MapConstant) = mapInputs(mapConstantT(g))
+
+    def mapInputs(g: Initialize ~> Initialize): Initialize[T] =
+      new Apply(f, alist.transform(inputs, g), alist)
+
+    def evaluate(ss: Settings[ScopeType]) = f(alist.transform(inputs, evaluateT(ss)))
+
+    def validateKeyReferenced(g: ValidateKeyRef) = {
+      val tx = alist.transform(inputs, validateKeyReferencedT(g))
+      val undefs = alist.toList(tx).flatMap(_.left.toSeq.flatten)
+      val get = λ[ValidatedInit ~> Initialize](_.right.get)
+      if (undefs.isEmpty) Right(new Apply(f, alist.transform(tx, get), alist)) else Left(undefs)
+    }
+
+    private[sbt] def processAttributes[S](init: S)(f: (S, AttributeMap) => S): S =
+      alist.toList(inputs).foldLeft(init) { (v, i) =>
+        i.processAttributes(v)(f)
+      }
+  }
+  private def remove[T](s: Seq[T], v: T) = s filterNot (_ == v)
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Signal.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Signal.scala
new file mode 100644
index 000000000..b0e862410
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/Signal.scala
@@ -0,0 +1,97 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sun.misc.{ Signal, SignalHandler }
+
+object Signals {
+  val CONT = "CONT"
+  val INT = "INT"
+
+  def withHandler[T](handler: () => Unit, signal: String = INT)(action: () => T): T = {
+    val result =
+      try {
+        val signals = new Signals0
+        signals.withHandler(signal, handler, action)
+      } catch { case _: LinkageError => Right(action()): Either[Throwable, T] }
+
+    result match {
+      case Left(e)  => throw e
+      case Right(v) => v
+    }
+  }
+
+  /** Helper interface so we can expose internals of signal-isms to others. */
+  sealed trait Registration {
+    def remove(): Unit
+  }
+
+  /**
+   * Register a signal handler that can be removed later.
+   * NOTE: Does not stack with other signal handlers!!!!
+   */
+  def register(handler: () => Unit, signal: String = INT): Registration =
+    // TODO - Maybe we can just ignore things if not is-supported.
+    if (supported(signal)) {
+      val intSignal = new Signal(signal)
+      val newHandler = new SignalHandler {
+        def handle(sig: Signal): Unit = { handler() }
+      }
+      val oldHandler = Signal.handle(intSignal, newHandler)
+      new UnregisterNewHandler(intSignal, oldHandler)
+    } else {
+      // TODO - Maybe we should just throw an exception if we don't support signals...
+      NullUnregisterNewHandler
+    }
+
+  def supported(signal: String): Boolean =
+    try {
+      val signals = new Signals0
+      signals.supported(signal)
+    } catch { case _: LinkageError => false }
+}
+
+private class UnregisterNewHandler(intSignal: Signal, oldHandler: SignalHandler)
+    extends Signals.Registration {
+  override def remove(): Unit = {
+    Signal.handle(intSignal, oldHandler)
+    ()
+  }
+}
+private object NullUnregisterNewHandler extends Signals.Registration {
+  override def remove(): Unit = ()
+}
+
+// Must only be referenced using a
+//   try { } catch { case _: LinkageError => ... }
+// block to
+private final class Signals0 {
+  def supported(signal: String): Boolean = {
+    import sun.misc.Signal
+    try {
+      new Signal(signal); true
+    } catch { case _: IllegalArgumentException => false }
+  }
+
+  // returns a LinkageError in `action` as Left(t) in order to avoid it being
+  // incorrectly swallowed as missing Signal/SignalHandler
+  def withHandler[T](signal: String, handler: () => Unit, action: () => T): Either[Throwable, T] = {
+    import sun.misc.{ Signal, SignalHandler }
+    val intSignal = new Signal(signal)
+    val newHandler = new SignalHandler {
+      def handle(sig: Signal): Unit = { handler() }
+    }
+
+    val oldHandler = Signal.handle(intSignal, newHandler)
+
+    try Right(action())
+    catch { case e: LinkageError => Left(e) } finally {
+      Signal.handle(intSignal, oldHandler); ()
+    }
+  }
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/TypeFunctions.scala b/internal/util-collection/src/main/scala/sbt/internal/util/TypeFunctions.scala
new file mode 100644
index 000000000..5d11c57fb
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/TypeFunctions.scala
@@ -0,0 +1,70 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+trait TypeFunctions {
+  import TypeFunctions._
+  type Id[X] = X
+  type NothingK[X] = Nothing
+  sealed trait Const[A] { type Apply[B] = A }
+  sealed trait ConstK[A] { type l[L[x]] = A }
+  sealed trait Compose[A[_], B[_]] { type Apply[T] = A[B[T]] }
+  sealed trait ∙[A[_], B[_]] { type l[T] = A[B[T]] }
+  private type AnyLeft[T] = Left[T, Nothing]
+  private type AnyRight[T] = Right[Nothing, T]
+
+  final val left: Id ~> Left[*, Nothing] =
+    λ[Id ~> AnyLeft](Left(_)).setToString("TypeFunctions.left")
+  final val right: Id ~> Right[Nothing, *] =
+    λ[Id ~> AnyRight](Right(_)).setToString("TypeFunctions.right")
+  final val some: Id ~> Some[*] = λ[Id ~> Some](Some(_)).setToString("TypeFunctions.some")
+  final def idFun[T]: T => T = ((t: T) => t).setToString("TypeFunctions.id")
+  final def const[A, B](b: B): A => B = ((_: A) => b).setToString(s"TypeFunctions.const($b)")
+  final def idK[M[_]]: M ~> M = λ[M ~> M](m => m).setToString("TypeFunctions.idK")
+
+  def nestCon[M[_], N[_], G[_]](f: M ~> N): (M ∙ G)#l ~> (N ∙ G)#l =
+    f.asInstanceOf[(M ∙ G)#l ~> (N ∙ G)#l] // implemented with a cast to avoid extra object+method call.
+  // castless version:
+  // λ[(M ∙ G)#l ~> (N ∙ G)#l](f(_))
+
+  type Endo[T] = T => T
+  type ~>|[A[_], B[_]] = A ~> Compose[Option, B]#Apply
+}
+
+object TypeFunctions extends TypeFunctions {
+  private implicit class Ops[T[_], R[_]](val underlying: T ~> R) extends AnyVal {
+    def setToString(string: String): T ~> R = new (T ~> R) {
+      override def apply[U](a: T[U]): R[U] = underlying(a)
+      override def toString: String = string
+      override def equals(o: Any): Boolean = underlying.equals(o)
+      override def hashCode: Int = underlying.hashCode
+    }
+  }
+  private implicit class FunctionOps[A, B](val f: A => B) extends AnyVal {
+    def setToString(string: String): A => B = new (A => B) {
+      override def apply(a: A): B = f(a)
+      override def toString: String = string
+      override def equals(o: Any): Boolean = f.equals(o)
+      override def hashCode: Int = f.hashCode
+    }
+  }
+}
+
+trait ~>[-A[_], +B[_]] { outer =>
+  def apply[T](a: A[T]): B[T]
+  // directly on ~> because of type inference limitations
+  final def ∙[C[_]](g: C ~> A): C ~> B = λ[C ~> B](c => outer.apply(g(c)))
+  final def ∙[C, D](g: C => D)(implicit ev: D <:< A[D]): C => B[D] = i => apply(ev(g(i)))
+  final def fn[T]: A[T] => B[T] = (t: A[T]) => apply[T](t)
+}
+
+object ~> {
+  import TypeFunctions._
+  val Id: Id ~> Id = idK[Id]
+  implicit def tcIdEquals: Id ~> Id = Id
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Types.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Types.scala
new file mode 100644
index 000000000..e07b6bd9f
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/Types.scala
@@ -0,0 +1,16 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+object Types extends Types
+
+trait Types extends TypeFunctions {
+  val :^: = KCons
+  type :+:[H, T <: HList] = HCons[H, T]
+  val :+: = HCons
+}
diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Util.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Util.scala
new file mode 100644
index 000000000..0155306c8
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/internal/util/Util.scala
@@ -0,0 +1,79 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.util.Locale
+
+import scala.reflect.macros.blackbox
+import scala.language.experimental.macros
+
+object Util {
+  def makeList[T](size: Int, value: T): List[T] = List.fill(size)(value)
+
+  def separateE[A, B](ps: Seq[Either[A, B]]): (Seq[A], Seq[B]) =
+    separate(ps)(Types.idFun)
+
+  def separate[T, A, B](ps: Seq[T])(f: T => Either[A, B]): (Seq[A], Seq[B]) = {
+    val (a, b) = ps.foldLeft((Nil: Seq[A], Nil: Seq[B]))((xs, y) => prependEither(xs, f(y)))
+    (a.reverse, b.reverse)
+  }
+
+  def prependEither[A, B](acc: (Seq[A], Seq[B]), next: Either[A, B]): (Seq[A], Seq[B]) =
+    next match {
+      case Left(l)  => (l +: acc._1, acc._2)
+      case Right(r) => (acc._1, r +: acc._2)
+    }
+
+  def pairID[A, B] = (a: A, b: B) => (a, b)
+
+  private[this] lazy val Hyphen = """-(\p{javaLowerCase})""".r
+
+  def hasHyphen(s: String): Boolean = s.indexOf('-') >= 0
+
+  def hyphenToCamel(s: String): String =
+    if (hasHyphen(s)) Hyphen.replaceAllIn(s, _.group(1).toUpperCase(Locale.ENGLISH)) else s
+
+  private[this] lazy val Camel = """(\p{javaLowerCase})(\p{javaUpperCase})""".r
+
+  def camelToHyphen(s: String): String =
+    Camel.replaceAllIn(s, m => m.group(1) + "-" + m.group(2).toLowerCase(Locale.ENGLISH))
+
+  def quoteIfKeyword(s: String): String = if (ScalaKeywords.values(s)) '`' + s + '`' else s
+
+  def ignoreResult[T](f: => T): Unit = macro Macro.ignore
+
+  lazy val isMac: Boolean =
+    System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("mac")
+
+  lazy val isWindows: Boolean =
+    System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("windows")
+
+  lazy val isCygwin: Boolean = {
+    val os = Option(System.getenv("OSTYPE"))
+    os match {
+      case Some(x) => x.toLowerCase(Locale.ENGLISH).contains("cygwin")
+      case _       => false
+    }
+  }
+
+  lazy val isNonCygwinWindows: Boolean = isWindows && !isCygwin
+  lazy val isCygwinWindows: Boolean = isWindows && isCygwin
+
+  lazy val isEmacs: Boolean = Option(System.getenv("INSIDE_EMACS")).isDefined
+
+  def nil[A]: List[A] = List.empty[A]
+  def nilSeq[A]: Seq[A] = Seq.empty[A]
+  def none[A]: Option[A] = (None: Option[A])
+
+  implicit class AnyOps[A](private val value: A) extends AnyVal {
+    def some: Option[A] = (Some(value): Option[A])
+  }
+  class Macro(val c: blackbox.Context) {
+    def ignore(f: c.Tree): c.Expr[Unit] = c.universe.reify({ c.Expr[Any](f).splice; () })
+  }
+}
diff --git a/internal/util-collection/src/main/scala/sbt/util/OptJsonWriter.scala b/internal/util-collection/src/main/scala/sbt/util/OptJsonWriter.scala
new file mode 100644
index 000000000..13883bbff
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/util/OptJsonWriter.scala
@@ -0,0 +1,29 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import sjsonnew.JsonWriter
+
+sealed trait OptJsonWriter[A]
+final case class NoJsonWriter[A]() extends OptJsonWriter[A]
+final case class SomeJsonWriter[A](value: JsonWriter[A]) extends OptJsonWriter[A]
+
+trait OptJsonWriter0 {
+  implicit def fallback[A]: NoJsonWriter[A] = NoJsonWriter()
+}
+object OptJsonWriter extends OptJsonWriter0 {
+  implicit def lift[A](implicit z: JsonWriter[A]): SomeJsonWriter[A] = SomeJsonWriter(z)
+
+  trait StrictMode0 {
+    implicit def conflictingFallback1[A]: NoJsonWriter[A] = NoJsonWriter()
+    implicit def conflictingFallback2[A]: NoJsonWriter[A] = NoJsonWriter()
+  }
+  object StrictMode extends StrictMode0 {
+    implicit def lift[A](implicit z: JsonWriter[A]): SomeJsonWriter[A] = SomeJsonWriter(z)
+  }
+}
diff --git a/internal/util-collection/src/main/scala/sbt/util/Show.scala b/internal/util-collection/src/main/scala/sbt/util/Show.scala
new file mode 100644
index 000000000..fa2c27008
--- /dev/null
+++ b/internal/util-collection/src/main/scala/sbt/util/Show.scala
@@ -0,0 +1,17 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+trait Show[A] {
+  def show(a: A): String
+}
+object Show {
+  def apply[A](f: A => String): Show[A] = a => f(a)
+
+  def fromToString[A]: Show[A] = _.toString
+}
diff --git a/internal/util-collection/src/test/scala/DagSpecification.scala b/internal/util-collection/src/test/scala/DagSpecification.scala
new file mode 100644
index 000000000..f5da77dee
--- /dev/null
+++ b/internal/util-collection/src/test/scala/DagSpecification.scala
@@ -0,0 +1,59 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalacheck._
+import Prop._
+
+import scala.collection.mutable.HashSet
+
+object DagSpecification extends Properties("Dag") {
+  property("No repeated nodes") = forAll { (dag: TestDag) =>
+    isSet(dag.topologicalSort)
+  }
+  property("Sort contains node") = forAll { (dag: TestDag) =>
+    dag.topologicalSort.contains(dag)
+  }
+  property("Dependencies precede node") = forAll { (dag: TestDag) =>
+    dependenciesPrecedeNodes(dag.topologicalSort)
+  }
+
+  implicit lazy val arbTestDag: Arbitrary[TestDag] = Arbitrary(Gen.sized(dagGen))
+  private def dagGen(nodeCount: Int): Gen[TestDag] = {
+    val nodes = new HashSet[TestDag]
+    def nonterminalGen(p: Gen.Parameters): Gen[TestDag] = {
+      val seed = rng.Seed.random()
+      for {
+        i <- 0 until nodeCount
+        nextDeps <- Gen.someOf(nodes).apply(p, seed)
+      } nodes += new TestDag(i, nextDeps)
+      for (nextDeps <- Gen.someOf(nodes)) yield new TestDag(nodeCount, nextDeps)
+    }
+    Gen.parameterized(nonterminalGen)
+  }
+
+  private def isSet[T](c: Seq[T]) = Set(c: _*).size == c.size
+  private def dependenciesPrecedeNodes(sort: List[TestDag]) = {
+    val seen = new HashSet[TestDag]
+    def iterate(remaining: List[TestDag]): Boolean = {
+      remaining match {
+        case Nil => true
+        case node :: tail =>
+          if (node.dependencies.forall(seen.contains) && !seen.contains(node)) {
+            seen += node
+            iterate(tail)
+          } else
+            false
+      }
+    }
+    iterate(sort)
+  }
+}
+class TestDag(id: Int, val dependencies: Iterable[TestDag]) extends Dag[TestDag] {
+  override def toString = id + "->" + dependencies.mkString("[", ",", "]")
+}
diff --git a/internal/util-collection/src/test/scala/HListFormatSpec.scala b/internal/util-collection/src/test/scala/HListFormatSpec.scala
new file mode 100644
index 000000000..dbdd5ce88
--- /dev/null
+++ b/internal/util-collection/src/test/scala/HListFormatSpec.scala
@@ -0,0 +1,35 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package util
+
+import sjsonnew.shaded.scalajson.ast.unsafe._
+import sjsonnew._, BasicJsonProtocol._, support.scalajson.unsafe._
+import HListFormats._
+
+class HListFormatSpec extends UnitSpec {
+  val quux = 23 :+: "quux" :+: true :+: HNil
+
+  it should "round trip quux" in assertRoundTrip(quux)
+  it should "round trip hnil" in assertRoundTrip(HNil)
+
+  it should "have a flat structure for quux" in assertJsonString(quux, """[23,"quux",true]""")
+  it should "have a flat structure for hnil" in assertJsonString(HNil, "[]")
+
+  def assertRoundTrip[A: JsonWriter: JsonReader](x: A) = {
+    val jsonString: String = toJsonString(x)
+    val jValue: JValue = Parser.parseUnsafe(jsonString)
+    val y: A = Converter.fromJson[A](jValue).get
+    assert(x === y)
+  }
+
+  def assertJsonString[A: JsonWriter](x: A, s: String) = assert(toJsonString(x) === s)
+
+  def toJsonString[A: JsonWriter](x: A): String = CompactPrinter(Converter.toJson(x).get)
+}
diff --git a/internal/util-collection/src/test/scala/KeyTest.scala b/internal/util-collection/src/test/scala/KeyTest.scala
new file mode 100644
index 000000000..b2ebb4d11
--- /dev/null
+++ b/internal/util-collection/src/test/scala/KeyTest.scala
@@ -0,0 +1,39 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalacheck._
+import Prop._
+
+object KeyTest extends Properties("AttributeKey") {
+  property("equality") = {
+    compare(AttributeKey[Int]("test"), AttributeKey[Int]("test"), true) &&
+    compare(AttributeKey[Int]("test"), AttributeKey[Int]("test", "description"), true) &&
+    compare(AttributeKey[Int]("test", "a"), AttributeKey[Int]("test", "b"), true) &&
+    compare(AttributeKey[Int]("test"), AttributeKey[Int]("tests"), false) &&
+    compare(AttributeKey[Int]("test"), AttributeKey[Double]("test"), false) &&
+    compare(AttributeKey[java.lang.Integer]("test"), AttributeKey[Int]("test"), false) &&
+    compare(AttributeKey[Map[Int, String]]("test"), AttributeKey[Map[Int, String]]("test"), true) &&
+    compare(AttributeKey[Map[Int, String]]("test"), AttributeKey[Map[Int, _]]("test"), false)
+  }
+
+  def compare(a: AttributeKey[_], b: AttributeKey[_], same: Boolean) =
+    ("a.label: " + a.label) |:
+      ("a.manifest: " + a.manifest) |:
+      ("b.label: " + b.label) |:
+      ("b.manifest: " + b.manifest) |:
+      ("expected equal? " + same) |:
+      compare0(a, b, same)
+
+  def compare0(a: AttributeKey[_], b: AttributeKey[_], same: Boolean) =
+    if (same) {
+      ("equality" |: (a == b)) &&
+      ("hash" |: (a.hashCode == b.hashCode))
+    } else
+      ("equality" |: (a != b))
+}
diff --git a/internal/util-collection/src/test/scala/PMapTest.scala b/internal/util-collection/src/test/scala/PMapTest.scala
new file mode 100644
index 000000000..c21cfd4b0
--- /dev/null
+++ b/internal/util-collection/src/test/scala/PMapTest.scala
@@ -0,0 +1,22 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import Types._
+
+// compilation test
+object PMapTest {
+  val mp = new DelegatingPMap[Some, Id](new collection.mutable.HashMap)
+  mp(Some("asdf")) = "a"
+  mp(Some(3)) = 9
+  val x = Some(3) :^: Some("asdf") :^: KNil
+  val y = x.transform[Id](mp)
+  assert(y.head == 9)
+  assert(y.tail.head == "a")
+  assert(y.tail.tail == KNil)
+}
diff --git a/internal/util-collection/src/test/scala/SettingsExample.scala b/internal/util-collection/src/test/scala/SettingsExample.scala
new file mode 100644
index 000000000..5399f79c1
--- /dev/null
+++ b/internal/util-collection/src/test/scala/SettingsExample.scala
@@ -0,0 +1,97 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util.Show
+
+/** Define our settings system */
+// A basic scope indexed by an integer.
+final case class Scope(nestIndex: Int, idAtIndex: Int = 0)
+
+// Extend the Init trait.
+//  (It is done this way because the Scope type parameter is used everywhere in Init.
+//  Lots of type constructors would become binary, which as you may know requires lots of type lambdas
+//  when you want a type function with only one parameter.
+//  That would be a general pain.)
+case class SettingsExample() extends Init[Scope] {
+  // Provides a way of showing a Scope+AttributeKey[_]
+  val showFullKey: Show[ScopedKey[_]] = Show[ScopedKey[_]]((key: ScopedKey[_]) => {
+    s"${key.scope.nestIndex}(${key.scope.idAtIndex})/${key.key.label}"
+  })
+
+  // A sample delegation function that delegates to a Scope with a lower index.
+  val delegates: Scope => Seq[Scope] = {
+    case s @ Scope(index, proj) =>
+      s +: (if (index <= 0) Nil
+            else {
+              (if (proj > 0) List(Scope(index)) else Nil) ++: delegates(Scope(index - 1))
+            })
+  }
+
+  // Not using this feature in this example.
+  val scopeLocal: ScopeLocal = _ => Nil
+
+  // These three functions + a scope (here, Scope) are sufficient for defining our settings system.
+}
+
+/** Usage Example **/
+case class SettingsUsage(val settingsExample: SettingsExample) {
+  import settingsExample._
+
+  // Define some keys
+  val a = AttributeKey[Int]("a")
+  val b = AttributeKey[Int]("b")
+
+  // Scope these keys
+  val a3 = ScopedKey(Scope(3), a)
+  val a4 = ScopedKey(Scope(4), a)
+  val a5 = ScopedKey(Scope(5), a)
+
+  val b4 = ScopedKey(Scope(4), b)
+
+  // Define some settings
+  val mySettings: Seq[Setting[_]] = Seq(
+    setting(a3, value(3)),
+    setting(b4, map(a4)(_ * 3)),
+    update(a5)(_ + 1)
+  )
+
+  // "compiles" and applies the settings.
+  //  This can be split into multiple steps to access intermediate results if desired.
+  //  The 'inspect' command operates on the output of 'compile', for example.
+  val applied: Settings[Scope] =
+    makeWithCompiledMap(mySettings)(delegates, scopeLocal, showFullKey)._2
+
+  // Show results.
+  /*	for(i <- 0 to 5; k <- Seq(a, b)) {
+		println( k.label + i + " = " + applied.get( Scope(i), k) )
+	}*/
+
+  /**
+ * Output:
+ * For the None results, we never defined the value and there was no value to delegate to.
+ * For a3, we explicitly defined it to be 3.
+ * a4 wasn't defined, so it delegates to a3 according to our delegates function.
+ * b4 gets the value for a4 (which delegates to a3, so it is 3) and multiplies by 3
+ * a5 is defined as the previous value of a5 + 1 and
+ *   since no previous value of a5 was defined, it delegates to a4, resulting in 3+1=4.
+ * b5 isn't defined explicitly, so it delegates to b4 and is therefore equal to 9 as well
+ * a0 = None
+ * b0 = None
+ * a1 = None
+ * b1 = None
+ * a2 = None
+ * b2 = None
+ * a3 = Some(3)
+ * b3 = None
+ * a4 = Some(3)
+ * b4 = Some(9)
+ * a5 = Some(4)
+ * b5 = Some(9)
+ */
+}
diff --git a/internal/util-collection/src/test/scala/SettingsTest.scala b/internal/util-collection/src/test/scala/SettingsTest.scala
new file mode 100644
index 000000000..bbfa2a848
--- /dev/null
+++ b/internal/util-collection/src/test/scala/SettingsTest.scala
@@ -0,0 +1,219 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalacheck._, Prop._
+
+object SettingsTest extends Properties("settings") {
+  val settingsExample: SettingsExample = SettingsExample()
+  import settingsExample._
+  val settingsUsage = SettingsUsage(settingsExample)
+  import settingsUsage._
+
+  import scala.reflect.Manifest
+
+  final val ChainMax = 5000
+  lazy val chainLengthGen = Gen.choose(1, ChainMax)
+
+  property("Basic settings test") = secure(all(tests: _*))
+
+  property("Basic chain") = forAll(chainLengthGen) { (i: Int) =>
+    val abs = math.abs(i)
+    singleIntTest(chain(abs, value(0)), abs)
+  }
+  property("Basic bind chain") = forAll(chainLengthGen) { (i: Int) =>
+    val abs = math.abs(i)
+    singleIntTest(chainBind(value(abs)), 0)
+  }
+
+  property("Allows references to completed settings") = forAllNoShrink(30) { allowedReference }
+  final def allowedReference(intermediate: Int): Prop = {
+    val top = value(intermediate)
+    def iterate(init: Initialize[Int]): Initialize[Int] =
+      bind(init) { t =>
+        if (t <= 0)
+          top
+        else
+          iterate(value(t - 1))
+      }
+    evaluate(setting(chk, iterate(top)) :: Nil); true
+  }
+
+  property("Derived setting chain depending on (prev derived, normal setting)") =
+    forAllNoShrink(Gen.choose(1, 100).label("numSettings")) { derivedSettings }
+  final def derivedSettings(nr: Int): Prop = {
+    val genScopedKeys = {
+      // We wan
+      // t to generate lists of keys that DO NOT inclue the "ch" key we use to check things.
+      val attrKeys = mkAttrKeys[Int](nr).filter(_.forall(_.label != "ch"))
+      attrKeys map (_ map (ak => ScopedKey(Scope(0), ak)))
+    }.label("scopedKeys").filter(_.nonEmpty)
+    forAll(genScopedKeys) { scopedKeys =>
+      try {
+        // Note; It's evil to grab last IF you haven't verified the set can't be empty.
+        val last = scopedKeys.last
+        val derivedSettings: Seq[Setting[Int]] = (
+          for {
+            List(scoped0, scoped1) <- chk :: scopedKeys sliding 2
+            nextInit = if (scoped0 == chk) chk
+            else
+              (scoped0 zipWith chk) { (p, _) =>
+                p + 1
+              }
+          } yield derive(setting(scoped1, nextInit))
+        ).toSeq
+
+        {
+          // Note: This causes a cycle refernec error, quite frequently.
+          checkKey(last, Some(nr - 1), evaluate(setting(chk, value(0)) +: derivedSettings)) :| "Not derived?"
+        } && {
+          checkKey(last, None, evaluate(derivedSettings)) :| "Should not be derived"
+        }
+      } catch {
+        case t: Throwable =>
+          // TODO - For debugging only.
+          t.printStackTrace(System.err)
+          throw t
+      }
+    }
+  }
+
+  private def mkAttrKeys[T](nr: Int)(implicit mf: Manifest[T]): Gen[List[AttributeKey[T]]] = {
+    import Gen._
+    val nonEmptyAlphaStr =
+      nonEmptyListOf(alphaChar)
+        .map({ xs: List[Char] =>
+          val s = xs.mkString
+          s.take(1).toLowerCase + s.drop(1)
+        })
+        .suchThat(_.forall(_.isLetter))
+
+    (for {
+      list <- Gen.listOfN(nr, nonEmptyAlphaStr) suchThat (l => l.size == l.distinct.size)
+      item <- list
+    } yield AttributeKey[T](item)).label(s"mkAttrKeys($nr)")
+  }
+
+  property("Derived setting(s) replace DerivedSetting in the Seq[Setting[_]]") =
+    derivedKeepsPosition
+  final def derivedKeepsPosition: Prop = {
+    val a: ScopedKey[Int] = ScopedKey(Scope(0), AttributeKey[Int]("a"))
+    val b: ScopedKey[Int] = ScopedKey(Scope(0), AttributeKey[Int]("b"))
+    val prop1 = {
+      val settings: Seq[Setting[_]] = Seq(
+        setting(a, value(3)),
+        setting(b, value(6)),
+        derive(setting(b, a)),
+        setting(a, value(5)),
+        setting(b, value(8))
+      )
+      val ev = evaluate(settings)
+      checkKey(a, Some(5), ev) && checkKey(b, Some(8), ev)
+    }
+    val prop2 = {
+      val settings: Seq[Setting[Int]] = Seq(
+        setting(a, value(3)),
+        setting(b, value(6)),
+        derive(setting(b, a)),
+        setting(a, value(5))
+      )
+      val ev = evaluate(settings)
+      checkKey(a, Some(5), ev) && checkKey(b, Some(5), ev)
+    }
+    prop1 && prop2
+  }
+
+  property(
+    "DerivedSetting in ThisBuild scopes derived settings under projects thus allowing safe +="
+  ) = forAllNoShrink(Gen.choose(1, 100)) { derivedSettingsScope }
+  final def derivedSettingsScope(nrProjects: Int): Prop = {
+    forAll(mkAttrKeys[Int](2)) {
+      case List(key, derivedKey) =>
+        val projectKeys = for { proj <- 1 to nrProjects } yield ScopedKey(Scope(1, proj), key)
+        val projectDerivedKeys = for { proj <- 1 to nrProjects } yield ScopedKey(
+          Scope(1, proj),
+          derivedKey
+        )
+        val globalKey = ScopedKey(Scope(0), key)
+        val globalDerivedKey = ScopedKey(Scope(0), derivedKey)
+        // Each project defines an initial value, but the update is defined in globalKey.
+        // However, the derived Settings that come from this should be scoped in each project.
+        val settings: Seq[Setting[_]] =
+          derive(setting(globalDerivedKey, settingsExample.map(globalKey)(_ + 1))) +: projectKeys
+            .map(pk => setting(pk, value(0)))
+        val ev = evaluate(settings)
+        // Also check that the key has no value at the "global" scope
+        val props = for { pk <- projectDerivedKeys } yield checkKey(pk, Some(1), ev)
+        checkKey(globalDerivedKey, None, ev) && Prop.all(props: _*)
+    }
+  }
+
+  // Circular (dynamic) references currently loop infinitely.
+  //  This is the expected behavior (detecting dynamic cycles is expensive),
+  //  but it may be necessary to provide an option to detect them (with a performance hit)
+  // This would test that cycle detection.
+  //  property("Catches circular references") = forAll(chainLengthGen) { checkCircularReferences _ }
+  final def checkCircularReferences(intermediate: Int): Prop = {
+    val ccr = new CCR(intermediate)
+    try {
+      evaluate(setting(chk, ccr.top) :: Nil); false
+    } catch {
+      case _: java.lang.Exception => true
+    }
+  }
+
+  def tests =
+    for (i <- 0 to 5; k <- Seq(a, b)) yield {
+      val expected = expectedValues(2 * i + (if (k == a) 0 else 1))
+      checkKey[Int](ScopedKey(Scope(i), k), expected, applied)
+    }
+
+  lazy val expectedValues = None :: None :: None :: None :: None :: None :: Some(3) :: None ::
+    Some(3) :: Some(9) :: Some(4) :: Some(9) :: Nil
+
+  lazy val ch = AttributeKey[Int]("ch")
+  lazy val chk = ScopedKey(Scope(0), ch)
+  def chain(i: Int, prev: Initialize[Int]): Initialize[Int] =
+    if (i <= 0) prev else chain(i - 1, prev(_ + 1))
+
+  def chainBind(prev: Initialize[Int]): Initialize[Int] =
+    bind(prev) { v =>
+      if (v <= 0) prev else chainBind(value(v - 1))
+    }
+  def singleIntTest(i: Initialize[Int], expected: Int) = {
+    val eval = evaluate(setting(chk, i) :: Nil)
+    checkKey(chk, Some(expected), eval)
+  }
+
+  def checkKey[T](key: ScopedKey[T], expected: Option[T], settings: Settings[Scope]) = {
+    val value = settings.get(key.scope, key.key)
+    ("Key: " + key) |:
+      ("Value: " + value) |:
+      ("Expected: " + expected) |:
+      (value == expected)
+  }
+
+  def evaluate(settings: Seq[Setting[_]]): Settings[Scope] =
+    try {
+      makeWithCompiledMap(settings)(delegates, scopeLocal, showFullKey)._2
+    } catch {
+      case e: Throwable => e.printStackTrace(); throw e
+    }
+}
+// This setup is a workaround for module synchronization issues
+final class CCR(intermediate: Int) {
+  import SettingsTest.settingsExample._
+  lazy val top = iterate(value(intermediate))
+  def iterate(init: Initialize[Int]): Initialize[Int] =
+    bind(init) { t =>
+      if (t <= 0)
+        top
+      else
+        iterate(value(t - 1))
+    }
+}
diff --git a/internal/util-collection/src/test/scala/UnitSpec.scala b/internal/util-collection/src/test/scala/UnitSpec.scala
new file mode 100644
index 000000000..ed582c3bb
--- /dev/null
+++ b/internal/util-collection/src/test/scala/UnitSpec.scala
@@ -0,0 +1,12 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalatest._
+
+abstract class UnitSpec extends FlatSpec with Matchers
diff --git a/internal/util-complete/NOTICE b/internal/util-complete/NOTICE
new file mode 100644
index 000000000..d5827b9c2
--- /dev/null
+++ b/internal/util-complete/NOTICE
@@ -0,0 +1,4 @@
+sbt: Completion Component
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under BSD-3-Clause license (see LICENSE)
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/LineReader.scala b/internal/util-complete/src/main/scala/sbt/internal/util/LineReader.scala
new file mode 100644
index 000000000..d52903d87
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/LineReader.scala
@@ -0,0 +1,370 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io._
+import java.util.{ List => JList }
+
+import jline.console.ConsoleReader
+import jline.console.history.{ FileHistory, MemoryHistory }
+import org.jline.reader.{
+  Candidate,
+  Completer,
+  EndOfFileException,
+  LineReader => JLineReader,
+  LineReaderBuilder,
+  ParsedLine,
+  UserInterruptException,
+}
+import org.jline.utils.ClosedException
+import sbt.internal.util.complete.Parser
+import sbt.io.syntax._
+
+import scala.annotation.tailrec
+import scala.concurrent.duration._
+import scala.util.control.NonFatal
+import java.nio.channels.ClosedByInterruptException
+import java.net.MalformedURLException
+
+import org.jline.builtins.InputRC
+
+trait LineReader extends AutoCloseable {
+  def readLine(prompt: String, mask: Option[Char] = None): Option[String]
+  override def close(): Unit = {}
+}
+
+object LineReader {
+  val HandleCONT =
+    !java.lang.Boolean.getBoolean("sbt.disable.cont") && Signals.supported(Signals.CONT)
+  val MaxHistorySize = 500
+
+  private def completer(parser: Parser[_]): Completer = new Completer {
+    def complete(lr: JLineReader, pl: ParsedLine, candidates: JList[Candidate]): Unit = {
+      Parser.completions(parser, pl.line(), 10).get.foreach { c =>
+        /*
+         * For commands like `~` that delegate parsing to another parser, the `~` may be
+         * excluded from the completion result. For example,
+         * ~testOnly <TAB>
+         * might return results like
+         * 'testOnly ;'
+         * 'testOnly com.foo.FooSpec'
+         * ...
+         * If we use the raw display, JLine will reject the completions because they are
+         * missing the leading `~`. To workaround this, we append to the result to the
+         * line provided the line does not end with " ". This fixes the missing `~` in
+         * the prefix problem. We also need to split the line on space and take the
+         * last token and append to that otherwise the completion will double print
+         * the prefix, so that `testOnly com<Tab>` might expand to something like:
+         * `testOnly testOnly\ com.foo.FooSpec` instead of `testOnly com.foo.FooSpec`.
+         */
+        if (c.append.nonEmpty) {
+          val cand = pl.line() match {
+            case line if line.endsWith(" ") => c.append
+            case line                       => line.split(" ").last + c.append
+          }
+          // https://github.com/jline/jline3/blob/9a4971868e4bdd29a36e454de01f54d3cd6071e0/reader/src/main/java/org/jline/reader/Candidate.java#L123-L131
+          // "If the candidate is complete and is selected, a space separator will be added."
+          val complete = false
+          candidates.add(new Candidate(cand, cand, null, null, null, null, complete))
+        }
+      }
+    }
+  }
+  private[this] def inputrcFileUrl(): Option[URL] = {
+    // keep jline2 compatibility
+    // https://github.com/jline/jline2/blob/12b98d94589e3bd6a6/src/main/java/jline/console/ConsoleReader.java#L291-L306
+    sys.props
+      .get("jline.inputrc")
+      .flatMap { path =>
+        try {
+          Some(url(path))
+        } catch {
+          case _: MalformedURLException =>
+            Some(file(path).toURI.toURL)
+        }
+      }
+      .orElse {
+        sys.props.get("user.home").map { home =>
+          val f = file(home) / ".inputrc"
+          (if (f.isFile) f else file("/etc/inputrc")).toURI.toURL
+        }
+      }
+  }
+  // cache on memory.
+  private[this] lazy val inputrcFileContents: Option[Array[Byte]] =
+    inputrcFileUrl().map(in => sbt.io.IO.readBytes(in.openStream()))
+  def createReader(
+      historyPath: Option[File],
+      parser: Parser[_],
+      terminal: Terminal,
+  ): LineReader = {
+    // We may want to consider insourcing LineReader.java from jline. We don't otherwise
+    // directly need jline3 for sbt.
+    new LineReader {
+      override def readLine(prompt: String, mask: Option[Char]): Option[String] = {
+        val term = JLine3(terminal)
+        val reader = LineReaderBuilder.builder().terminal(term).completer(completer(parser)).build()
+        try {
+          inputrcFileContents.foreach { bytes =>
+            InputRC.configure(
+              reader,
+              new ByteArrayInputStream(bytes)
+            )
+          }
+        } catch {
+          case NonFatal(_) =>
+          // ignore
+        }
+        historyPath.foreach(f => reader.setVariable(JLineReader.HISTORY_FILE, f))
+        val signalRegistration = terminal match {
+          case _: Terminal.ConsoleTerminal => Some(Signals.register(() => terminal.write(-1)))
+          case _                           => None
+        }
+        try terminal.withRawInput {
+          Option(mask.map(reader.readLine(prompt, _)).getOrElse(reader.readLine(prompt)))
+        } catch {
+          case e: EndOfFileException =>
+            if (terminal == Terminal.console && System.console == null) None
+            else Some("exit")
+          case _: IOError | _: ClosedException => Some("exit")
+          case _: UserInterruptException | _: ClosedByInterruptException |
+              _: UncheckedIOException =>
+            throw new InterruptedException
+        } finally {
+          signalRegistration.foreach(_.remove())
+          terminal.prompt.reset()
+          term.close()
+        }
+      }
+    }
+  }
+
+  def createJLine2Reader(
+      historyPath: Option[File],
+      terminal: Terminal,
+      prompt: Prompt = Prompt.Running,
+  ): ConsoleReader = {
+    val cr = Terminal.createReader(terminal, prompt)
+    cr.setExpandEvents(false) // https://issues.scala-lang.org/browse/SI-7650
+    cr.setBellEnabled(false)
+    val h = historyPath match {
+      case None       => new MemoryHistory
+      case Some(file) => new FileHistory(file): MemoryHistory
+    }
+    h.setMaxSize(MaxHistorySize)
+    cr.setHistory(h)
+    cr.setHistoryEnabled(true)
+    cr
+  }
+  def simple(terminal: Terminal): LineReader = new SimpleReader(None, HandleCONT, terminal)
+  def simple(
+      historyPath: Option[File],
+      handleCONT: Boolean = HandleCONT,
+      injectThreadSleep: Boolean = false
+  ): LineReader = new SimpleReader(historyPath, handleCONT, injectThreadSleep)
+}
+
+abstract class JLine extends LineReader {
+  protected[this] def handleCONT: Boolean
+  protected[this] def reader: ConsoleReader
+  @deprecated("For binary compatibility only", "1.4.0")
+  protected[this] def injectThreadSleep: Boolean = false
+  @deprecated("For binary compatibility only", "1.4.0")
+  protected[this] lazy val in: InputStream = Terminal.wrappedSystemIn
+
+  override def readLine(prompt: String, mask: Option[Char] = None): Option[String] =
+    try {
+      unsynchronizedReadLine(prompt, mask)
+    } catch {
+      case _: InterruptedException =>
+        // println("readLine: InterruptedException")
+        Option("")
+    }
+
+  private[this] def unsynchronizedReadLine(prompt: String, mask: Option[Char]): Option[String] =
+    readLineWithHistory(prompt, mask) map { x =>
+      x.trim
+    }
+
+  private[this] def readLineWithHistory(prompt: String, mask: Option[Char]): Option[String] =
+    reader.getHistory match {
+      case fh: FileHistory =>
+        try readLineDirect(prompt, mask)
+        finally fh.flush()
+      case _ => readLineDirect(prompt, mask)
+    }
+
+  private[this] def readLineDirect(prompt: String, mask: Option[Char]): Option[String] =
+    if (handleCONT)
+      Signals.withHandler(() => resume(), signal = Signals.CONT)(
+        () => readLineDirectRaw(prompt, mask)
+      )
+    else
+      readLineDirectRaw(prompt, mask)
+
+  private[this] def readLineDirectRaw(prompt: String, mask: Option[Char]): Option[String] = {
+    val newprompt = handleMultilinePrompt(prompt)
+    mask match {
+      case Some(m) => Option(reader.readLine(newprompt, m))
+      case None    => Option(reader.readLine(newprompt))
+    }
+  }
+
+  private[this] def handleMultilinePrompt(prompt: String): String = {
+    val lines0 = """\r?\n""".r.split(prompt)
+    lines0.length match {
+      case 0 | 1 => handleProgress(prompt)
+      case _ =>
+        val lines = lines0.toList map handleProgress
+        // Workaround for regression jline/jline2#205
+        reader.getOutput.write(lines.init.mkString("\n") + "\n")
+        lines.last
+    }
+  }
+
+  private[this] def handleProgress(prompt: String): String = {
+    import ConsoleAppender._
+    if (showProgress) s"$DeleteLine" + prompt
+    else prompt
+  }
+
+  private[this] def resume(): Unit = {
+    Terminal.reset()
+    reader.drawLine()
+    reader.flush()
+  }
+}
+
+@deprecated("Use LineReader apis", "1.4.0")
+private[sbt] object JLine {
+  @deprecated("For binary compatibility only", "1.4.0")
+  protected[this] val originalIn = new FileInputStream(FileDescriptor.in)
+
+  @deprecated("Handled by Terminal.fixTerminalProperty", "1.4.0")
+  private[sbt] def fixTerminalProperty(): Unit = ()
+
+  @deprecated("For binary compatibility only", "1.4.0")
+  private[sbt] def makeInputStream(injectThreadSleep: Boolean): InputStream =
+    if (injectThreadSleep) new InputStreamWrapper(originalIn, 2.milliseconds)
+    else originalIn
+
+  // When calling this, ensure that enableEcho has been or will be called.
+  // TerminalFactory.get will initialize the terminal to disable echo.
+  @deprecated("Don't use jline.Terminal directly", "1.4.0")
+  private[sbt] def terminal: jline.Terminal = Terminal.deprecatedTeminal
+
+  /**
+   * For accessing the JLine Terminal object.
+   * This ensures synchronized access as well as re-enabling echo after getting the Terminal.
+   */
+  @deprecated(
+    "Don't use jline.Terminal directly. Use Terminal.get.withCanonicalIn instead.",
+    "1.4.0"
+  )
+  def usingTerminal[T](f: jline.Terminal => T): T = f(Terminal.get.toJLine)
+
+  @deprecated("unused", "1.4.0")
+  def createReader(): ConsoleReader = createReader(None, Terminal.wrappedSystemIn)
+
+  @deprecated("Use LineReader.createReader", "1.4.0")
+  def createReader(historyPath: Option[File], in: InputStream): ConsoleReader = {
+    val cr = Terminal.createReader(Terminal.console, Prompt.Running)
+    cr.setExpandEvents(false) // https://issues.scala-lang.org/browse/SI-7650
+    cr.setBellEnabled(false)
+    val h = historyPath match {
+      case None       => new MemoryHistory
+      case Some(file) => new FileHistory(file): MemoryHistory
+    }
+    h.setMaxSize(MaxHistorySize)
+    cr.setHistory(h)
+    cr
+  }
+
+  @deprecated("Avoid referencing JLine directly.", "1.4.0")
+  def withJLine[T](action: => T): T = Terminal.get.withRawInput(action)
+
+  @deprecated("Use LineReader.simple instead", "1.4.0")
+  def simple(
+      historyPath: Option[File],
+      handleCONT: Boolean = LineReader.HandleCONT,
+      injectThreadSleep: Boolean = false
+  ): SimpleReader = new SimpleReader(historyPath, handleCONT, injectThreadSleep)
+
+  @deprecated("Use LineReader.MaxHistorySize", "1.4.0")
+  val MaxHistorySize = LineReader.MaxHistorySize
+
+  @deprecated("Use LineReader.HandleCONT", "1.4.0")
+  val HandleCONT = LineReader.HandleCONT
+}
+
+@deprecated("For binary compatibility only", "1.4.0")
+private[sbt] class InputStreamWrapper(is: InputStream, val poll: Duration)
+    extends FilterInputStream(is) {
+  @tailrec final override def read(): Int =
+    if (is.available() != 0) is.read()
+    else {
+      Thread.sleep(poll.toMillis)
+      read()
+    }
+
+  @tailrec final override def read(b: Array[Byte]): Int =
+    if (is.available() != 0) is.read(b)
+    else {
+      Thread.sleep(poll.toMillis)
+      read(b)
+    }
+
+  @tailrec final override def read(b: Array[Byte], off: Int, len: Int): Int =
+    if (is.available() != 0) is.read(b, off, len)
+    else {
+      Thread.sleep(poll.toMillis)
+      read(b, off, len)
+    }
+}
+
+final class FullReader(
+    historyPath: Option[File],
+    complete: Parser[_],
+    val handleCONT: Boolean,
+    terminal: Terminal
+) extends JLine {
+  @deprecated("Use the constructor with no injectThreadSleep parameter", "1.4.0")
+  def this(
+      historyPath: Option[File],
+      complete: Parser[_],
+      handleCONT: Boolean = LineReader.HandleCONT,
+      injectThreadSleep: Boolean = false
+  ) =
+    this(
+      historyPath,
+      complete,
+      handleCONT,
+      Terminal.console
+    )
+  protected[this] val reader: ConsoleReader = {
+    val cr = LineReader.createJLine2Reader(historyPath, terminal)
+    sbt.internal.util.complete.JLineCompletion.installCustomCompletor(cr, complete)
+    cr
+  }
+}
+
+class SimpleReader private[sbt] (
+    historyPath: Option[File],
+    val handleCONT: Boolean,
+    terminal: Terminal
+) extends JLine {
+  def this(historyPath: Option[File], handleCONT: Boolean, injectThreadSleep: Boolean) =
+    this(historyPath, handleCONT, Terminal.console)
+  protected[this] lazy val reader: ConsoleReader =
+    LineReader.createJLine2Reader(historyPath, terminal)
+}
+
+object SimpleReader extends SimpleReader(None, LineReader.HandleCONT, false) {
+  def apply(terminal: Terminal): SimpleReader =
+    new SimpleReader(None, LineReader.HandleCONT, terminal)
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Completions.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Completions.scala
new file mode 100644
index 000000000..2d938d89a
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Completions.scala
@@ -0,0 +1,173 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+/**
+ * Represents a set of completions.
+ * It exists instead of implicitly defined operations on top of Set[Completion]
+ *  for laziness.
+ */
+sealed trait Completions {
+  def get: Set[Completion]
+
+  final def x(o: Completions): Completions = flatMap(_ x o)
+  final def ++(o: Completions): Completions = Completions(get ++ o.get)
+  final def +:(o: Completion): Completions = Completions(get + o)
+  final def filter(f: Completion => Boolean): Completions = Completions(get filter f)
+  final def filterS(f: String => Boolean): Completions = filter(c => f(c.append))
+
+  override def toString = get.mkString("Completions(", ",", ")")
+
+  final def flatMap(f: Completion => Completions): Completions =
+    Completions(get.flatMap(c => f(c).get))
+
+  final def map(f: Completion => Completion): Completions = Completions(get map f)
+
+  override final def hashCode = get.hashCode
+  override final def equals(o: Any) = o match {
+    case c: Completions => get == c.get; case _ => false
+  }
+}
+
+object Completions {
+
+  /** Returns a lazy Completions instance using the provided Completion Set. */
+  def apply(cs: => Set[Completion]): Completions = new Completions {
+    lazy val get = cs
+  }
+
+  /** Returns a strict Completions instance using the provided Completion Set. */
+  def strict(cs: Set[Completion]): Completions = apply(cs)
+
+  /**
+   * No suggested completions, not even the empty Completion.
+   * This typically represents invalid input.
+   */
+  val nil: Completions = strict(Set.empty)
+
+  /**
+   * Only includes an empty Suggestion.
+   * This typically represents valid input that either has no completions or accepts no further input.
+   */
+  val empty: Completions = strict(Set.empty + Completion.empty)
+
+  /** Returns a strict Completions instance containing only the provided Completion.*/
+  def single(c: Completion): Completions = strict(Set.empty + c)
+
+}
+
+/**
+ * Represents a completion.
+ * The abstract members `display` and `append` are best explained with an example.
+ *
+ * Assuming space-delimited tokens, processing this:
+ *   am is are w<TAB>
+ * could produce these Completions:
+ *   Completion { display = "was"; append = "as" }
+ *   Completion { display = "were"; append = "ere" }
+ * to suggest the tokens "was" and "were".
+ *
+ * In this way, two pieces of information are preserved:
+ *  1) what needs to be appended to the current input if a completion is selected
+ *  2) the full token being completed, which is useful for presenting a user with choices to select
+ */
+sealed trait Completion {
+
+  /** The proposed suffix to append to the existing input to complete the last token in the input.*/
+  def append: String
+
+  /** The string to present to the user to represent the full token being suggested.*/
+  def display: String
+
+  /** True if this Completion is suggesting the empty string.*/
+  def isEmpty: Boolean
+
+  /** Appends the completions in `o` with the completions in this Completion.*/
+  def ++(o: Completion): Completion = Completion.concat(this, o)
+
+  final def x(o: Completions): Completions =
+    if (Completion evaluatesRight this) o.map(this ++ _) else Completions.strict(Set.empty + this)
+
+  override final lazy val hashCode = Completion.hashCode(this)
+  override final def equals(o: Any) = o match {
+    case c: Completion => Completion.equal(this, c); case _ => false
+  }
+}
+
+final class DisplayOnly(val display: String) extends Completion {
+  def isEmpty = display.isEmpty
+  def append = ""
+  override def toString = "{" + display + "}"
+}
+
+final class Token(val display: String, val append: String) extends Completion {
+  def isEmpty = display.isEmpty && append.isEmpty
+  override final def toString = "[" + display + "]++" + append
+}
+
+final class Suggestion(val append: String) extends Completion {
+  def isEmpty = append.isEmpty
+  def display = append
+  override def toString = append
+}
+
+object Completion {
+  def concat(a: Completion, b: Completion): Completion =
+    (a, b) match {
+      case (as: Suggestion, bs: Suggestion)    => suggestion(as.append + bs.append)
+      case (at: Token, _) if at.append.isEmpty => b
+      case _ if a.isEmpty                      => b
+      case _                                   => a
+    }
+
+  def evaluatesRight(a: Completion): Boolean =
+    a match {
+      case _: Suggestion                  => true
+      case at: Token if at.append.isEmpty => true
+      case _                              => a.isEmpty
+    }
+
+  def equal(a: Completion, b: Completion): Boolean =
+    (a, b) match {
+      case (as: Suggestion, bs: Suggestion)   => as.append == bs.append
+      case (ad: DisplayOnly, bd: DisplayOnly) => ad.display == bd.display
+      case (at: Token, bt: Token)             => at.display == bt.display && at.append == bt.append
+      case _                                  => false
+    }
+
+  def hashCode(a: Completion): Int =
+    a match {
+      case as: Suggestion  => (0, as.append).hashCode
+      case ad: DisplayOnly => (1, ad.display).hashCode
+      case at: Token       => (2, at.display, at.append).hashCode
+    }
+
+  val empty: Completion = suggestion("")
+  def single(c: Char): Completion = suggestion(c.toString)
+
+  def displayOnly(value: String): Completion = new DisplayOnly(value)
+
+  def token(prepend: String, append: String): Completion =
+    new Token(prepend + append, append)
+
+  /** @since 0.12.1 */
+  def tokenDisplay(append: String, display: String): Completion = new Token(display, append)
+
+  def suggestion(value: String): Completion = new Suggestion(value)
+
+  @deprecated("No longer used. for binary compatibility", "1.1.0")
+  private[complete] def displayOnly(value: => String): Completion = new DisplayOnly(value)
+
+  @deprecated("No longer used. for binary compatibility", "1.1.0")
+  private[complete] def token(prepend: => String, append: => String): Completion =
+    new Token(prepend + append, append)
+
+  @deprecated("No longer used. for binary compatibility", "1.1.0")
+  private[complete] def suggestion(value: => String): Completion = new Suggestion(value)
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/EditDistance.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/EditDistance.scala
new file mode 100644
index 000000000..e7c710c87
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/EditDistance.scala
@@ -0,0 +1,60 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import java.lang.Character.{ toLowerCase => lower }
+
+/** @author Paul Phillips */
+object EditDistance {
+
+  /**
+   * Translated from the java version at
+   *    http://www.merriampark.com/ld.htm
+   *  which is declared to be public domain.
+   */
+  def levenshtein(
+      s: String,
+      t: String,
+      insertCost: Int = 1,
+      deleteCost: Int = 1,
+      subCost: Int = 1,
+      transposeCost: Int = 1,
+      matchCost: Int = 0,
+      caseCost: Int = 1,
+      transpositions: Boolean = false
+  ): Int = {
+    val _ = transposeCost
+    val n = s.length
+    val m = t.length
+    if (n == 0) return m
+    if (m == 0) return n
+
+    val d = Array.ofDim[Int](n + 1, m + 1)
+    0 to n foreach (x => d(x)(0) = x)
+    0 to m foreach (x => d(0)(x) = x)
+
+    for (i <- 1 to n; s_i = s(i - 1); j <- 1 to m) {
+      val t_j = t(j - 1)
+      val cost = if (s_i == t_j) matchCost else if (lower(s_i) == lower(t_j)) caseCost else subCost
+
+      val c1 = d(i - 1)(j) + deleteCost
+      val c2 = d(i)(j - 1) + insertCost
+      val c3 = d(i - 1)(j - 1) + cost
+
+      d(i)(j) = c1 min c2 min c3
+
+      if (transpositions) {
+        if (i > 1 && j > 1 && s(i - 1) == t(j - 2) && s(i - 2) == t(j - 1))
+          d(i)(j) = d(i)(j) min (d(i - 2)(j - 2) + cost)
+      }
+    }
+
+    d(n)(m)
+  }
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/ExampleSource.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ExampleSource.scala
new file mode 100644
index 000000000..e15217524
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ExampleSource.scala
@@ -0,0 +1,75 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import java.io.File
+import sbt.io.IO
+
+/**
+ * These sources of examples are used in parsers for user input completion. An example of such a source is the
+ * [[sbt.internal.util.complete.FileExamples]] class, which provides a list of suggested files to the user as they press the
+ * TAB key in the console.
+ */
+trait ExampleSource {
+
+  /**
+   * @return a (possibly lazy) list of completion example strings. These strings are continuations of user's input. The
+   *         user's input is incremented with calls to [[withAddedPrefix]].
+   */
+  def apply(): Iterable[String]
+
+  /**
+   * @param addedPrefix a string that just typed in by the user.
+   * @return a new source of only those examples that start with the string typed by the user so far (with addition of
+   *         the just added prefix).
+   */
+  def withAddedPrefix(addedPrefix: String): ExampleSource
+
+}
+
+/**
+ * A convenience example source that wraps any collection of strings into a source of examples.
+ * @param examples the examples that will be displayed to the user when they press the TAB key.
+ */
+sealed case class FixedSetExamples(examples: Iterable[String]) extends ExampleSource {
+  override def withAddedPrefix(addedPrefix: String): ExampleSource =
+    FixedSetExamples(examplesWithRemovedPrefix(addedPrefix))
+
+  override def apply(): Iterable[String] = examples
+
+  private def examplesWithRemovedPrefix(prefix: String) = examples.collect {
+    case example if example startsWith prefix => example substring prefix.length
+  }
+}
+
+/**
+ * Provides path completion examples based on files in the base directory.
+ * @param base the directory within which this class will search for completion examples.
+ * @param prefix the part of the path already written by the user.
+ */
+class FileExamples(base: File, prefix: String = "") extends ExampleSource {
+  override def apply(): Stream[String] = files(base).map(_ substring prefix.length)
+
+  override def withAddedPrefix(addedPrefix: String): FileExamples =
+    new FileExamples(base, prefix + addedPrefix)
+
+  protected def files(directory: File): Stream[String] = {
+    val childPaths = IO.listFiles(directory).toStream
+    val prefixedDirectChildPaths = childPaths map { IO.relativize(base, _).get } filter {
+      _ startsWith prefix
+    }
+    val dirsToRecurseInto = childPaths filter { _.isDirectory } map { IO.relativize(base, _).get } filter {
+      dirStartsWithPrefix
+    }
+    prefixedDirectChildPaths append dirsToRecurseInto.flatMap(dir => files(new File(base, dir)))
+  }
+
+  private def dirStartsWithPrefix(relativizedPath: String): Boolean =
+    (relativizedPath startsWith prefix) || (prefix startsWith relativizedPath)
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/History.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/History.scala
new file mode 100644
index 000000000..b65dba0dc
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/History.scala
@@ -0,0 +1,63 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import History.number
+import java.io.File
+
+final class History private (val lines: IndexedSeq[String], val path: Option[File]) {
+  private def reversed = lines.reverse
+
+  def all: Seq[String] = lines
+  def size = lines.length
+  def !! : Option[String] = !-(1)
+
+  def apply(i: Int): Option[String] =
+    if (0 <= i && i < size) Some(lines(i))
+    else {
+      sys.error("Invalid history index: " + i)
+    }
+
+  def !(i: Int): Option[String] = apply(i)
+
+  def !(s: String): Option[String] =
+    number(s) match {
+      case Some(n) => if (n < 0) !-(-n) else apply(n)
+      case None    => nonEmpty(s) { reversed.find(_.startsWith(s)) }
+    }
+
+  def !-(n: Int): Option[String] = apply(size - n - 1)
+
+  def !?(s: String): Option[String] = nonEmpty(s) { reversed.drop(1).find(_.contains(s)) }
+
+  private def nonEmpty[T](s: String)(act: => Option[T]): Option[T] =
+    if (s.isEmpty)
+      sys.error("No action specified to history command")
+    else
+      act
+
+  def list(historySize: Int, show: Int): Seq[String] =
+    lines.toList
+      .drop(scala.math.max(0, lines.size - historySize))
+      .zipWithIndex
+      .map { case (line, number) => "   " + number + "  " + line }
+      .takeRight(show max 1)
+}
+
+object History {
+  def apply(lines: Seq[String], path: Option[File], error: String => Unit): History =
+    new History(lines.toIndexedSeq, path)
+  def apply(lines: Seq[String], path: Option[File]): History =
+    new History(lines.toIndexedSeq, path)
+
+  def number(s: String): Option[Int] =
+    try {
+      Some(s.toInt)
+    } catch { case _: NumberFormatException => None }
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/HistoryCommands.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/HistoryCommands.scala
new file mode 100644
index 000000000..6c45f54e9
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/HistoryCommands.scala
@@ -0,0 +1,88 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import sbt.io.IO
+import Util.{ AnyOps, nil }
+
+object HistoryCommands {
+  val Start = "!"
+  // second characters
+  val Contains = "?"
+  val Last = "!"
+  val ListCommands = ":"
+
+  def ContainsFull = h(Contains)
+  def LastFull = h(Last)
+  def ListFull = h(ListCommands)
+
+  def ListN = ListFull + "n"
+  def ContainsString = ContainsFull + "string"
+  def StartsWithString = Start + "string"
+  def Previous = Start + "-n"
+  def Nth = Start + "n"
+
+  private def h(s: String) = Start + s
+  def plainCommands = Seq(ListFull, Start, LastFull, ContainsFull)
+
+  def descriptions = Seq(
+    LastFull -> "Execute the last command again",
+    ListFull -> "Show all previous commands",
+    ListN -> "Show the last n commands",
+    Nth -> ("Execute the command with index n, as shown by the " + ListFull + " command"),
+    Previous -> "Execute the nth command before this one",
+    StartsWithString -> "Execute the most recent command starting with 'string'",
+    ContainsString -> "Execute the most recent command containing 'string'"
+  )
+
+  def helpString =
+    "History commands:\n   " + (descriptions
+      .map { case (c, d) => c + "    " + d })
+      .mkString("\n   ")
+
+  def printHelp(): Unit = println(helpString)
+
+  def printHistory(history: complete.History, historySize: Int, show: Int): Unit =
+    history.list(historySize, show).foreach(println)
+
+  import DefaultParsers._
+
+  val MaxLines = 500
+  lazy val num = token(NatBasic, "<integer>")
+  lazy val last = Last ^^^ { execute(_.!!) }
+
+  lazy val list = ListCommands ~> (num ?? Int.MaxValue) map { show => (h: History) =>
+    { printHistory(h, MaxLines, show); nil[String].some }
+  }
+
+  lazy val execStr = flag('?') ~ token(any.+.string, "<string>") map {
+    case (contains, str) =>
+      execute(h => if (contains) h !? str else h ! str)
+  }
+
+  lazy val execInt = flag('-') ~ num map {
+    case (neg, value) =>
+      execute(h => if (neg) h !- value else h ! value)
+  }
+
+  lazy val help = success((h: History) => { printHelp(); nil[String].some })
+
+  def execute(f: History => Option[String]): History => Option[List[String]] = (h: History) => {
+    val command = f(h).filterNot(_.startsWith(Start))
+    val lines = h.lines.toArray
+    command.foreach(lines(lines.length - 1) = _)
+    h.path foreach { h =>
+      IO.writeLines(h, lines)
+    }
+    command.toList.some
+  }
+
+  val actionParser: Parser[complete.History => Option[List[String]]] =
+    Start ~> (help | last | execInt | list | execStr) // execStr must come last
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/JLineCompletion.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/JLineCompletion.scala
new file mode 100644
index 000000000..1e9f4cfcb
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/JLineCompletion.scala
@@ -0,0 +1,184 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import jline.console.ConsoleReader
+import jline.console.completer.{ Completer, CompletionHandler }
+import scala.annotation.tailrec
+import scala.collection.JavaConverters._
+
+object JLineCompletion {
+  def installCustomCompletor(reader: ConsoleReader, parser: Parser[_]): Unit =
+    installCustomCompletor(reader)(parserAsCompletor(parser))
+
+  def installCustomCompletor(reader: ConsoleReader)(
+      complete: (String, Int) => (Seq[String], Seq[String])
+  ): Unit =
+    installCustomCompletor(customCompletor(complete), reader)
+
+  def installCustomCompletor(
+      complete: (ConsoleReader, Int) => Boolean,
+      reader: ConsoleReader
+  ): Unit = {
+    reader.removeCompleter(DummyCompletor)
+    reader.addCompleter(DummyCompletor)
+    reader.setCompletionHandler(new CustomHandler(complete))
+  }
+
+  private[this] final class CustomHandler(completeImpl: (ConsoleReader, Int) => Boolean)
+      extends CompletionHandler {
+    private[this] var previous: Option[(String, Int)] = None
+    private[this] var level: Int = 1
+
+    override def complete(
+        reader: ConsoleReader,
+        candidates: java.util.List[CharSequence],
+        position: Int
+    ) = {
+      val current = Some(bufferSnapshot(reader))
+      level = if (current == previous) level + 1 else 1
+      previous = current
+      try completeImpl(reader, level)
+      catch {
+        case e: Exception =>
+          reader.print("\nException occurred while determining completions.")
+          e.printStackTrace()
+          false
+      }
+    }
+  }
+
+  // always provides dummy completions so that the custom completion handler gets called
+  //   (ConsoleReader doesn't call the handler if there aren't any completions)
+  //   the custom handler will then throw away the candidates and call the custom function
+  private[this] final object DummyCompletor extends Completer {
+    override def complete(
+        buffer: String,
+        cursor: Int,
+        candidates: java.util.List[CharSequence]
+    ): Int = {
+      candidates.asInstanceOf[java.util.List[String]] add "dummy"
+      0
+    }
+  }
+
+  def parserAsCompletor(p: Parser[_]): (String, Int) => (Seq[String], Seq[String]) =
+    (str, level) => convertCompletions(Parser.completions(p, str, level))
+
+  def convertCompletions(c: Completions): (Seq[String], Seq[String]) = {
+    val cs = c.get
+    if (cs.isEmpty)
+      (Nil, "{invalid input}" :: Nil)
+    else
+      convertCompletions(cs)
+  }
+
+  def convertCompletions(cs: Set[Completion]): (Seq[String], Seq[String]) = {
+    val (insert, display) =
+      cs.foldLeft((Set.empty[String], Set.empty[String])) {
+        case (t @ (insert, display), comp) =>
+          if (comp.isEmpty) t
+          else (appendNonEmpty(insert, comp.append), appendNonEmpty(display, comp.display))
+      }
+    (insert.toSeq, display.toSeq.sorted)
+  }
+
+  def appendNonEmpty(set: Set[String], add: String) = if (add.trim.isEmpty) set else set + add
+
+  def customCompletor(
+      f: (String, Int) => (Seq[String], Seq[String])
+  ): (ConsoleReader, Int) => Boolean =
+    (reader, level) => {
+      val success = complete(beforeCursor(reader), string => f(string, level), reader)
+      reader.flush()
+      success
+    }
+
+  def bufferSnapshot(reader: ConsoleReader): (String, Int) = {
+    val b = reader.getCursorBuffer
+    (b.buffer.toString, b.cursor)
+  }
+
+  def beforeCursor(reader: ConsoleReader): String = {
+    val b = reader.getCursorBuffer
+    b.buffer.substring(0, b.cursor)
+  }
+
+  // returns false if there was nothing to insert and nothing to display
+  def complete(
+      beforeCursor: String,
+      completions: String => (Seq[String], Seq[String]),
+      reader: ConsoleReader
+  ): Boolean = {
+    val (insert, display) = completions(beforeCursor)
+    val common = commonPrefix(insert)
+    if (common.isEmpty)
+      if (display.isEmpty)
+        ()
+      else
+        showCompletions(display, reader)
+    else
+      appendCompletion(common, reader)
+
+    !(common.isEmpty && display.isEmpty)
+  }
+
+  def appendCompletion(common: String, reader: ConsoleReader): Unit = {
+    reader.getCursorBuffer.write(common)
+    reader.redrawLine()
+  }
+
+  /**
+   * `display` is assumed to be the exact strings requested to be displayed.
+   * In particular, duplicates should have been removed already.
+   */
+  def showCompletions(display: Seq[String], reader: ConsoleReader): Unit = {
+    printCompletions(display, reader)
+    reader.drawLine()
+  }
+
+  def printCompletions(cs: Seq[String], reader: ConsoleReader): Unit = {
+    val print = shouldPrint(cs, reader)
+    reader.println()
+    if (print) printLinesAndColumns(cs, reader)
+  }
+
+  def printLinesAndColumns(cs: Seq[String], reader: ConsoleReader): Unit = {
+    val (lines, columns) = cs partition hasNewline
+    for (line <- lines) {
+      reader.print(line)
+      if (line.charAt(line.length - 1) != '\n')
+        reader.println()
+    }
+    reader.printColumns(columns.map(_.trim).asJava)
+  }
+
+  def hasNewline(s: String): Boolean = s.indexOf('\n') >= 0
+
+  def shouldPrint(cs: Seq[String], reader: ConsoleReader): Boolean = {
+    val size = cs.size
+    (size <= reader.getAutoprintThreshold) ||
+    confirm("Display all %d possibilities? (y or n) ".format(size), 'y', 'n', reader)
+  }
+
+  def confirm(prompt: String, trueC: Char, falseC: Char, reader: ConsoleReader): Boolean = {
+    reader.println()
+    reader.print(prompt)
+    reader.flush()
+    reader.readCharacter(trueC, falseC) == trueC
+  }
+
+  def commonPrefix(s: Seq[String]): String = if (s.isEmpty) "" else s reduceLeft commonPrefix
+
+  def commonPrefix(a: String, b: String): String = {
+    val len = scala.math.min(a.length, b.length)
+    @tailrec def loop(i: Int): Int = if (i >= len) len else if (a(i) != b(i)) i else loop(i + 1)
+    a.substring(0, loop(0))
+  }
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parser.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parser.scala
new file mode 100644
index 000000000..464ab1916
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parser.scala
@@ -0,0 +1,988 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import Parser._
+import sbt.internal.util.Types.{ left, right, some }
+import sbt.internal.util.Util.{ makeList, separate }
+
+/**
+ * A String parser that provides semi-automatic tab completion.
+ * A successful parse results in a value of type `T`.
+ * The methods in this trait are what must be implemented to define a new Parser implementation, but are not typically useful for common usage.
+ * Instead, most useful methods for combining smaller parsers into larger parsers are implicitly added by the [[RichParser]] type.
+ */
+trait Parser[+T] {
+  def derive(i: Char): Parser[T]
+  def resultEmpty: Result[T]
+  def result: Option[T]
+  def completions(level: Int): Completions
+  def failure: Option[Failure]
+  def isTokenStart = false
+  def ifValid[S](p: => Parser[S]): Parser[S]
+  def valid: Boolean
+}
+
+sealed trait RichParser[A] {
+
+  /** Apply the original Parser and then apply `next` (in order).  The result of both is provides as a pair. */
+  def ~[B](next: Parser[B]): Parser[(A, B)]
+
+  /** Apply the original Parser one or more times and provide the non-empty sequence of results.*/
+  def + : Parser[Seq[A]]
+
+  /** Apply the original Parser zero or more times and provide the (potentially empty) sequence of results.*/
+  def * : Parser[Seq[A]]
+
+  /** Apply the original Parser zero or one times, returning None if it was applied zero times or the result wrapped in Some if it was applied once.*/
+  def ? : Parser[Option[A]]
+
+  /** Apply either the original Parser or `b`.*/
+  def |[B >: A](b: Parser[B]): Parser[B]
+
+  /** Apply either the original Parser or `b`.*/
+  def ||[B](b: Parser[B]): Parser[Either[A, B]]
+
+  /** Apply the original Parser to the input and then apply `f` to the result.*/
+  def map[B](f: A => B): Parser[B]
+
+  /**
+   * Returns the original parser.  This is useful for converting literals to Parsers.
+   * For example, `'c'.id` or `"asdf".id`
+   */
+  def id: Parser[A]
+
+  /** Apply the original Parser, but provide `value` as the result if it succeeds. */
+  def ^^^[B](value: B): Parser[B]
+
+  /** Apply the original Parser, but provide `alt` as the result if it fails.*/
+  def ??[B >: A](alt: B): Parser[B]
+
+  /**
+   * Produces a Parser that applies the original Parser and then applies `next` (in order), discarding the result of `next`.
+   * (The arrow point in the direction of the retained result.)
+   */
+  def <~[B](b: Parser[B]): Parser[A]
+
+  /**
+   * Produces a Parser that applies the original Parser and then applies `next` (in order), discarding the result of the original parser.
+   * (The arrow point in the direction of the retained result.)
+   */
+  def ~>[B](b: Parser[B]): Parser[B]
+
+  /** Uses the specified message if the original Parser fails.*/
+  def !!!(msg: String): Parser[A]
+
+  /**
+   * If an exception is thrown by the original Parser,
+   * capture it and fail locally instead of allowing the exception to propagate up and terminate parsing.
+   */
+  def failOnException: Parser[A]
+
+  /**
+   * Apply the original parser, but only succeed if `o` also succeeds.
+   * Note that `o` does not need to consume the same amount of input to satisfy this condition.
+   */
+  def &(o: Parser[_]): Parser[A]
+
+  /** Explicitly defines the completions for the original Parser.*/
+  def examples(s: String*): Parser[A]
+
+  /** Explicitly defines the completions for the original Parser.*/
+  def examples(s: Set[String], check: Boolean = false): Parser[A]
+
+  /**
+   * @param exampleSource the source of examples when displaying completions to the user.
+   * @param maxNumberOfExamples limits the number of examples that the source of examples should return. This can
+   *                            prevent lengthy pauses and avoids bad interactive user experience.
+   * @param removeInvalidExamples indicates whether completion examples should be checked for validity (against the
+   *                              given parser). Invalid examples will be filtered out and only valid suggestions will
+   *                              be displayed.
+   * @return a new parser with a new source of completions.
+   */
+  def examples(
+      exampleSource: ExampleSource,
+      maxNumberOfExamples: Int,
+      removeInvalidExamples: Boolean
+  ): Parser[A]
+
+  /**
+   * @param exampleSource the source of examples when displaying completions to the user.
+   * @return a new parser with a new source of completions. It displays at most 25 completion examples and does not
+   *         remove invalid examples.
+   */
+  def examples(exampleSource: ExampleSource): Parser[A] =
+    examples(exampleSource, maxNumberOfExamples = 25, removeInvalidExamples = false)
+
+  /** Converts a Parser returning a Char sequence to a Parser returning a String.*/
+  def string(implicit ev: A <:< Seq[Char]): Parser[String]
+
+  /**
+   * Produces a Parser that filters the original parser.
+   * If 'f' is not true when applied to the output of the original parser, the Parser returned by this method fails.
+   * The failure message is constructed by applying `msg` to the String that was successfully parsed by the original parser.
+   */
+  def filter(f: A => Boolean, msg: String => String): Parser[A]
+
+  /** Applies the original parser, applies `f` to the result to get the next parser, and applies that parser and uses its result for the overall result. */
+  def flatMap[B](f: A => Parser[B]): Parser[B]
+}
+
+/** Contains Parser implementation helper methods not typically needed for using parsers. */
+object Parser extends ParserMain {
+  sealed abstract class Result[+T] {
+    def isFailure: Boolean
+    def isValid: Boolean
+    def errors: Seq[String]
+    def or[B >: T](b: => Result[B]): Result[B]
+    def either[B](b: => Result[B]): Result[Either[T, B]]
+    def map[B](f: T => B): Result[B]
+    def flatMap[B](f: T => Result[B]): Result[B]
+    def &&(b: => Result[_]): Result[T]
+    def filter(f: T => Boolean, msg: => String): Result[T]
+    def seq[B](b: => Result[B]): Result[(T, B)] = app(b)((m, n) => (m, n))
+    def app[B, C](b: => Result[B])(f: (T, B) => C): Result[C]
+    def toEither: Either[() => Seq[String], T]
+  }
+
+  final case class Value[+T](value: T) extends Result[T] {
+    def isFailure = false
+    def isValid: Boolean = true
+    def errors = Nil
+
+    def app[B, C](b: => Result[B])(f: (T, B) => C): Result[C] = b match {
+      case fail: Failure => fail
+      case Value(bv)     => Value(f(value, bv))
+    }
+
+    def &&(b: => Result[_]): Result[T] = b match { case f: Failure => f; case _ => this }
+    def or[B >: T](b: => Result[B]): Result[B] = this
+    def either[B](b: => Result[B]): Result[Either[T, B]] = Value(Left(value))
+    def map[B](f: T => B): Result[B] = Value(f(value))
+    def flatMap[B](f: T => Result[B]): Result[B] = f(value)
+    def filter(f: T => Boolean, msg: => String): Result[T] = if (f(value)) this else mkFailure(msg)
+    def toEither = Right(value)
+  }
+
+  final class Failure private[sbt] (mkErrors: => Seq[String], val definitive: Boolean)
+      extends Result[Nothing] {
+    lazy val errors: Seq[String] = mkErrors
+    def isFailure = true
+    def isValid = false
+    def map[B](f: Nothing => B) = this
+    def flatMap[B](f: Nothing => Result[B]) = this
+
+    def or[B](b: => Result[B]): Result[B] = b match {
+      case v: Value[B] => v
+      case f: Failure  => if (definitive) this else this ++ f
+    }
+
+    def either[B](b: => Result[B]): Result[Either[Nothing, B]] = b match {
+      case Value(v)   => Value(Right(v))
+      case f: Failure => if (definitive) this else this ++ f
+    }
+
+    def filter(f: Nothing => Boolean, msg: => String) = this
+    def app[B, C](b: => Result[B])(f: (Nothing, B) => C): Result[C] = this
+    def &&(b: => Result[_]) = this
+    def toEither = Left(() => errors)
+
+    private[sbt] def ++(f: Failure) = mkFailures(errors ++ f.errors)
+  }
+
+  def mkFailures(errors: => Seq[String], definitive: Boolean = false): Failure =
+    new Failure(errors.distinct, definitive)
+
+  def mkFailure(error: => String, definitive: Boolean = false): Failure =
+    new Failure(error :: Nil, definitive)
+
+  def tuple[A, B](a: Option[A], b: Option[B]): Option[(A, B)] =
+    (a, b) match { case (Some(av), Some(bv)) => Some((av, bv)); case _ => None }
+
+  def mapParser[A, B](a: Parser[A], f: A => B): Parser[B] =
+    a.ifValid {
+      a.result match {
+        case Some(av) => success(f(av))
+        case None =>
+          a match {
+            case m: MapParser[_, A] => m.map(f)
+            case _                  => new MapParser(a, f)
+          }
+      }
+    }
+
+  def bindParser[A, B](a: Parser[A], f: A => Parser[B]): Parser[B] =
+    a.ifValid {
+      a.result match {
+        case Some(av) => f(av)
+        case None     => new BindParser(a, f)
+      }
+    }
+
+  def filterParser[T](
+      a: Parser[T],
+      f: T => Boolean,
+      seen: String,
+      msg: String => String
+  ): Parser[T] =
+    a.ifValid {
+      a.result match {
+        case Some(av) if f(av) => success(av)
+        case _                 => new Filter(a, f, seen, msg)
+      }
+    }
+
+  def seqParser[A, B](a: Parser[A], b: Parser[B]): Parser[(A, B)] =
+    a.ifValid {
+      b.ifValid {
+        (a.result, b.result) match {
+          case (Some(av), Some(bv)) => success((av, bv))
+          case (Some(av), None)     => b map (bv => (av, bv))
+          case (None, Some(bv))     => a map (av => (av, bv))
+          case (None, None)         => new SeqParser(a, b)
+        }
+      }
+    }
+
+  def choiceParser[A, B](a: Parser[A], b: Parser[B]): Parser[Either[A, B]] =
+    if (a.valid)
+      if (b.valid) new HetParser(a, b) else a.map(left.fn)
+    else
+      b.map(right.fn)
+
+  def opt[T](a: Parser[T]): Parser[Option[T]] =
+    if (a.valid) new Optional(a) else success(None)
+
+  def onFailure[T](delegate: Parser[T], msg: String): Parser[T] =
+    if (delegate.valid) new OnFailure(delegate, msg) else failure(msg)
+
+  def trapAndFail[T](delegate: Parser[T]): Parser[T] =
+    delegate.ifValid(new TrapAndFail(delegate))
+
+  def zeroOrMore[T](p: Parser[T]): Parser[Seq[T]] = repeat(p, 0, Infinite)
+  def oneOrMore[T](p: Parser[T]): Parser[Seq[T]] = repeat(p, 1, Infinite)
+
+  def repeat[T](p: Parser[T], min: Int = 0, max: UpperBound = Infinite): Parser[Seq[T]] =
+    repeat(None, p, min, max, Nil)
+
+  private[complete] def repeat[T](
+      partial: Option[Parser[T]],
+      repeated: Parser[T],
+      min: Int,
+      max: UpperBound,
+      revAcc: List[T]
+  ): Parser[Seq[T]] = {
+    assume(min >= 0, "Minimum must be greater than or equal to zero (was " + min + ")")
+    assume(
+      max >= min,
+      "Minimum must be less than or equal to maximum (min: " + min + ", max: " + max + ")"
+    )
+
+    def checkRepeated(invalidButOptional: => Parser[Seq[T]]): Parser[Seq[T]] =
+      repeated match {
+        case _: Invalid if min == 0 => invalidButOptional
+        case i: Invalid             => i
+        case _ =>
+          repeated.result match {
+            case Some(value) =>
+              success(revAcc reverse_::: value :: Nil) // revAcc should be Nil here
+            case None =>
+              if (max.isZero) success(revAcc.reverse)
+              else new Repeat(partial, repeated, min, max, revAcc)
+          }
+      }
+
+    partial match {
+      case Some(part) =>
+        part.ifValid {
+          part.result match {
+            case Some(value) => repeat(None, repeated, min, max, value :: revAcc)
+            case None        => checkRepeated(part.map(lv => (lv :: revAcc).reverse))
+          }
+        }
+      case None => checkRepeated(success(Nil))
+    }
+  }
+
+  def and[T](a: Parser[T], b: Parser[_]): Parser[T] = a.ifValid(b.ifValid(new And(a, b)))
+}
+
+trait ParserMain {
+
+  /** Provides combinators for Parsers.*/
+  implicit def richParser[A](a: Parser[A]): RichParser[A] = new RichParser[A] {
+    def ~[B](b: Parser[B]) = seqParser(a, b)
+    def ||[B](b: Parser[B]) = choiceParser(a, b)
+    def |[B >: A](b: Parser[B]) = homParser[B](a, b)
+    def ? = opt(a)
+    def * = zeroOrMore(a)
+    def + = oneOrMore(a)
+    def map[B](f: A => B) = mapParser(a, f)
+    def id = a
+
+    def ^^^[B](value: B): Parser[B] = a map (_ => value)
+    def ??[B >: A](alt: B): Parser[B] = a.? map { x =>
+      x.getOrElse[B](alt)
+    }
+    def <~[B](b: Parser[B]): Parser[A] = (a ~ b) map { case av ~ _ => av }
+    def ~>[B](b: Parser[B]): Parser[B] = (a ~ b) map { case _ ~ bv => bv }
+    def !!!(msg: String): Parser[A] = onFailure(a, msg)
+    def failOnException: Parser[A] = trapAndFail(a)
+
+    def &(o: Parser[_]) = and(a, o)
+    def examples(s: String*): Parser[A] = examples(s.toSet)
+
+    def examples(s: Set[String], check: Boolean = false): Parser[A] =
+      examples(new FixedSetExamples(s), s.size, check)
+
+    def examples(
+        s: ExampleSource,
+        maxNumberOfExamples: Int,
+        removeInvalidExamples: Boolean
+    ): Parser[A] =
+      Parser.examples(a, s, maxNumberOfExamples, removeInvalidExamples)
+
+    def filter(f: A => Boolean, msg: String => String): Parser[A] = filterParser(a, f, "", msg)
+    def string(implicit ev: A <:< Seq[Char]): Parser[String] = map(_.mkString)
+    def flatMap[B](f: A => Parser[B]) = bindParser(a, f)
+  }
+
+  implicit def literalRichCharParser(c: Char): RichParser[Char] = richParser(c)
+  implicit def literalRichStringParser(s: String): RichParser[String] = richParser(s)
+
+  /**
+   * Construct a parser that is valid, but has no valid result.  This is used as a way
+   * to provide a definitive Failure when a parser doesn't match empty input.  For example,
+   * in `softFailure(...) | p`, if `p` doesn't match the empty sequence, the failure will come
+   * from the Parser constructed by the `softFailure` method.
+   */
+  private[sbt] def softFailure(msg: => String, definitive: Boolean = false): Parser[Nothing] =
+    SoftInvalid(mkFailures(msg :: Nil, definitive))
+
+  /**
+   * Defines a parser that always fails on any input with messages `msgs`.
+   * If `definitive` is `true`, any failures by later alternatives are discarded.
+   */
+  def invalid(msgs: => Seq[String], definitive: Boolean = false): Parser[Nothing] =
+    Invalid(mkFailures(msgs, definitive))
+
+  /**
+   * Defines a parser that always fails on any input with message `msg`.
+   * If `definitive` is `true`, any failures by later alternatives are discarded.
+   */
+  def failure(msg: => String, definitive: Boolean = false): Parser[Nothing] =
+    invalid(msg :: Nil, definitive)
+
+  /** Defines a parser that always succeeds on empty input with the result `value`.*/
+  def success[T](value: T): Parser[T] = new ValidParser[T] {
+    override def result = Some(value)
+    def resultEmpty = Value(value)
+    def derive(c: Char) = Parser.failure("Expected end of input.")
+    def completions(level: Int) = Completions.empty
+    override def toString = "success(" + value + ")"
+  }
+
+  /** Presents a Char range as a Parser.  A single Char is parsed only if it is in the given range.*/
+  implicit def range(r: collection.immutable.NumericRange[Char]): Parser[Char] = {
+    val label = r.map(_.toString).toString
+    range(r, label)
+  }
+
+  /** Presents a Char range as a Parser.  A single Char is parsed only if it is in the given range.*/
+  def range(r: collection.immutable.NumericRange[Char], label: String): Parser[Char] =
+    charClass(r contains _, label).examples(r.map(_.toString): _*)
+
+  /** Defines a Parser that parses a single character only if it is contained in `legal`.*/
+  def chars(legal: String): Parser[Char] = {
+    val set = legal.toSet
+    charClass(set, "character in '" + legal + "'") examples (set.map(_.toString))
+  }
+
+  /**
+   * Defines a Parser that parses a single character only if the predicate `f` returns true for that character.
+   * If this parser fails, `label` is used as the failure message.
+   */
+  def charClass(f: Char => Boolean, label: String = "<unspecified>"): Parser[Char] =
+    new CharacterClass(f, label)
+
+  /** Presents a single Char `ch` as a Parser that only parses that exact character. */
+  implicit def literal(ch: Char): Parser[Char] = new ValidParser[Char] {
+    def result = None
+    def resultEmpty = mkFailure("Expected '" + ch + "'")
+    def derive(c: Char) = if (c == ch) success(ch) else new Invalid(resultEmpty)
+    def completions(level: Int) = Completions.single(Completion.suggestion(ch.toString))
+    override def toString = "'" + ch + "'"
+  }
+
+  /** Presents a literal String `s` as a Parser that only parses that exact text and provides it as the result.*/
+  implicit def literal(s: String): Parser[String] = stringLiteral(s, 0)
+
+  /** See [[unapply]]. */
+  object ~ {
+
+    /** Convenience for destructuring a tuple that mirrors the `~` combinator.*/
+    def unapply[A, B](t: (A, B)): Some[(A, B)] = Some(t)
+
+  }
+
+  /** Parses input `str` using `parser`.  If successful, the result is provided wrapped in `Right`.  If unsuccessful, an error message is provided in `Left`.*/
+  def parse[T](str: String, parser: Parser[T]): Either[String, T] =
+    Parser.result(parser, str).left.map { failures =>
+      val (msgs, pos) = failures()
+      ProcessError(str, msgs, pos)
+    }
+
+  /**
+   * Convenience method to use when developing a parser.
+   * `parser` is applied to the input `str`.
+   * If `completions` is true, the available completions for the input are displayed.
+   * Otherwise, the result of parsing is printed using the result's `toString` method.
+   * If parsing fails, the error message is displayed.
+   *
+   * See also [[sampleParse]] and [[sampleCompletions]].
+   */
+  def sample(str: String, parser: Parser[_], completions: Boolean = false): Unit =
+    if (completions) sampleCompletions(str, parser) else sampleParse(str, parser)
+
+  /**
+   * Convenience method to use when developing a parser.
+   * `parser` is applied to the input `str` and the result of parsing is printed using the result's `toString` method.
+   * If parsing fails, the error message is displayed.
+   */
+  def sampleParse(str: String, parser: Parser[_]): Unit =
+    parse(str, parser) match {
+      case Left(msg) => println(msg)
+      case Right(v)  => println(v)
+    }
+
+  /**
+   * Convenience method to use when developing a parser.
+   * `parser` is applied to the input `str` and the available completions are displayed on separate lines.
+   * If parsing fails, the error message is displayed.
+   */
+  def sampleCompletions(str: String, parser: Parser[_], level: Int = 1): Unit =
+    Parser.completions(parser, str, level).get foreach println
+
+  // intended to be temporary pending proper error feedback
+  def result[T](p: Parser[T], s: String): Either[() => (Seq[String], Int), T] = {
+    def loop(i: Int, a: Parser[T]): Either[() => (Seq[String], Int), T] =
+      a match {
+        case Invalid(f) => Left(() => (f.errors, i))
+        case _ =>
+          val ci = i + 1
+          if (ci >= s.length)
+            a.resultEmpty.toEither.left.map { msgs0 => () =>
+              val msgs = msgs0()
+              val nonEmpty = if (msgs.isEmpty) Seq("Unexpected end of input") else msgs
+              (nonEmpty, ci)
+            } else
+            loop(ci, a derive s(ci))
+      }
+    loop(-1, p)
+  }
+
+  /** Applies parser `p` to input `s`. */
+  def apply[T](p: Parser[T])(s: String): Parser[T] =
+    s.foldLeft(p)(derive1)
+
+  /** Applies parser `p` to a single character of input. */
+  def derive1[T](p: Parser[T], c: Char): Parser[T] =
+    if (p.valid) p.derive(c) else p
+
+  /**
+   * Applies parser `p` to input `s` and returns the completions at verbosity `level`.
+   * The interpretation of `level` is up to parser definitions, but 0 is the default by convention,
+   * with increasing positive numbers corresponding to increasing verbosity.  Typically no more than
+   * a few levels are defined.
+   */
+  def completions(p: Parser[_], s: String, level: Int): Completions =
+    // The x Completions.empty removes any trailing token completions where append.isEmpty
+    apply(p)(s).completions(level) x Completions.empty
+
+  def examples[A](a: Parser[A], completions: Set[String], check: Boolean = false): Parser[A] =
+    examples(a, new FixedSetExamples(completions), completions.size, check)
+
+  /**
+   * @param a the parser to decorate with a source of examples. All validation and parsing is delegated to this parser,
+   *          only [[Parser.completions]] is modified.
+   * @param completions the source of examples when displaying completions to the user.
+   * @param maxNumberOfExamples limits the number of examples that the source of examples should return. This can
+   *                            prevent lengthy pauses and avoids bad interactive user experience.
+   * @param removeInvalidExamples indicates whether completion examples should be checked for validity (against the given parser). An
+   *                              exception is thrown if the example source contains no valid completion suggestions.
+   * @tparam A the type of values that are returned by the parser.
+   * @return
+   */
+  def examples[A](
+      a: Parser[A],
+      completions: ExampleSource,
+      maxNumberOfExamples: Int,
+      removeInvalidExamples: Boolean
+  ): Parser[A] =
+    if (a.valid) {
+      a.result match {
+        case Some(av) => success(av)
+        case None =>
+          new ParserWithExamples(a, completions, maxNumberOfExamples, removeInvalidExamples)
+      }
+    } else a
+
+  def matched(
+      t: Parser[_],
+      seen: Vector[Char] = Vector.empty,
+      partial: Boolean = false
+  ): Parser[String] =
+    t match {
+      case i: Invalid => if (partial && seen.nonEmpty) success(seen.mkString) else i
+      case _ =>
+        if (t.result.isEmpty)
+          new MatchedString(t, seen, partial)
+        else
+          success(seen.mkString)
+    }
+
+  /**
+   * Establishes delegate parser `t` as a single token of tab completion.
+   * When tab completion of part of this token is requested, the completions provided by the delegate `t` or a later derivative are appended to
+   * the prefix String already seen by this parser.
+   */
+  def token[T](t: Parser[T]): Parser[T] = token(t, TokenCompletions.default)
+
+  /**
+   * Establishes delegate parser `t` as a single token of tab completion.
+   * When tab completion of part of this token is requested, no completions are returned if `hide` returns true for the current tab completion level.
+   * Otherwise, the completions provided by the delegate `t` or a later derivative are appended to the prefix String already seen by this parser.
+   */
+  def token[T](t: Parser[T], hide: Int => Boolean): Parser[T] =
+    token(t, TokenCompletions.default.hideWhen(hide))
+
+  /**
+   * Establishes delegate parser `t` as a single token of tab completion.
+   * When tab completion of part of this token is requested, `description` is displayed for suggestions and no completions are ever performed.
+   */
+  def token[T](t: Parser[T], description: String): Parser[T] =
+    token(t, TokenCompletions.displayOnly(description))
+
+  /**
+   * Establishes delegate parser `t` as a single token of tab completion.
+   * When tab completion of part of this token is requested, `display` is used as the printed suggestion, but the completions from the delegate
+   * parser `t` are used to complete if unambiguous.
+   */
+  def tokenDisplay[T](t: Parser[T], display: String): Parser[T] =
+    token(t, TokenCompletions.overrideDisplay(display))
+
+  def token[T](t: Parser[T], complete: TokenCompletions): Parser[T] =
+    mkToken(t, "", complete)
+
+  private[sbt] def mkToken[T](t: Parser[T], seen: String, complete: TokenCompletions): Parser[T] =
+    if (t.valid && !t.isTokenStart)
+      if (t.result.isEmpty) new TokenStart(t, seen, complete) else t
+    else
+      t
+
+  def homParser[A](a: Parser[A], b: Parser[A]): Parser[A] = (a, b) match {
+    case (Invalid(af), Invalid(bf)) => Invalid(af ++ bf)
+    case (Invalid(_), bv)           => bv
+    case (av, Invalid(_))           => av
+    case (_, _)                     => new HomParser(a, b)
+  }
+
+  def not(p: Parser[_], failMessage: String): Parser[Unit] = p.result match {
+    case None    => new Not(p, failMessage)
+    case Some(_) => failure(failMessage)
+  }
+
+  def oneOf[T](p: Seq[Parser[T]]): Parser[T] = p.reduceLeft(_ | _)
+  def seq[T](p: Seq[Parser[T]]): Parser[Seq[T]] = seq0(p, Nil)
+
+  def seq0[T](p: Seq[Parser[T]], errors: => Seq[String]): Parser[Seq[T]] = {
+    val (newErrors, valid) = separate(p) {
+      case Invalid(f) => Left(f.errors _): Either[() => Seq[String], Parser[T]]
+      case ok         => Right(ok): Either[() => Seq[String], Parser[T]]
+    }
+    def combinedErrors = errors ++ newErrors.flatMap(_())
+    if (valid.isEmpty) invalid(combinedErrors) else new ParserSeq(valid, combinedErrors)
+  }
+
+  def stringLiteral(s: String, start: Int): Parser[String] = {
+    val len = s.length
+    if (len == 0) sys.error("String literal cannot be empty")
+    else if (start >= len) success(s)
+    else new StringLiteral(s, start)
+  }
+}
+
+sealed trait ValidParser[T] extends Parser[T] {
+  final def valid = true
+  final def failure = None
+  final def ifValid[S](p: => Parser[S]): Parser[S] = p
+}
+
+private final case class Invalid(fail: Failure) extends Parser[Nothing] {
+  def failure = Some(fail)
+  def result = None
+  def resultEmpty = fail
+  def derive(c: Char) = sys.error("Invalid.")
+  def completions(level: Int) = Completions.nil
+  override def toString = fail.errors.mkString("; ")
+  def valid = false
+  def ifValid[S](p: => Parser[S]): Parser[S] = this
+}
+
+private final case class SoftInvalid(fail: Failure) extends ValidParser[Nothing] {
+  def result = None
+  def resultEmpty = fail
+  def derive(c: Char) = Invalid(fail)
+  def completions(level: Int) = Completions.nil
+  override def toString = fail.errors.mkString("; ")
+}
+
+private final class TrapAndFail[A](a: Parser[A]) extends ValidParser[A] {
+  def result =
+    try {
+      a.result
+    } catch { case _: Exception => None }
+  def resultEmpty =
+    try {
+      a.resultEmpty
+    } catch { case e: Exception => fail(e) }
+
+  def derive(c: Char) =
+    try {
+      trapAndFail(a derive c)
+    } catch {
+      case e: Exception => Invalid(fail(e))
+    }
+
+  def completions(level: Int) =
+    try {
+      a.completions(level)
+    } catch {
+      case _: Exception => Completions.nil
+    }
+
+  override def toString = "trap(" + a + ")"
+  override def isTokenStart = a.isTokenStart
+  private[this] def fail(e: Exception): Failure = mkFailure(e.toString)
+}
+
+private final class OnFailure[A](a: Parser[A], message: String) extends ValidParser[A] {
+  def result = a.result
+
+  def resultEmpty = a.resultEmpty match {
+    case _: Failure => mkFailure(message); case v: Value[A] => v
+  }
+
+  def derive(c: Char) = onFailure(a derive c, message)
+  def completions(level: Int) = a.completions(level)
+  override def toString = "(" + a + " !!! \"" + message + "\" )"
+  override def isTokenStart = a.isTokenStart
+}
+
+private final class SeqParser[A, B](a: Parser[A], b: Parser[B]) extends ValidParser[(A, B)] {
+  lazy val result = tuple(a.result, b.result)
+  lazy val resultEmpty = a.resultEmpty seq b.resultEmpty
+
+  def derive(c: Char) = {
+    val common = a.derive(c) ~ b
+    a.resultEmpty match {
+      case Value(av)  => common | b.derive(c).map(br => (av, br))
+      case _: Failure => common
+    }
+  }
+
+  def completions(level: Int) = a.completions(level) x b.completions(level)
+  override def toString = "(" + a + " ~ " + b + ")"
+}
+
+private final class HomParser[A](a: Parser[A], b: Parser[A]) extends ValidParser[A] {
+  lazy val result = tuple(a.result, b.result) map (_._1)
+  def derive(c: Char) = (a derive c) | (b derive c)
+  lazy val resultEmpty = a.resultEmpty or b.resultEmpty
+  def completions(level: Int) = a.completions(level) ++ b.completions(level)
+  override def toString = "(" + a + " | " + b + ")"
+}
+
+private final class HetParser[A, B](a: Parser[A], b: Parser[B]) extends ValidParser[Either[A, B]] {
+  lazy val result = tuple(a.result, b.result) map { case (a, _) => Left(a) }
+  def derive(c: Char) = (a derive c) || (b derive c)
+  lazy val resultEmpty = a.resultEmpty either b.resultEmpty
+  def completions(level: Int) = a.completions(level) ++ b.completions(level)
+  override def toString = "(" + a + " || " + b + ")"
+}
+
+private final class ParserSeq[T](a: Seq[Parser[T]], errors: => Seq[String])
+    extends ValidParser[Seq[T]] {
+  assert(a.nonEmpty)
+
+  lazy val resultEmpty: Result[Seq[T]] = {
+    val res = a.map(_.resultEmpty)
+    val (failures, values) = separate(res)(_.toEither)
+    //    if(failures.isEmpty) Value(values) else mkFailures(failures.flatMap(_()) ++ errors)
+    if (values.nonEmpty) Value(values) else mkFailures(failures.flatMap(_()) ++ errors)
+  }
+
+  def result = {
+    val success = a.flatMap(_.result)
+    if (success.length == a.length) Some(success) else None
+  }
+
+  def completions(level: Int) = a.map(_.completions(level)).reduceLeft(_ ++ _)
+  def derive(c: Char) = seq0(a.map(_ derive c), errors)
+
+  override def toString = "seq(" + a + ")"
+}
+
+private final class BindParser[A, B](a: Parser[A], f: A => Parser[B]) extends ValidParser[B] {
+  lazy val result = a.result flatMap (av => f(av).result)
+  lazy val resultEmpty = a.resultEmpty flatMap (av => f(av).resultEmpty)
+
+  def completions(level: Int) =
+    a.completions(level) flatMap { c =>
+      apply(a)(c.append).resultEmpty match {
+        case _: Failure => Completions.strict(Set.empty + c)
+        case Value(av)  => c x f(av).completions(level)
+      }
+    }
+
+  def derive(c: Char) = {
+    val common = a derive c flatMap f
+    a.resultEmpty match {
+      case Value(av)  => common | derive1(f(av), c)
+      case _: Failure => common
+    }
+  }
+
+  override def isTokenStart = a.isTokenStart
+
+  override def toString = "bind(" + a + ")"
+}
+
+private final class MapParser[A, B](a: Parser[A], f: A => B) extends ValidParser[B] {
+  lazy val result = a.result map f
+  lazy val resultEmpty = a.resultEmpty map f
+  def derive(c: Char) = (a derive c) map f
+  def completions(level: Int) = a.completions(level)
+  override def isTokenStart = a.isTokenStart
+  override def toString = "map(" + a + ")"
+  def map[C](g: B => C) = new MapParser[A, C](a, f.andThen(g))
+}
+
+private final class Filter[T](p: Parser[T], f: T => Boolean, seen: String, msg: String => String)
+    extends ValidParser[T] {
+  def filterResult(r: Result[T]) = r.filter(f, msg(seen))
+  lazy val result = p.result filter f
+  lazy val resultEmpty = filterResult(p.resultEmpty)
+  def derive(c: Char) = filterParser(p derive c, f, seen + c, msg)
+
+  def completions(level: Int) = p.completions(level) filterS { s =>
+    filterResult(apply(p)(s).resultEmpty).isValid
+  }
+
+  override def toString = "filter(" + p + ")"
+  override def isTokenStart = p.isTokenStart
+}
+
+private final class MatchedString(delegate: Parser[_], seenV: Vector[Char], partial: Boolean)
+    extends ValidParser[String] {
+  lazy val seen = seenV.mkString
+  def derive(c: Char) = matched(delegate derive c, seenV :+ c, partial)
+  def completions(level: Int) = delegate.completions(level)
+  def result = if (delegate.result.isDefined) Some(seen) else None
+
+  def resultEmpty = delegate.resultEmpty match {
+    case f: Failure if !partial => f; case _ => Value(seen)
+  }
+
+  override def isTokenStart = delegate.isTokenStart
+  override def toString = "matched(" + partial + ", " + seen + ", " + delegate + ")"
+}
+
+private final class TokenStart[T](delegate: Parser[T], seen: String, complete: TokenCompletions)
+    extends ValidParser[T] {
+  def derive(c: Char) = mkToken(delegate derive c, seen + c, complete)
+
+  def completions(level: Int) = complete match {
+    case dc: TokenCompletions.Delegating =>
+      dc.completions(seen, level, delegate.completions(level))
+    case fc: TokenCompletions.Fixed => fc.completions(seen, level)
+  }
+
+  def result = delegate.result
+  def resultEmpty = delegate.resultEmpty
+  override def isTokenStart = true
+  override def toString = "token('" + complete + ", " + delegate + ")"
+}
+
+private final class And[T](a: Parser[T], b: Parser[_]) extends ValidParser[T] {
+  lazy val result = tuple(a.result, b.result) map { _._1 }
+  def derive(c: Char) = (a derive c) & (b derive c)
+  def completions(level: Int) = a.completions(level).filterS(s => apply(b)(s).resultEmpty.isValid)
+  lazy val resultEmpty = a.resultEmpty && b.resultEmpty
+  override def toString = "(%s) && (%s)".format(a, b)
+}
+
+private final class Not(delegate: Parser[_], failMessage: String) extends ValidParser[Unit] {
+  def derive(c: Char) = if (delegate.valid) not(delegate derive c, failMessage) else this
+  def completions(level: Int) = Completions.empty
+  def result = None
+
+  lazy val resultEmpty = delegate.resultEmpty match {
+    case _: Failure  => Value(())
+    case _: Value[_] => mkFailure(failMessage)
+  }
+
+  override def toString = " -(%s)".format(delegate)
+}
+
+/**
+ * This class wraps an existing parser (the delegate), and replaces the delegate's completions with examples from
+ * the given example source.
+ *
+ * This class asks the example source for a limited amount of examples (to prevent lengthy and expensive
+ * computations and large amounts of allocated data). It then passes these examples on to the UI.
+ *
+ * @param delegate the parser to decorate with completion examples (i.e., completion of user input).
+ * @param exampleSource the source from which this class will take examples (potentially filter them with the delegate
+ *                      parser), and pass them to the UI.
+ * @param maxNumberOfExamples the maximum number of completions to read from the example source and pass to the UI. This
+ *                            limit prevents lengthy example generation and allocation of large amounts of memory.
+ * @param removeInvalidExamples indicates whether to remove examples that are deemed invalid by the delegate parser.
+ * @tparam T the type of value produced by the parser.
+ */
+private final class ParserWithExamples[T](
+    delegate: Parser[T],
+    exampleSource: ExampleSource,
+    maxNumberOfExamples: Int,
+    removeInvalidExamples: Boolean
+) extends ValidParser[T] {
+
+  def derive(c: Char) =
+    examples(
+      delegate derive c,
+      exampleSource.withAddedPrefix(c.toString),
+      maxNumberOfExamples,
+      removeInvalidExamples
+    )
+
+  def result = delegate.result
+
+  lazy val resultEmpty = delegate.resultEmpty
+
+  def completions(level: Int) = {
+    if (exampleSource().isEmpty)
+      if (resultEmpty.isValid) Completions.nil else Completions.empty
+    else {
+      val examplesBasedOnTheResult = filteredExamples.take(maxNumberOfExamples).toSet
+      Completions(examplesBasedOnTheResult.map(ex => Completion.suggestion(ex)))
+    }
+  }
+
+  override def toString = "examples(" + delegate + ", " + exampleSource().take(2).toList + ")"
+
+  private def filteredExamples: Iterable[String] = {
+    if (removeInvalidExamples)
+      exampleSource().filter(isExampleValid)
+    else
+      exampleSource()
+  }
+
+  private def isExampleValid(example: String): Boolean = {
+    apply(delegate)(example).resultEmpty.isValid
+  }
+}
+
+private final class StringLiteral(str: String, start: Int) extends ValidParser[String] {
+  assert(0 <= start && start < str.length)
+
+  def failMsg = "Expected '" + str + "'"
+  def resultEmpty = mkFailure(failMsg)
+  def result = None
+
+  def derive(c: Char) =
+    if (str.charAt(start) == c) stringLiteral(str, start + 1) else new Invalid(resultEmpty)
+
+  def completions(level: Int) = Completions.single(Completion.suggestion(str.substring(start)))
+  override def toString = '"' + str + '"'
+}
+
+private final class CharacterClass(f: Char => Boolean, label: String) extends ValidParser[Char] {
+  def result = None
+  def resultEmpty = mkFailure("Expected " + label)
+  def derive(c: Char) = if (f(c)) success(c) else Invalid(resultEmpty)
+  def completions(level: Int) = Completions.empty
+  override def toString = "class(" + label + ")"
+}
+
+private final class Optional[T](delegate: Parser[T]) extends ValidParser[Option[T]] {
+  def result = delegate.result map some.fn
+  def resultEmpty = Value(None)
+  def derive(c: Char) = (delegate derive c).map(some.fn)
+  def completions(level: Int) = Completion.empty +: delegate.completions(level)
+  override def toString = delegate.toString + "?"
+}
+
+private final class Repeat[T](
+    partial: Option[Parser[T]],
+    repeated: Parser[T],
+    min: Int,
+    max: UpperBound,
+    accumulatedReverse: List[T]
+) extends ValidParser[Seq[T]] {
+  assume(0 <= min, "Minimum occurrences must be non-negative")
+  assume(max >= min, "Minimum occurrences must be less than the maximum occurrences")
+
+  def derive(c: Char) =
+    partial match {
+      case Some(part) =>
+        val partD = repeat(Some(part derive c), repeated, min, max, accumulatedReverse)
+        part.resultEmpty match {
+          case Value(pv)  => partD | repeatDerive(c, pv :: accumulatedReverse)
+          case _: Failure => partD
+        }
+      case None => repeatDerive(c, accumulatedReverse)
+    }
+
+  def repeatDerive(c: Char, accRev: List[T]): Parser[Seq[T]] =
+    repeat(Some(repeated derive c), repeated, scala.math.max(0, min - 1), max.decrement, accRev)
+
+  def completions(level: Int) = {
+    def pow(comp: Completions, exp: Completions, n: Int): Completions =
+      if (n == 1) comp else pow(comp x exp, exp, n - 1)
+
+    val repC = repeated.completions(level)
+    val fin = if (min == 0) Completion.empty +: repC else pow(repC, repC, min)
+    partial match {
+      case Some(p) => p.completions(level) x fin
+      case None    => fin
+    }
+  }
+
+  def result = None
+
+  lazy val resultEmpty: Result[Seq[T]] = {
+    val partialAccumulatedOption =
+      partial match {
+        case None => (Value(accumulatedReverse): Result[List[T]])
+        case Some(partialPattern) =>
+          partialPattern.resultEmpty.map(_ :: accumulatedReverse)
+      }
+    (partialAccumulatedOption app repeatedParseEmpty)((x, y) => (x reverse_::: y): Seq[T])
+  }
+
+  private def repeatedParseEmpty: Result[List[T]] = {
+    if (min == 0)
+      Value(Nil)
+    else
+      // forced determinism
+      for (value <- repeated.resultEmpty) yield makeList(min, value)
+  }
+
+  override def toString = "repeat(" + min + "," + max + "," + partial + "," + repeated + ")"
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parsers.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parsers.scala
new file mode 100644
index 000000000..651ddd8d0
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/Parsers.scala
@@ -0,0 +1,364 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import Parser._
+import java.io.File
+import java.net.URI
+import java.lang.Character.{
+  CURRENCY_SYMBOL,
+  DASH_PUNCTUATION,
+  MATH_SYMBOL,
+  MODIFIER_SYMBOL,
+  OTHER_PUNCTUATION,
+  OTHER_SYMBOL,
+  getType
+}
+
+import scala.annotation.tailrec
+import sbt.internal.util.Util.nilSeq
+
+/** Provides standard implementations of commonly useful [[Parser]]s. */
+trait Parsers {
+
+  /** Matches the end of input, providing no useful result on success. */
+  lazy val EOF = not(any, "Expected EOF")
+
+  /** Parses any single character and provides that character as the result. */
+  lazy val any: Parser[Char] = charClass(_ => true, "any character")
+
+  /** Set that contains each digit in a String representation.*/
+  lazy val DigitSet = Set("0", "1", "2", "3", "4", "5", "6", "7", "8", "9")
+
+  /** Parses any single digit and provides that digit as a Char as the result.*/
+  lazy val Digit = charClass(_.isDigit, "digit") examples DigitSet
+
+  /** Set containing Chars for hexadecimal digits 0-9 and A-F (but not a-f). */
+  lazy val HexDigitSet =
+    Set('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F')
+
+  /** Parses a single hexadecimal digit (0-9, a-f, A-F). */
+  lazy val HexDigit = charClass(c => HexDigitSet(c.toUpper), "hex digit") examples HexDigitSet.map(
+    _.toString
+  )
+
+  /** Parses a single letter, according to Char.isLetter, into a Char. */
+  lazy val Letter = charClass(_.isLetter, "letter")
+
+  /** Parses a single letter, according to Char.isUpper, into a Char. */
+  lazy val Upper = charClass(_.isUpper, "upper")
+
+  /** Parses a single letter, according to Char.isLower, into a Char. */
+  lazy val Lower = charClass(_.isLower, "lower")
+
+  /** Parses the first Char in an sbt identifier, which must be a [[Letter]].*/
+  def IDStart = Letter
+
+  /** Parses an identifier Char other than the first character.  This includes letters, digits, dash `-`, and underscore `_`.*/
+  lazy val IDChar = charClass(isIDChar, "ID character")
+
+  /** Parses an identifier String, which must start with [[IDStart]] and contain zero or more [[IDChar]]s after that. */
+  lazy val ID = identifier(IDStart, IDChar)
+
+  /** Parses a single operator Char, as allowed by [[isOpChar]]. */
+  lazy val OpChar = charClass(isOpChar, "symbol")
+
+  /** Parses a non-empty operator String, which consists only of characters allowed by [[OpChar]]. */
+  lazy val Op = OpChar.+.string
+
+  /** Parses either an operator String defined by [[Op]] or a non-symbolic identifier defined by [[ID]]. */
+  lazy val OpOrID = ID | Op
+
+  /** Parses a single, non-symbolic Scala identifier Char.  Valid characters are letters, digits, and the underscore character `_`. */
+  lazy val ScalaIDChar = charClass(isScalaIDChar, "Scala identifier character")
+
+  /** Parses a non-symbolic Scala-like identifier.  The identifier must start with [[IDStart]] and contain zero or more [[ScalaIDChar]]s after that.*/
+  lazy val ScalaID = identifier(IDStart, ScalaIDChar)
+
+  /** Parses a non-symbolic Scala-like identifier.  The identifier must start with [[Upper]] and contain zero or more [[ScalaIDChar]]s after that.*/
+  lazy val CapitalizedID = identifier(Upper, ScalaIDChar)
+
+  /** Parses a String that starts with `start` and is followed by zero or more characters parsed by `rep`.*/
+  def identifier(start: Parser[Char], rep: Parser[Char]): Parser[String] =
+    start ~ rep.* map { case x ~ xs => (x +: xs).mkString }
+
+  def opOrIDSpaced(s: String): Parser[Char] =
+    if (DefaultParsers.matches(ID, s))
+      OpChar | SpaceClass
+    else if (DefaultParsers.matches(Op, s))
+      IDChar | SpaceClass
+    else
+      any
+
+  /** Returns true if `c` an operator character. */
+  def isOpChar(c: Char) = !isDelimiter(c) && isOpType(getType(c))
+
+  def isOpType(cat: Int) = cat match {
+    case MATH_SYMBOL | OTHER_SYMBOL | DASH_PUNCTUATION | OTHER_PUNCTUATION | MODIFIER_SYMBOL |
+        CURRENCY_SYMBOL =>
+      true; case _      => false
+  }
+
+  /** Returns true if `c` is a dash `-`, a letter, digit, or an underscore `_`. */
+  def isIDChar(c: Char) = isScalaIDChar(c) || c == '-'
+
+  /** Returns true if `c` is a letter, digit, or an underscore `_`. */
+  def isScalaIDChar(c: Char) = c.isLetterOrDigit || c == '_'
+
+  def isDelimiter(c: Char) = c match {
+    case '`' | '\'' | '\"' | /*';' | */ ',' | '.' => true; case _ => false
+  }
+
+  /** Matches a single character that is not a whitespace character. */
+  lazy val NotSpaceClass = charClass(!_.isWhitespace, "non-whitespace character")
+
+  /** Matches a single whitespace character, as determined by Char.isWhitespace.*/
+  lazy val SpaceClass = charClass(_.isWhitespace, "whitespace character")
+
+  /** Matches a non-empty String consisting of non-whitespace characters. */
+  lazy val NotSpace = NotSpaceClass.+.string
+
+  /** Matches a possibly empty String consisting of non-whitespace characters. */
+  lazy val OptNotSpace = NotSpaceClass.*.string
+
+  /**
+   * Matches a non-empty String consisting of whitespace characters.
+   * The suggested tab completion is a single, constant space character.
+   */
+  lazy val Space: Parser[Seq[Char]] = SpaceClass.+.examples(" ")
+
+  /**
+   * Matches a possibly empty String consisting of whitespace characters.
+   * The suggested tab completion is a single, constant space character.
+   */
+  lazy val OptSpace = SpaceClass.*.examples(" ")
+
+  /** Parses a non-empty String that contains only valid URI characters, as defined by [[URIChar]].*/
+  lazy val URIClass = URIChar.+.string !!! "Invalid URI"
+
+  /** Triple-quotes, as used for verbatim quoting.*/
+  lazy val VerbatimDQuotes = "\"\"\""
+
+  /** Double quote character. */
+  lazy val DQuoteChar = '\"'
+
+  /** Backslash character. */
+  lazy val BackslashChar = '\\'
+
+  /** Matches a single double quote. */
+  lazy val DQuoteClass = charClass(_ == DQuoteChar, "double-quote character")
+
+  /** Matches any character except a double quote or whitespace. */
+  lazy val NotDQuoteSpaceClass =
+    charClass({ c: Char =>
+      (c != DQuoteChar) && !c.isWhitespace
+    }, "non-double-quote-space character")
+
+  /** Matches any character except a double quote or backslash. */
+  lazy val NotDQuoteBackslashClass =
+    charClass({ c: Char =>
+      (c != DQuoteChar) && (c != BackslashChar)
+    }, "non-double-quote-backslash character")
+
+  /** Matches a single character that is valid somewhere in a URI. */
+  lazy val URIChar = charClass(alphanum, "alphanum") | chars("_-!.~'()*,;:$&+=?/[]@%#")
+
+  /** Returns true if `c` is an ASCII letter or digit. */
+  def alphanum(c: Char) =
+    ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9')
+
+  /**
+   * @param base the directory used for completion proposals (when the user presses the TAB key). Only paths under this
+   *             directory will be proposed.
+   * @return the file that was parsed from the input string. The returned path may or may not exist.
+   */
+  def fileParser(base: File): Parser[File] =
+    OptSpace ~> StringBasic
+      .examples(new FileExamples(base))
+      .map(new File(_))
+
+  /** Parses a port number.  Currently, this accepts any integer and presents a tab completion suggestion of `<port>`. */
+  lazy val Port = token(IntBasic, "<port>")
+
+  /** Parses a signed integer. */
+  lazy val IntBasic = mapOrFail('-'.? ~ Digit.+)(Function.tupled(toInt))
+
+  /** Parses an unsigned integer. */
+  lazy val NatBasic = mapOrFail(Digit.+)(_.mkString.toInt)
+
+  private[this] def toInt(neg: Option[Char], digits: Seq[Char]): Int =
+    (neg.toSeq ++ digits).mkString.toInt
+
+  /** Parses the lower-case values `true` and `false` into their corresponding Boolean values.  */
+  lazy val Bool = ("true" ^^^ true) | ("false" ^^^ false)
+
+  /**
+   * Parses a potentially quoted String value.  The value may be verbatim quoted ([[StringVerbatim]]),
+   * quoted with interpreted escapes ([[StringEscapable]]), or unquoted ([[NotQuoted]]).
+   */
+  lazy val StringBasic = StringVerbatim | StringEscapable | NotQuoted
+
+  /**
+   * Parses a verbatim quoted String value, discarding the quotes in the result.  This kind of quoted text starts with triple quotes `"""`
+   * and ends at the next triple quotes and may contain any character in between.
+   */
+  lazy val StringVerbatim: Parser[String] = VerbatimDQuotes ~>
+    any.+.string.filter(!_.contains(VerbatimDQuotes), _ => "Invalid verbatim string") <~
+    VerbatimDQuotes
+
+  /**
+   * Parses a string value, interpreting escapes and discarding the surrounding quotes in the result.
+   * See [[EscapeSequence]] for supported escapes.
+   */
+  lazy val StringEscapable: Parser[String] =
+    (DQuoteChar ~> (NotDQuoteBackslashClass | EscapeSequence).+.string <~ DQuoteChar |
+      (DQuoteChar ~ DQuoteChar) ^^^ "")
+
+  /**
+   * Parses a size unit string. For example, `128K` parsers to `128L * 1024`, and `1.25g` parses
+   * to `1024L * 1024 * 1024 * 5 / 4`.
+   */
+  lazy val Size: Parser[Long] = SizeParser.value
+
+  /**
+   * Parses a brace enclosed string and, if each opening brace is matched with a closing brace,
+   * it returns the entire string including the braces.
+   *
+   * @param open the opening character, e.g. '{'
+   * @param close the closing character, e.g. '}'
+   * @return a parser for the brace encloosed string.
+   */
+  private[sbt] def braces(open: Char, close: Char): Parser[String] = {
+    val notDelim = charClass(c => c != open && c != close).*.string
+    def impl(): Parser[String] = {
+      (open ~ (notDelim ~ close).?).flatMap {
+        case (l, Some((content, r))) => Parser.success(l + content + r)
+        case (l, None) =>
+          ((notDelim ~ impl()).map {
+            case (leftPrefix, nestedBraces) => leftPrefix + nestedBraces
+          }.+ ~ notDelim ~ close).map {
+            case ((nested, suffix), r) => l + nested.mkString + suffix + r
+          }
+      }
+    }
+    impl()
+  }
+
+  /**
+   * Parses a single escape sequence into the represented Char.
+   * Escapes start with a backslash and are followed by `u` for a [[UnicodeEscape]] or by `b`, `t`, `n`, `f`, `r`, `"`, `'`, `\` for standard escapes.
+   */
+  lazy val EscapeSequence: Parser[Char] =
+    BackslashChar ~> ('b' ^^^ '\b' | 't' ^^^ '\t' | 'n' ^^^ '\n' | 'f' ^^^ '\f' | 'r' ^^^ '\r' |
+      '\"' ^^^ '\"' | '\'' ^^^ '\'' | '\\' ^^^ '\\' | UnicodeEscape)
+
+  /**
+   * Parses a single unicode escape sequence into the represented Char.
+   * A unicode escape begins with a backslash, followed by a `u` and 4 hexadecimal digits representing the unicode value.
+   */
+  lazy val UnicodeEscape: Parser[Char] =
+    ("u" ~> repeat(HexDigit, 4, 4)) map { seq =>
+      Integer.parseInt(seq.mkString, 16).toChar
+    }
+
+  /** Parses an unquoted, non-empty String value that cannot start with a double quote and cannot contain whitespace.*/
+  lazy val NotQuoted = (NotDQuoteSpaceClass ~ OptNotSpace) map { case (c, s) => c.toString + s }
+
+  /**
+   * Applies `rep` zero or more times, separated by `sep`.
+   * The result is the (possibly empty) sequence of results from the multiple `rep` applications.  The `sep` results are discarded.
+   */
+  def repsep[T](rep: Parser[T], sep: Parser[_]): Parser[Seq[T]] =
+    rep1sep(rep, sep) ?? nilSeq[T]
+
+  /**
+   * Applies `rep` one or more times, separated by `sep`.
+   * The result is the non-empty sequence of results from the multiple `rep` applications.  The `sep` results are discarded.
+   */
+  def rep1sep[T](rep: Parser[T], sep: Parser[_]): Parser[Seq[T]] =
+    (rep ~ (sep ~> rep).*).map { case (x ~ xs) => x +: xs }
+
+  /** Wraps the result of `p` in `Some`.*/
+  def some[T](p: Parser[T]): Parser[Option[T]] = p map { v =>
+    Some(v)
+  }
+
+  /**
+   * Applies `f` to the result of `p`, transforming any exception when evaluating
+   * `f` into a parse failure with the exception `toString` as the message.
+   */
+  def mapOrFail[S, T](p: Parser[S])(f: S => T): Parser[T] =
+    p flatMap { s =>
+      try {
+        success(f(s))
+      } catch { case e: Exception => failure(e.toString) }
+    }
+
+  /**
+   * Parses a space-delimited, possibly empty sequence of arguments.
+   * The arguments may use quotes and escapes according to [[StringBasic]].
+   */
+  def spaceDelimited(display: String): Parser[Seq[String]] =
+    (token(Space) ~> token(StringBasic, display)).* <~ SpaceClass.*
+
+  /** Applies `p` and uses `true` as the result if it succeeds and turns failure into a result of `false`. */
+  def flag[T](p: Parser[T]): Parser[Boolean] = (p ^^^ true) ?? false
+
+  /**
+   * Defines a sequence parser where the parser used for each part depends on the previously parsed values.
+   * `p` is applied to the (possibly empty) sequence of already parsed values to obtain the next parser to use.
+   * The parsers obtained in this way are separated by `sep`, whose result is discarded and only the sequence
+   * of values from the parsers returned by `p` is used for the result.
+   */
+  def repeatDep[A](p: Seq[A] => Parser[A], sep: Parser[Any]): Parser[Seq[A]] = {
+    def loop(acc: Seq[A]): Parser[Seq[A]] = {
+      val next = (sep ~> p(acc)) flatMap { result =>
+        loop(acc :+ result)
+      }
+      next ?? acc
+    }
+    p(Vector()) flatMap { first =>
+      loop(Seq(first))
+    }
+  }
+
+  /** Applies String.trim to the result of `p`. */
+  def trimmed(p: Parser[String]) = p map { _.trim }
+
+  /** Parses a URI that is valid according to the single argument java.net.URI constructor. */
+  lazy val basicUri = mapOrFail(URIClass)(uri => new URI(uri))
+
+  /** Parses a URI that is valid according to the single argument java.net.URI constructor, using `ex` as tab completion examples. */
+  def Uri(ex: Set[URI]) = basicUri examples (ex.map(_.toString))
+}
+
+/** Provides standard [[Parser]] implementations. */
+object Parsers extends Parsers
+
+/** Provides common [[Parser]] implementations and helper methods.*/
+object DefaultParsers extends Parsers with ParserMain {
+
+  /** Applies parser `p` to input `s` and returns `true` if the parse was successful. */
+  def matches(p: Parser[_], s: String): Boolean =
+    apply(p)(s).resultEmpty.isValid
+
+  /** Returns `true` if `s` parses successfully according to [[ID]].*/
+  def validID(s: String): Boolean = {
+    // Handwritten version of `matches(ID, s)` because validID turned up in profiling.
+    def isIdChar(c: Char): Boolean = Character.isLetterOrDigit(c) || (c == '-') || (c == '_')
+    @tailrec def isRestIdChar(cur: Int, s: String, length: Int): Boolean =
+      if (cur < length)
+        isIdChar(s.charAt(cur)) && isRestIdChar(cur + 1, s, length)
+      else
+        true
+
+    !s.isEmpty && Character.isLetter(s.charAt(0)) && isRestIdChar(1, s, s.length)
+  }
+
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/ProcessError.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ProcessError.scala
new file mode 100644
index 000000000..1d3a540bf
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/ProcessError.scala
@@ -0,0 +1,38 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+object ProcessError {
+  def apply(command: String, msgs: Seq[String], index: Int): String = {
+    val (line, modIndex) = extractLine(command, index)
+    val point = pointerSpace(command, modIndex)
+    msgs.mkString("\n") + "\n" + line + "\n" + point + "^"
+  }
+
+  def extractLine(s: String, i: Int): (String, Int) = {
+    val notNewline = (c: Char) => c != '\n' && c != '\r'
+    val left = takeRightWhile(s.substring(0, i))(notNewline)
+    val right = s substring i takeWhile notNewline
+    (left + right, left.length)
+  }
+
+  def takeRightWhile(s: String)(pred: Char => Boolean): String = {
+    def loop(i: Int): String =
+      if (i < 0)
+        s
+      else if (pred(s(i)))
+        loop(i - 1)
+      else
+        s.substring(i + 1)
+    loop(s.length - 1)
+  }
+
+  def pointerSpace(s: String, i: Int): String =
+    (s take i) map { case '\t' => '\t'; case _ => ' ' } mkString ""
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/SizeParser.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/SizeParser.scala
new file mode 100644
index 000000000..1ca63efbe
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/SizeParser.scala
@@ -0,0 +1,56 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util.complete
+
+import sbt.internal.util.complete.DefaultParsers._
+
+private[sbt] object SizeParser {
+  def apply(s: String): Option[Long] = Parser.parse(s, value).toOption
+  private sealed trait SizeUnit
+  private case object Bytes extends SizeUnit
+  private case object KiloBytes extends SizeUnit
+  private case object MegaBytes extends SizeUnit
+  private case object GigaBytes extends SizeUnit
+  private def parseDouble(s: String): Parser[Either[Double, Long]] =
+    try Parser.success(Left(java.lang.Double.valueOf(s)))
+    catch { case _: NumberFormatException => Parser.failure(s"Couldn't parse $s as double.") }
+  private def parseLong(s: String): Parser[Either[Double, Long]] =
+    try Parser.success(Right(java.lang.Long.valueOf(s)))
+    catch { case _: NumberFormatException => Parser.failure(s"Couldn't parse $s as double.") }
+  private[this] val digit = charClass(_.isDigit, "digit")
+  private[this] val numberParser: Parser[Either[Double, Long]] =
+    (digit.+ ~ ('.'.examples() ~> digit.+).?).flatMap {
+      case (leading, Some(decimalPart)) =>
+        parseDouble(s"${leading.mkString}.${decimalPart.mkString}")
+      case (leading, _) => parseLong(leading.mkString)
+    }
+  private[this] val unitParser: Parser[SizeUnit] =
+    token("b" | "B" | "g" | "G" | "k" | "K" | "m" | "M").map {
+      case "b" | "B" => Bytes
+      case "g" | "G" => GigaBytes
+      case "k" | "K" => KiloBytes
+      case "m" | "M" => MegaBytes
+    }
+  private[this] def multiply(left: Either[Double, Long], right: Long): Long = left match {
+    case Left(d)  => (d * right).toLong
+    case Right(l) => l * right
+  }
+  private[sbt] val value: Parser[Long] =
+    ((numberParser <~ SpaceClass
+      .examples(" ", "b", "B", "g", "G", "k", "K", "m", "M")
+      .*) ~ unitParser.?)
+      .map {
+        case (number, unit) =>
+          unit match {
+            case None | Some(Bytes) => multiply(number, right = 1L)
+            case Some(KiloBytes)    => multiply(number, right = 1024L)
+            case Some(MegaBytes)    => multiply(number, right = 1024L * 1024)
+            case Some(GigaBytes)    => multiply(number, right = 1024L * 1024 * 1024)
+          }
+      }
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/TokenCompletions.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TokenCompletions.scala
new file mode 100644
index 000000000..b956417da
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TokenCompletions.scala
@@ -0,0 +1,52 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import Completion.{ token => ctoken, tokenDisplay }
+
+sealed trait TokenCompletions {
+  def hideWhen(f: Int => Boolean): TokenCompletions
+}
+
+object TokenCompletions {
+  private[sbt] abstract class Delegating extends TokenCompletions { outer =>
+    def completions(seen: String, level: Int, delegate: Completions): Completions
+    final def hideWhen(hide: Int => Boolean): TokenCompletions = new Delegating {
+      def completions(seen: String, level: Int, delegate: Completions): Completions =
+        if (hide(level)) Completions.nil else outer.completions(seen, level, delegate)
+    }
+  }
+
+  private[sbt] abstract class Fixed extends TokenCompletions { outer =>
+    def completions(seen: String, level: Int): Completions
+    final def hideWhen(hide: Int => Boolean): TokenCompletions = new Fixed {
+      def completions(seen: String, level: Int) =
+        if (hide(level)) Completions.nil else outer.completions(seen, level)
+    }
+  }
+
+  val default: TokenCompletions = mapDelegateCompletions((seen, level, c) => ctoken(seen, c.append))
+
+  def displayOnly(msg: String): TokenCompletions = new Fixed {
+    def completions(seen: String, level: Int) = Completions.single(Completion.displayOnly(msg))
+  }
+
+  def overrideDisplay(msg: String): TokenCompletions =
+    mapDelegateCompletions((seen, level, c) => tokenDisplay(display = msg, append = c.append))
+
+  def fixed(f: (String, Int) => Completions): TokenCompletions = new Fixed {
+    def completions(seen: String, level: Int) = f(seen, level)
+  }
+
+  def mapDelegateCompletions(f: (String, Int, Completion) => Completion): TokenCompletions =
+    new Delegating {
+      def completions(seen: String, level: Int, delegate: Completions) =
+        Completions(delegate.get.map(c => f(seen, level, c)))
+    }
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/TypeString.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TypeString.scala
new file mode 100644
index 000000000..3a4e84ad2
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/TypeString.scala
@@ -0,0 +1,90 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import DefaultParsers._
+import TypeString._
+
+/**
+ * Basic representation of types parsed from Manifest.toString.
+ * This can only represent the structure of parameterized types.
+ * All other types are represented by a TypeString with an empty `args`.
+ */
+private[sbt] final class TypeString(val base: String, val args: List[TypeString]) {
+  override def toString =
+    if (base.startsWith(FunctionName))
+      args.dropRight(1).mkString("(", ",", ")") + " => " + args.last
+    else if (base.startsWith(TupleName))
+      args.mkString("(", ",", ")")
+    else
+      cleanupTypeName(base) + (if (args.isEmpty) "" else args.mkString("[", ",", "]"))
+}
+
+private[sbt] object TypeString {
+
+  /** Makes the string representation of a type as returned by Manifest.toString more readable.*/
+  def cleanup(typeString: String): String =
+    parse(typeString, typeStringParser) match {
+      case Right(ts) => ts.toString
+      case Left(_)   => typeString
+    }
+
+  /**
+   * Makes a fully qualified type name provided by Manifest.toString more readable.
+   * The argument should be just a name (like scala.Tuple2) and not a full type (like scala.Tuple2[Int,Boolean])
+   */
+  def cleanupTypeName(base: String): String =
+    dropPrefix(base).replace('$', '.')
+
+  /**
+   * Removes prefixes from a fully qualified type name that are unnecessary in the presence of standard imports for an sbt setting.
+   * This does not use the compiler and is therefore a conservative approximation.
+   */
+  def dropPrefix(base: String): String =
+    if (base.startsWith(SbtPrefix))
+      base.substring(SbtPrefix.length)
+    else if (base.startsWith(CollectionPrefix)) {
+      val simple = base.substring(CollectionPrefix.length)
+      if (ShortenCollection(simple)) simple else base
+    } else if (base.startsWith(ScalaPrefix))
+      base.substring(ScalaPrefix.length)
+    else if (base.startsWith(JavaPrefix))
+      base.substring(JavaPrefix.length)
+    else
+      TypeMap.getOrElse(base, base)
+
+  final val CollectionPrefix = "scala.collection."
+  final val FunctionName = "scala.Function"
+  final val TupleName = "scala.Tuple"
+  final val SbtPrefix = "sbt."
+  final val ScalaPrefix = "scala."
+  final val JavaPrefix = "java.lang."
+  /* scala.collection.X -> X */
+  val ShortenCollection = Set("Seq", "List", "Set", "Map", "Iterable")
+
+  val TypeMap = Map(
+    "java.io.File" -> "File",
+    "java.net.URL" -> "URL",
+    "java.net.URI" -> "URI"
+  )
+
+  /**
+   * A Parser that extracts basic structure from the string representation of a type from Manifest.toString.
+   * This is rudimentary and essentially only decomposes the string into names and arguments for parameterized types.
+   */
+  lazy val typeStringParser: Parser[TypeString] = {
+    def isFullScalaIDChar(c: Char) = isScalaIDChar(c) || c == '.' || c == '$'
+    lazy val fullScalaID =
+      identifier(IDStart, charClass(isFullScalaIDChar, "Scala identifier character"))
+    lazy val tpe: Parser[TypeString] =
+      for (id <- fullScalaID; args <- ('[' ~> rep1sep(tpe, ',') <~ ']').?)
+        yield new TypeString(id, args.toList.flatten)
+    tpe
+  }
+}
diff --git a/internal/util-complete/src/main/scala/sbt/internal/util/complete/UpperBound.scala b/internal/util-complete/src/main/scala/sbt/internal/util/complete/UpperBound.scala
new file mode 100644
index 000000000..c502f8784
--- /dev/null
+++ b/internal/util-complete/src/main/scala/sbt/internal/util/complete/UpperBound.scala
@@ -0,0 +1,64 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+sealed trait UpperBound {
+
+  /** True if and only if the given value meets this bound.*/
+  def >=(min: Int): Boolean
+
+  /** True if and only if this bound is one.*/
+  def isOne: Boolean
+
+  /** True if and only if this bound is zero.*/
+  def isZero: Boolean
+
+  /**
+   * If this bound is zero or Infinite, `decrement` returns this bound.
+   * Otherwise, this bound is finite and greater than zero and `decrement` returns the bound that is one less than this bound.
+   */
+  def decrement: UpperBound
+
+  /** True if and only if this is unbounded.*/
+  def isInfinite: Boolean
+
+}
+
+/** Represents unbounded. */
+case object Infinite extends UpperBound {
+
+  /** All finite numbers meet this bound. */
+  def >=(min: Int) = true
+
+  def isOne = false
+  def isZero = false
+  def decrement = this
+  def isInfinite = true
+
+  override def toString = "Infinity"
+}
+
+/**
+ * Represents a finite upper bound. The maximum allowed value is 'value', inclusive.
+ *  It must positive.
+ */
+final case class Finite(value: Int) extends UpperBound {
+  assume(value >= 0, "Maximum occurrences must be nonnegative.")
+
+  def >=(min: Int) = value >= min
+  def isOne = value == 1
+  def isZero = value == 0
+  def decrement = Finite(scala.math.max(0, value - 1))
+  def isInfinite = false
+  override def toString = value.toString
+}
+
+object UpperBound {
+  implicit def intToFinite(i: Int): Finite = Finite(i)
+}
diff --git a/internal/util-complete/src/test/scala/DefaultParsersSpec.scala b/internal/util-complete/src/test/scala/DefaultParsersSpec.scala
new file mode 100644
index 000000000..b0f7bd47e
--- /dev/null
+++ b/internal/util-complete/src/test/scala/DefaultParsersSpec.scala
@@ -0,0 +1,29 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import org.scalacheck._, Gen._, Prop._
+
+object DefaultParsersSpec extends Properties("DefaultParsers") {
+  import DefaultParsers.{ ID, isIDChar, matches, validID }
+
+  property("∀ s ∈ String: validID(s) == matches(ID, s)") = forAll(
+    (s: String) => validID(s) == matches(ID, s)
+  )
+
+  property("∀ s ∈ genID: matches(ID, s)") = forAll(genID)(s => matches(ID, s))
+  property("∀ s ∈ genID: validID(s)") = forAll(genID)(s => validID(s))
+
+  private val chars: Seq[Char] = Char.MinValue to Char.MaxValue
+  private val genID: Gen[String] =
+    for {
+      c <- oneOf(chars filter (_.isLetter))
+      cs <- listOf(oneOf(chars filter isIDChar))
+    } yield (c :: cs).mkString
+}
diff --git a/internal/util-complete/src/test/scala/ParserTest.scala b/internal/util-complete/src/test/scala/ParserTest.scala
new file mode 100644
index 000000000..49f99056f
--- /dev/null
+++ b/internal/util-complete/src/test/scala/ParserTest.scala
@@ -0,0 +1,162 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+object JLineTest {
+  import DefaultParsers._
+
+  val one = "blue" | "green" | "black"
+  val two = token("color" ~> Space) ~> token(one)
+  val three = token("color" ~> Space) ~> token(ID.examples("blue", "green", "black"))
+  val four = token("color" ~> Space) ~> token(ID, "<color name>")
+
+  val num = token(NatBasic)
+  val five = (num ~ token("+" | "-") ~ num) <~ token('=') flatMap {
+    case a ~ "+" ~ b => token((a + b).toString)
+    case a ~ "-" ~ b => token((a - b).toString)
+  }
+
+  val parsers = Map("1" -> one, "2" -> two, "3" -> three, "4" -> four, "5" -> five)
+  def main(args: Array[String]): Unit = {
+    import jline.TerminalFactory
+    import jline.console.ConsoleReader
+    val reader = new ConsoleReader()
+    TerminalFactory.get.init
+
+    val parser = parsers(args(0))
+    JLineCompletion.installCustomCompletor(reader, parser)
+    def loop(): Unit = {
+      val line = reader.readLine("> ")
+      if (line ne null) {
+        println("Result: " + apply(parser)(line).resultEmpty)
+        loop()
+      }
+    }
+    loop()
+  }
+}
+
+import Parser._
+import org.scalacheck._
+
+object ParserTest extends Properties("Completing Parser") {
+  import Parsers._
+  import DefaultParsers.matches
+
+  val nested = (token("a1") ~ token("b2")) ~ "c3"
+  val nestedDisplay = (token("a1", "<a1>") ~ token("b2", "<b2>")) ~ "c3"
+
+  val spacePort = token(Space) ~> Port
+
+  def p[T](f: T): T = { println(f); f }
+
+  def checkSingle(in: String, expect: Completion)(expectDisplay: Completion = expect) =
+    (("token '" + in + "'") |: checkOne(in, nested, expect)) &&
+      (("display '" + in + "'") |: checkOne(in, nestedDisplay, expectDisplay))
+
+  def checkOne(in: String, parser: Parser[_], expect: Completion): Prop =
+    completions(parser, in, 1) == Completions.single(expect)
+
+  def checkAll(in: String, parser: Parser[_], expect: Completions): Prop = {
+    val cs = completions(parser, in, 1)
+    ("completions: " + cs) |: ("Expected: " + expect) |: (cs == expect: Prop)
+  }
+
+  def checkInvalid(in: String) =
+    (("token '" + in + "'") |: checkInv(in, nested)) &&
+      (("display '" + in + "'") |: checkInv(in, nestedDisplay))
+
+  def checkInv(in: String, parser: Parser[_]): Prop = {
+    val cs = completions(parser, in, 1)
+    ("completions: " + cs) |: (cs == Completions.nil: Prop)
+  }
+
+  property("nested tokens a") =
+    checkSingle("", Completion.token("", "a1"))(Completion.displayOnly("<a1>"))
+  property("nested tokens a1") =
+    checkSingle("a", Completion.token("a", "1"))(Completion.displayOnly("<a1>"))
+  property("nested tokens a inv") = checkInvalid("b")
+  property("nested tokens b") =
+    checkSingle("a1", Completion.token("", "b2"))(Completion.displayOnly("<b2>"))
+  property("nested tokens b2") =
+    checkSingle("a1b", Completion.token("b", "2"))(Completion.displayOnly("<b2>"))
+  property("nested tokens b inv") = checkInvalid("a1a")
+  property("nested tokens c") = checkSingle("a1b2", Completion.suggestion("c3"))()
+  property("nested tokens c3") = checkSingle("a1b2c", Completion.suggestion("3"))()
+  property("nested tokens c inv") = checkInvalid("a1b2a")
+
+  property("suggest space") = checkOne("", spacePort, Completion.token("", " "))
+  property("suggest port") = checkOne(" ", spacePort, Completion.displayOnly("<port>"))
+  property("no suggest at end") = checkOne("asdf", "asdf", Completion.suggestion(""))
+  property("no suggest at token end") = checkOne("asdf", token("asdf"), Completion.suggestion(""))
+  property("empty suggest for examples") =
+    checkOne("asdf", any.+.examples("asdf", "qwer"), Completion.suggestion(""))
+  property("empty suggest for examples token") =
+    checkOne("asdf", token(any.+.examples("asdf", "qwer")), Completion.suggestion(""))
+
+  val colors = Set("blue", "green", "red")
+  val base = (seen: Seq[String]) => token(ID examples (colors -- seen))
+  val sep = token(Space)
+  val repeat = repeatDep(base, sep)
+  def completionStrings(ss: Set[String]) = Completions(ss map (Completion.token("", _)))
+
+  property("repeatDep no suggestions for bad input") = checkInv(".", repeat)
+  property("repeatDep suggest all") = checkAll("", repeat, completionStrings(colors))
+  property("repeatDep suggest remaining two") = {
+    val first = colors.toSeq.head
+    checkAll(first + " ", repeat, completionStrings(colors - first))
+  }
+  property("repeatDep suggest remaining one") = {
+    val take = colors.toSeq.take(2)
+    checkAll(take.mkString("", " ", " "), repeat, completionStrings(colors -- take))
+  }
+  property("repeatDep requires at least one token") = !matches(repeat, "")
+  property("repeatDep accepts one token") = matches(repeat, colors.toSeq.head)
+  property("repeatDep accepts two tokens") = matches(repeat, colors.toSeq.take(2).mkString(" "))
+}
+object ParserExample {
+  val ws = charClass(_.isWhitespace, "whitespace").+
+  val notws = charClass(!_.isWhitespace, "not whitespace").+
+
+  val name = token("test")
+  val options = (ws ~> token("quick" | "failed" | "new")).*
+  val exampleSet = Set("am", "is", "are", "was", "were")
+  val include = (ws ~> token(
+    examples(notws.string, new FixedSetExamples(exampleSet), exampleSet.size, false)
+  )).*
+
+  val t = name ~ options ~ include
+
+  // Get completions for some different inputs
+  println(completions(t, "te", 1))
+  println(completions(t, "test ", 1))
+  println(completions(t, "test w", 1))
+
+  // Get the parsed result for different inputs
+  println(apply(t)("te").resultEmpty)
+  println(apply(t)("test").resultEmpty)
+  println(apply(t)("test w").resultEmpty)
+  println(apply(t)("test was were").resultEmpty)
+
+  def run(n: Int): Unit = {
+    val a = 'a'.id
+    val aq = a.?
+    val aqn = repeat(aq, min = n, max = n)
+    val an = repeat(a, min = n, max = n)
+    val ann = aqn ~ an
+
+    def r = apply(ann)("a" * (n * 2)).resultEmpty
+    println(r.isValid)
+  }
+  def run2(n: Int): Unit = {
+    val ab = "ab".?.*
+    val r = apply(ab)("a" * n).resultEmpty
+    println(r)
+  }
+}
diff --git a/internal/util-complete/src/test/scala/UnitSpec.scala b/internal/util-complete/src/test/scala/UnitSpec.scala
new file mode 100644
index 000000000..ed582c3bb
--- /dev/null
+++ b/internal/util-complete/src/test/scala/UnitSpec.scala
@@ -0,0 +1,12 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalatest._
+
+abstract class UnitSpec extends FlatSpec with Matchers
diff --git a/internal/util-complete/src/test/scala/sbt/complete/FileExamplesTest.scala b/internal/util-complete/src/test/scala/sbt/complete/FileExamplesTest.scala
new file mode 100644
index 000000000..da4662308
--- /dev/null
+++ b/internal/util-complete/src/test/scala/sbt/complete/FileExamplesTest.scala
@@ -0,0 +1,104 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import java.io.File
+import org.scalatest.Assertion
+import sbt.io.IO
+
+class FileExamplesTest extends UnitSpec {
+
+  "listing all files in an absolute base directory" should
+    "produce the entire base directory's contents" in {
+    withDirectoryStructure() { ds =>
+      ds.fileExamples().toList should contain theSameElementsAs (ds.allRelativizedPaths)
+    }
+  }
+
+  "listing files with a prefix that matches none" should "produce an empty list" in {
+    withDirectoryStructure(withCompletionPrefix = "z") { ds =>
+      ds.fileExamples().toList shouldBe empty
+    }
+  }
+
+  "listing single-character prefixed files" should "produce matching paths only" in {
+    withDirectoryStructure(withCompletionPrefix = "f") { ds =>
+      ds.fileExamples().toList should contain theSameElementsAs (ds.prefixedPathsOnly)
+    }
+  }
+
+  "listing directory-prefixed files" should "produce matching paths only" in {
+    withDirectoryStructure(withCompletionPrefix = "far") { ds =>
+      ds.fileExamples().toList should contain theSameElementsAs (ds.prefixedPathsOnly)
+    }
+  }
+
+  it should "produce sub-dir contents only when appending a file separator to the directory" in {
+    withDirectoryStructure(withCompletionPrefix = "far" + File.separator) { ds =>
+      ds.fileExamples().toList should contain theSameElementsAs (ds.prefixedPathsOnly)
+    }
+  }
+
+  "listing files with a sub-path prefix" should "produce matching paths only" in {
+    withDirectoryStructure(withCompletionPrefix = "far" + File.separator + "ba") { ds =>
+      ds.fileExamples().toList should contain theSameElementsAs (ds.prefixedPathsOnly)
+    }
+  }
+
+  "completing a full path" should "produce a list with an empty string" in {
+    withDirectoryStructure(withCompletionPrefix = "bazaar") { ds =>
+      ds.fileExamples().toList shouldEqual List("")
+    }
+  }
+
+  def withDirectoryStructure[A](withCompletionPrefix: String = "")(
+      thunk: DirectoryStructure => Assertion
+  ): Assertion = {
+    IO.withTemporaryDirectory { tempDir =>
+      val ds = new DirectoryStructure(withCompletionPrefix)
+      ds.createSampleDirStructure(tempDir)
+      ds.fileExamples = new FileExamples(ds.baseDir, withCompletionPrefix)
+      thunk(ds)
+    }
+  }
+
+  final class DirectoryStructure(withCompletionPrefix: String) {
+    var fileExamples: FileExamples = _
+    var baseDir: File = _
+    var childFiles: List[File] = _
+    var childDirectories: List[File] = _
+    var nestedFiles: List[File] = _
+    var nestedDirectories: List[File] = _
+
+    def allRelativizedPaths: List[String] =
+      (childFiles ++ childDirectories ++ nestedFiles ++ nestedDirectories)
+        .map(IO.relativize(baseDir, _).get)
+
+    def prefixedPathsOnly: List[String] =
+      allRelativizedPaths
+        .filter(_ startsWith withCompletionPrefix)
+        .map(_ substring withCompletionPrefix.length)
+
+    def createSampleDirStructure(tempDir: File): Unit = {
+      childFiles = toChildFiles(tempDir, List("foo", "bar", "bazaar"))
+      childDirectories = toChildFiles(tempDir, List("moo", "far"))
+      nestedFiles = toChildFiles(childDirectories(1), List("farfile1", "barfile2"))
+      nestedDirectories = toChildFiles(childDirectories(1), List("fardir1", "bardir2"))
+
+      (childDirectories ++ nestedDirectories).map(_.mkdirs())
+      (childFiles ++ nestedFiles).map(_.createNewFile())
+
+      baseDir = tempDir
+    }
+
+    private def toChildFiles(baseDir: File, files: List[String]): List[File] =
+      files.map(new File(baseDir, _))
+  }
+
+}
diff --git a/internal/util-complete/src/test/scala/sbt/complete/FixedSetExamplesTest.scala b/internal/util-complete/src/test/scala/sbt/complete/FixedSetExamplesTest.scala
new file mode 100644
index 000000000..51c6a2f6f
--- /dev/null
+++ b/internal/util-complete/src/test/scala/sbt/complete/FixedSetExamplesTest.scala
@@ -0,0 +1,32 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+class FixedSetExamplesTest extends UnitSpec {
+
+  "adding a prefix" should "produce a smaller set of examples with the prefix removed" in {
+    val _ = new Examples {
+      fixedSetExamples.withAddedPrefix("f")() should contain theSameElementsAs
+        (List("oo", "ool", "u"))
+      fixedSetExamples.withAddedPrefix("fo")() should contain theSameElementsAs (List("o", "ol"))
+      fixedSetExamples.withAddedPrefix("b")() should contain theSameElementsAs (List("ar"))
+    }
+  }
+
+  "without a prefix" should "produce the original set" in {
+    val _ = new Examples {
+      fixedSetExamples() shouldBe exampleSet
+    }
+  }
+
+  trait Examples {
+    val exampleSet = List("foo", "bar", "fool", "fu")
+    val fixedSetExamples = FixedSetExamples(exampleSet)
+  }
+}
diff --git a/internal/util-complete/src/test/scala/sbt/complete/ParserWithExamplesTest.scala b/internal/util-complete/src/test/scala/sbt/complete/ParserWithExamplesTest.scala
new file mode 100644
index 000000000..93e8e4c05
--- /dev/null
+++ b/internal/util-complete/src/test/scala/sbt/complete/ParserWithExamplesTest.scala
@@ -0,0 +1,117 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package complete
+
+import Completion._
+
+class ParserWithExamplesTest extends UnitSpec {
+
+  "listing a limited number of completions" should
+    "grab only the needed number of elements from the iterable source of examples" in {
+    val _ = new ParserWithLazyExamples {
+      parserWithExamples.completions(0)
+      examples.size shouldEqual maxNumberOfExamples
+    }
+  }
+
+  "listing only valid completions" should
+    "use the delegate parser to remove invalid examples" in {
+    val _ = new ParserWithValidExamples {
+      val validCompletions = Completions(
+        Set(
+          suggestion("blue"),
+          suggestion("red")
+        )
+      )
+      parserWithExamples.completions(0) shouldEqual validCompletions
+    }
+  }
+
+  "listing valid completions in a derived parser" should
+    "produce only valid examples that start with the character of the derivation" in {
+    val _ = new ParserWithValidExamples {
+      val derivedCompletions = Completions(
+        Set(
+          suggestion("lue")
+        )
+      )
+      parserWithExamples.derive('b').completions(0) shouldEqual derivedCompletions
+    }
+  }
+
+  "listing valid and invalid completions" should
+    "produce the entire source of examples" in {
+    val _ = new parserWithAllExamples {
+      val completions = Completions(examples.map(suggestion(_)).toSet)
+      parserWithExamples.completions(0) shouldEqual completions
+    }
+  }
+
+  "listing valid and invalid completions in a derived parser" should
+    "produce only examples that start with the character of the derivation" in {
+    val _ = new parserWithAllExamples {
+      val derivedCompletions = Completions(
+        Set(
+          suggestion("lue"),
+          suggestion("lock")
+        )
+      )
+      parserWithExamples.derive('b').completions(0) shouldEqual derivedCompletions
+    }
+  }
+
+  class ParserWithLazyExamples
+      extends ParserExample(
+        GrowableSourceOfExamples(),
+        maxNumberOfExamples = 5,
+        removeInvalidExamples = false
+      )
+
+  class ParserWithValidExamples extends ParserExample(removeInvalidExamples = true)
+
+  class parserWithAllExamples extends ParserExample(removeInvalidExamples = false)
+
+  case class ParserExample(
+      examples: Iterable[String] = Set("blue", "yellow", "greeen", "block", "red"),
+      maxNumberOfExamples: Int = 25,
+      removeInvalidExamples: Boolean
+  ) {
+
+    import DefaultParsers._
+
+    val colorParser = "blue" | "green" | "black" | "red"
+    val parserWithExamples: Parser[String] = new ParserWithExamples[String](
+      colorParser,
+      FixedSetExamples(examples),
+      maxNumberOfExamples,
+      removeInvalidExamples
+    )
+  }
+
+  case class GrowableSourceOfExamples() extends Iterable[String] {
+    private var numberOfIteratedElements: Int = 0
+
+    override def iterator: Iterator[String] = {
+      new Iterator[String] {
+        var currentElement = 0
+
+        override def next(): String = {
+          currentElement += 1
+          numberOfIteratedElements = Math.max(currentElement, numberOfIteratedElements)
+          numberOfIteratedElements.toString
+        }
+
+        override def hasNext: Boolean = true
+      }
+    }
+
+    override def size: Int = numberOfIteratedElements
+  }
+
+}
diff --git a/internal/util-complete/src/test/scala/sbt/internal/util/complete/SizeParserSpec.scala b/internal/util-complete/src/test/scala/sbt/internal/util/complete/SizeParserSpec.scala
new file mode 100644
index 000000000..521f2d10a
--- /dev/null
+++ b/internal/util-complete/src/test/scala/sbt/internal/util/complete/SizeParserSpec.scala
@@ -0,0 +1,63 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util.complete
+
+import org.scalatest.FlatSpec
+
+class SizeParserSpec extends FlatSpec {
+  "SizeParser" should "handle raw bytes" in {
+    assert(Parser.parse(str = "123456", SizeParser.value) == Right(123456L))
+  }
+  it should "handle bytes" in {
+    assert(Parser.parse(str = "123456b", SizeParser.value) == Right(123456L))
+    assert(Parser.parse(str = "123456B", SizeParser.value) == Right(123456L))
+    assert(Parser.parse(str = "123456 b", SizeParser.value) == Right(123456L))
+    assert(Parser.parse(str = "123456 B", SizeParser.value) == Right(123456L))
+  }
+  it should "handle kilobytes" in {
+    assert(Parser.parse(str = "123456k", SizeParser.value) == Right(123456L * 1024))
+    assert(Parser.parse(str = "123456K", SizeParser.value) == Right(123456L * 1024))
+    assert(Parser.parse(str = "123456 K", SizeParser.value) == Right(123456L * 1024))
+    assert(Parser.parse(str = "123456 K", SizeParser.value) == Right(123456L * 1024))
+  }
+  it should "handle megabytes" in {
+    assert(Parser.parse(str = "123456m", SizeParser.value) == Right(123456L * 1024 * 1024))
+    assert(Parser.parse(str = "123456M", SizeParser.value) == Right(123456L * 1024 * 1024))
+    assert(Parser.parse(str = "123456 M", SizeParser.value) == Right(123456L * 1024 * 1024))
+    assert(Parser.parse(str = "123456 M", SizeParser.value) == Right(123456L * 1024 * 1024))
+  }
+  it should "handle gigabytes" in {
+    assert(Parser.parse(str = "123456g", SizeParser.value) == Right(123456L * 1024 * 1024 * 1024))
+    assert(Parser.parse(str = "123456G", SizeParser.value) == Right(123456L * 1024 * 1024 * 1024))
+    assert(Parser.parse(str = "123456 G", SizeParser.value) == Right(123456L * 1024 * 1024 * 1024))
+    assert(Parser.parse(str = "123456 G", SizeParser.value) == Right(123456L * 1024 * 1024 * 1024))
+  }
+  it should "handle doubles" in {
+    assert(Parser.parse(str = "1.25g", SizeParser.value) == Right(5L * 1024 * 1024 * 1024 / 4))
+    assert(Parser.parse(str = "1.25 g", SizeParser.value) == Right(5L * 1024 * 1024 * 1024 / 4))
+    assert(Parser.parse(str = "1.25 g", SizeParser.value) == Right(5L * 1024 * 1024 * 1024 / 4))
+    assert(Parser.parse(str = "1.25 G", SizeParser.value) == Right(5L * 1024 * 1024 * 1024 / 4))
+  }
+  private val expectedCompletions = Set("", "b", "B", "g", "G", "k", "K", "m", "M", " ")
+  it should "have completions for long" in {
+    val completions = Parser.completions(SizeParser.value, "123", level = 0).get.map(_.display)
+    assert(completions == expectedCompletions)
+  }
+  it should "have completions for long with spaces" in {
+    val completions = Parser.completions(SizeParser.value, "123", level = 0).get.map(_.display)
+    assert(completions == expectedCompletions)
+  }
+  it should "have completions for double " in {
+    val completions = Parser.completions(SizeParser.value, "1.25", level = 0).get.map(_.display)
+    assert(completions == expectedCompletions)
+  }
+  it should "have completions for double with spaces" in {
+    val completions = Parser.completions(SizeParser.value, "1.25  ", level = 0).get.map(_.display)
+    assert(completions == expectedCompletions + "")
+  }
+}
diff --git a/internal/util-control/NOTICE b/internal/util-control/NOTICE
new file mode 100644
index 000000000..76a30965a
--- /dev/null
+++ b/internal/util-control/NOTICE
@@ -0,0 +1,3 @@
+Simple Build Tool: Control Component
+Copyright 2009  Mark Harrah
+Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/ErrorHandling.scala b/internal/util-control/src/main/scala/sbt/internal/util/ErrorHandling.scala
new file mode 100644
index 000000000..7b2a86994
--- /dev/null
+++ b/internal/util-control/src/main/scala/sbt/internal/util/ErrorHandling.scala
@@ -0,0 +1,49 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.IOException
+
+object ErrorHandling {
+  def translate[T](msg: => String)(f: => T) =
+    try {
+      f
+    } catch {
+      case e: IOException => throw new TranslatedIOException(msg + e.toString, e)
+      case e: Exception   => throw new TranslatedException(msg + e.toString, e)
+    }
+
+  def wideConvert[T](f: => T): Either[Throwable, T] =
+    try {
+      Right(f)
+    } catch {
+      case ex @ (_: Exception | _: StackOverflowError)     => Left(ex)
+      case err @ (_: ThreadDeath | _: VirtualMachineError) => throw err
+      case x: Throwable                                    => Left(x)
+    }
+
+  def convert[T](f: => T): Either[Exception, T] =
+    try {
+      Right(f)
+    } catch { case e: Exception => Left(e) }
+
+  def reducedToString(e: Throwable): String =
+    if (e.getClass == classOf[RuntimeException]) {
+      val msg = e.getMessage
+      if (msg == null || msg.isEmpty) e.toString else msg
+    } else
+      e.toString
+}
+
+sealed class TranslatedException private[sbt] (msg: String, cause: Throwable)
+    extends RuntimeException(msg, cause) {
+  override def toString = msg
+}
+
+final class TranslatedIOException private[sbt] (msg: String, cause: IOException)
+    extends TranslatedException(msg, cause)
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/ExitHook.scala b/internal/util-control/src/main/scala/sbt/internal/util/ExitHook.scala
new file mode 100644
index 000000000..677b780fd
--- /dev/null
+++ b/internal/util-control/src/main/scala/sbt/internal/util/ExitHook.scala
@@ -0,0 +1,28 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+/** Defines a function to call as sbt exits.*/
+trait ExitHook {
+
+  /** Subclasses should implement this method, which is called when this hook is executed. */
+  def runBeforeExiting(): Unit
+
+}
+
+object ExitHook {
+  def apply(f: => Unit): ExitHook = new ExitHook { def runBeforeExiting() = f }
+}
+
+object ExitHooks {
+
+  /** Calls each registered exit hook, trapping any exceptions so that each hook is given a chance to run. */
+  def runExitHooks(exitHooks: Seq[ExitHook]): Seq[Throwable] =
+    exitHooks.flatMap(hook => ErrorHandling.wideConvert(hook.runBeforeExiting()).left.toOption)
+
+}
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/MessageOnlyException.scala b/internal/util-control/src/main/scala/sbt/internal/util/MessageOnlyException.scala
new file mode 100644
index 000000000..094d4999c
--- /dev/null
+++ b/internal/util-control/src/main/scala/sbt/internal/util/MessageOnlyException.scala
@@ -0,0 +1,28 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+final class MessageOnlyException(override val toString: String) extends RuntimeException(toString)
+
+/**
+ * A dummy exception for the top-level exception handler to know that an exception
+ * has been handled, but is being passed further up to indicate general failure.
+ */
+final class AlreadyHandledException(val underlying: Throwable) extends RuntimeException
+
+/**
+ * A marker trait for a top-level exception handler to know that this exception
+ * doesn't make sense to display.
+ */
+trait UnprintableException extends Throwable
+
+/**
+ * A marker trait that refines UnprintableException to indicate to a top-level exception handler
+ * that the code throwing this exception has already provided feedback to the user about the error condition.
+ */
+trait FeedbackProvidedException extends UnprintableException
diff --git a/internal/util-control/src/main/scala/sbt/internal/util/RunningProcesses.scala b/internal/util-control/src/main/scala/sbt/internal/util/RunningProcesses.scala
new file mode 100644
index 000000000..47da42d34
--- /dev/null
+++ b/internal/util-control/src/main/scala/sbt/internal/util/RunningProcesses.scala
@@ -0,0 +1,33 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.util.concurrent.ConcurrentHashMap
+import scala.sys.process.Process
+
+/**
+ * Manages forked processes created by sbt. Any process registered
+ * with RunningProcesses can be killed with the killAll method. In
+ * particular, this can be used in a signal handler to kill these
+ * processes when the user inputs ctrl+c.
+ */
+private[sbt] object RunningProcesses {
+  val active = ConcurrentHashMap.newKeySet[Process]
+  def add(process: Process): Unit = active.synchronized {
+    active.add(process)
+    ()
+  }
+  def remove(process: Process): Unit = active.synchronized {
+    active.remove(process)
+    ()
+  }
+  def killAll(): Unit = active.synchronized {
+    active.forEach(_.destroy())
+    active.clear()
+  }
+}
diff --git a/internal/util-interface/src/main/java/xsbti/Logger.java b/internal/util-interface/src/main/java/xsbti/Logger.java
new file mode 100644
index 000000000..54023b52e
--- /dev/null
+++ b/internal/util-interface/src/main/java/xsbti/Logger.java
@@ -0,0 +1,22 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package xsbti;
+
+import java.util.function.Supplier;
+
+public interface Logger {
+  void error(Supplier<String> msg);
+
+  void warn(Supplier<String> msg);
+
+  void info(Supplier<String> msg);
+
+  void debug(Supplier<String> msg);
+
+  void trace(Supplier<Throwable> exception);
+}
diff --git a/internal/util-interface/src/main/java/xsbti/Position.java b/internal/util-interface/src/main/java/xsbti/Position.java
new file mode 100644
index 000000000..da4f139d6
--- /dev/null
+++ b/internal/util-interface/src/main/java/xsbti/Position.java
@@ -0,0 +1,53 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package xsbti;
+
+import java.io.File;
+import java.util.Optional;
+
+public interface Position {
+  Optional<Integer> line();
+
+  String lineContent();
+
+  Optional<Integer> offset();
+
+  // pointer to the column position of the error/warning
+  Optional<Integer> pointer();
+
+  Optional<String> pointerSpace();
+
+  Optional<String> sourcePath();
+
+  Optional<File> sourceFile();
+
+  // Default values to avoid breaking binary compatibility
+  default Optional<Integer> startOffset() {
+    return Optional.empty();
+  }
+
+  default Optional<Integer> endOffset() {
+    return Optional.empty();
+  }
+
+  default Optional<Integer> startLine() {
+    return Optional.empty();
+  }
+
+  default Optional<Integer> startColumn() {
+    return Optional.empty();
+  }
+
+  default Optional<Integer> endLine() {
+    return Optional.empty();
+  }
+
+  default Optional<Integer> endColumn() {
+    return Optional.empty();
+  }
+}
diff --git a/internal/util-interface/src/main/java/xsbti/Problem.java b/internal/util-interface/src/main/java/xsbti/Problem.java
new file mode 100644
index 000000000..78c9145a3
--- /dev/null
+++ b/internal/util-interface/src/main/java/xsbti/Problem.java
@@ -0,0 +1,29 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package xsbti;
+
+import java.util.Optional;
+
+public interface Problem {
+  String category();
+
+  Severity severity();
+
+  String message();
+
+  Position position();
+
+  // Default value to avoid breaking binary compatibility
+  /**
+   * If present, the string shown to the user when displaying this Problem. Otherwise, the Problem
+   * will be shown in an implementation-defined way based on the values of its other fields.
+   */
+  default Optional<String> rendered() {
+    return Optional.empty();
+  }
+}
diff --git a/internal/util-interface/src/main/java/xsbti/Severity.java b/internal/util-interface/src/main/java/xsbti/Severity.java
new file mode 100644
index 000000000..833d91093
--- /dev/null
+++ b/internal/util-interface/src/main/java/xsbti/Severity.java
@@ -0,0 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package xsbti;
+
+public enum Severity {
+  Info,
+  Warn,
+  Error
+}
diff --git a/internal/util-interface/src/main/java/xsbti/T2.java b/internal/util-interface/src/main/java/xsbti/T2.java
new file mode 100644
index 000000000..2f51726d7
--- /dev/null
+++ b/internal/util-interface/src/main/java/xsbti/T2.java
@@ -0,0 +1,15 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package xsbti;
+
+/** Used to pass a pair of values. */
+public interface T2<A1, A2> {
+  public A1 get1();
+
+  public A2 get2();
+}
diff --git a/internal/util-logging/NOTICE b/internal/util-logging/NOTICE
new file mode 100644
index 000000000..2455dad65
--- /dev/null
+++ b/internal/util-logging/NOTICE
@@ -0,0 +1,3 @@
+Simple Build Tool: Logging Component
+Copyright 2008, 2009, 2010  Mark Harrah, Tony Sloane
+Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/AbstractEntry.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/AbstractEntry.scala
new file mode 100644
index 000000000..023b1009f
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/AbstractEntry.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util
+abstract class AbstractEntry(
+  val channelName: Option[String],
+  val execId: Option[String]) extends Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: AbstractEntry => (this.channelName == x.channelName) && (this.execId == x.execId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.util.AbstractEntry".##) + channelName.##) + execId.##)
+  }
+  override def toString: String = {
+    "AbstractEntry(" + channelName + ", " + execId + ")"
+  }
+}
+object AbstractEntry {
+  
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/LogOption.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/LogOption.scala
new file mode 100644
index 000000000..3e0c50d64
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/LogOption.scala
@@ -0,0 +1,15 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util
+/** value for logging options like color */
+sealed abstract class LogOption extends Serializable
+object LogOption {
+  
+  
+  case object Always extends LogOption
+  case object Never extends LogOption
+  case object Auto extends LogOption
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/ProgressEvent.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/ProgressEvent.scala
new file mode 100644
index 000000000..ada2a80c8
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/ProgressEvent.scala
@@ -0,0 +1,75 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util
+/** used by super shell */
+final class ProgressEvent private (
+  val level: String,
+  val items: Vector[sbt.internal.util.ProgressItem],
+  val lastTaskCount: Option[Int],
+  channelName: Option[String],
+  execId: Option[String],
+  val command: Option[String],
+  val skipIfActive: Option[Boolean]) extends sbt.internal.util.AbstractEntry(channelName, execId) with Serializable {
+  
+  private def this(level: String, items: Vector[sbt.internal.util.ProgressItem], lastTaskCount: Option[Int], channelName: Option[String], execId: Option[String]) = this(level, items, lastTaskCount, channelName, execId, None, None)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ProgressEvent => (this.level == x.level) && (this.items == x.items) && (this.lastTaskCount == x.lastTaskCount) && (this.channelName == x.channelName) && (this.execId == x.execId) && (this.command == x.command) && (this.skipIfActive == x.skipIfActive)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.util.ProgressEvent".##) + level.##) + items.##) + lastTaskCount.##) + channelName.##) + execId.##) + command.##) + skipIfActive.##)
+  }
+  override def toString: String = {
+    "ProgressEvent(" + level + ", " + items + ", " + lastTaskCount + ", " + channelName + ", " + execId + ", " + command + ", " + skipIfActive + ")"
+  }
+  private[this] def copy(level: String = level, items: Vector[sbt.internal.util.ProgressItem] = items, lastTaskCount: Option[Int] = lastTaskCount, channelName: Option[String] = channelName, execId: Option[String] = execId, command: Option[String] = command, skipIfActive: Option[Boolean] = skipIfActive): ProgressEvent = {
+    new ProgressEvent(level, items, lastTaskCount, channelName, execId, command, skipIfActive)
+  }
+  def withLevel(level: String): ProgressEvent = {
+    copy(level = level)
+  }
+  def withItems(items: Vector[sbt.internal.util.ProgressItem]): ProgressEvent = {
+    copy(items = items)
+  }
+  def withLastTaskCount(lastTaskCount: Option[Int]): ProgressEvent = {
+    copy(lastTaskCount = lastTaskCount)
+  }
+  def withLastTaskCount(lastTaskCount: Int): ProgressEvent = {
+    copy(lastTaskCount = Option(lastTaskCount))
+  }
+  def withChannelName(channelName: Option[String]): ProgressEvent = {
+    copy(channelName = channelName)
+  }
+  def withChannelName(channelName: String): ProgressEvent = {
+    copy(channelName = Option(channelName))
+  }
+  def withExecId(execId: Option[String]): ProgressEvent = {
+    copy(execId = execId)
+  }
+  def withExecId(execId: String): ProgressEvent = {
+    copy(execId = Option(execId))
+  }
+  def withCommand(command: Option[String]): ProgressEvent = {
+    copy(command = command)
+  }
+  def withCommand(command: String): ProgressEvent = {
+    copy(command = Option(command))
+  }
+  def withSkipIfActive(skipIfActive: Option[Boolean]): ProgressEvent = {
+    copy(skipIfActive = skipIfActive)
+  }
+  def withSkipIfActive(skipIfActive: Boolean): ProgressEvent = {
+    copy(skipIfActive = Option(skipIfActive))
+  }
+}
+object ProgressEvent {
+  
+  def apply(level: String, items: Vector[sbt.internal.util.ProgressItem], lastTaskCount: Option[Int], channelName: Option[String], execId: Option[String]): ProgressEvent = new ProgressEvent(level, items, lastTaskCount, channelName, execId)
+  def apply(level: String, items: Vector[sbt.internal.util.ProgressItem], lastTaskCount: Int, channelName: String, execId: String): ProgressEvent = new ProgressEvent(level, items, Option(lastTaskCount), Option(channelName), Option(execId))
+  def apply(level: String, items: Vector[sbt.internal.util.ProgressItem], lastTaskCount: Option[Int], channelName: Option[String], execId: Option[String], command: Option[String], skipIfActive: Option[Boolean]): ProgressEvent = new ProgressEvent(level, items, lastTaskCount, channelName, execId, command, skipIfActive)
+  def apply(level: String, items: Vector[sbt.internal.util.ProgressItem], lastTaskCount: Int, channelName: String, execId: String, command: String, skipIfActive: Boolean): ProgressEvent = new ProgressEvent(level, items, Option(lastTaskCount), Option(channelName), Option(execId), Option(command), Option(skipIfActive))
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/ProgressItem.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/ProgressItem.scala
new file mode 100644
index 000000000..cb3498842
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/ProgressItem.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util
+/**
+ * used by super shell
+ * @param name name of a task
+ * @param elapsedMicros current elapsed time in micro seconds
+ */
+final class ProgressItem private (
+  val name: String,
+  val elapsedMicros: Long) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ProgressItem => (this.name == x.name) && (this.elapsedMicros == x.elapsedMicros)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.util.ProgressItem".##) + name.##) + elapsedMicros.##)
+  }
+  override def toString: String = {
+    "ProgressItem(" + name + ", " + elapsedMicros + ")"
+  }
+  private[this] def copy(name: String = name, elapsedMicros: Long = elapsedMicros): ProgressItem = {
+    new ProgressItem(name, elapsedMicros)
+  }
+  def withName(name: String): ProgressItem = {
+    copy(name = name)
+  }
+  def withElapsedMicros(elapsedMicros: Long): ProgressItem = {
+    copy(elapsedMicros = elapsedMicros)
+  }
+}
+object ProgressItem {
+  
+  def apply(name: String, elapsedMicros: Long): ProgressItem = new ProgressItem(name, elapsedMicros)
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/StringEvent.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/StringEvent.scala
new file mode 100644
index 000000000..39bb8d716
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/StringEvent.scala
@@ -0,0 +1,51 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util
+final class StringEvent private (
+  val level: String,
+  val message: String,
+  channelName: Option[String],
+  execId: Option[String]) extends sbt.internal.util.AbstractEntry(channelName, execId) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: StringEvent => (this.level == x.level) && (this.message == x.message) && (this.channelName == x.channelName) && (this.execId == x.execId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.util.StringEvent".##) + level.##) + message.##) + channelName.##) + execId.##)
+  }
+  override def toString: String = {
+    "StringEvent(" + level + ", " + message + ", " + channelName + ", " + execId + ")"
+  }
+  private[this] def copy(level: String = level, message: String = message, channelName: Option[String] = channelName, execId: Option[String] = execId): StringEvent = {
+    new StringEvent(level, message, channelName, execId)
+  }
+  def withLevel(level: String): StringEvent = {
+    copy(level = level)
+  }
+  def withMessage(message: String): StringEvent = {
+    copy(message = message)
+  }
+  def withChannelName(channelName: Option[String]): StringEvent = {
+    copy(channelName = channelName)
+  }
+  def withChannelName(channelName: String): StringEvent = {
+    copy(channelName = Option(channelName))
+  }
+  def withExecId(execId: Option[String]): StringEvent = {
+    copy(execId = execId)
+  }
+  def withExecId(execId: String): StringEvent = {
+    copy(execId = Option(execId))
+  }
+}
+object StringEvent {
+  
+  def apply(level: String, message: String, channelName: Option[String], execId: Option[String]): StringEvent = new StringEvent(level, message, channelName, execId)
+  def apply(level: String, message: String, channelName: String, execId: String): StringEvent = new StringEvent(level, message, Option(channelName), Option(execId))
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/SuccessEvent.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/SuccessEvent.scala
new file mode 100644
index 000000000..12df7b1d9
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/SuccessEvent.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util
+final class SuccessEvent private (
+  val message: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SuccessEvent => (this.message == x.message)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.util.SuccessEvent".##) + message.##)
+  }
+  override def toString: String = {
+    "SuccessEvent(" + message + ")"
+  }
+  private[this] def copy(message: String = message): SuccessEvent = {
+    new SuccessEvent(message)
+  }
+  def withMessage(message: String): SuccessEvent = {
+    copy(message = message)
+  }
+}
+object SuccessEvent {
+  
+  def apply(message: String): SuccessEvent = new SuccessEvent(message)
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/TraceEvent.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/TraceEvent.scala
new file mode 100644
index 000000000..97cd54285
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/TraceEvent.scala
@@ -0,0 +1,51 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util
+final class TraceEvent private (
+  val level: String,
+  val message: Throwable,
+  channelName: Option[String],
+  execId: Option[String]) extends sbt.internal.util.AbstractEntry(channelName, execId) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TraceEvent => (this.level == x.level) && (this.message == x.message) && (this.channelName == x.channelName) && (this.execId == x.execId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.util.TraceEvent".##) + level.##) + message.##) + channelName.##) + execId.##)
+  }
+  override def toString: String = {
+    "TraceEvent(" + level + ", " + message + ", " + channelName + ", " + execId + ")"
+  }
+  private[this] def copy(level: String = level, message: Throwable = message, channelName: Option[String] = channelName, execId: Option[String] = execId): TraceEvent = {
+    new TraceEvent(level, message, channelName, execId)
+  }
+  def withLevel(level: String): TraceEvent = {
+    copy(level = level)
+  }
+  def withMessage(message: Throwable): TraceEvent = {
+    copy(message = message)
+  }
+  def withChannelName(channelName: Option[String]): TraceEvent = {
+    copy(channelName = channelName)
+  }
+  def withChannelName(channelName: String): TraceEvent = {
+    copy(channelName = Option(channelName))
+  }
+  def withExecId(execId: Option[String]): TraceEvent = {
+    copy(execId = execId)
+  }
+  def withExecId(execId: String): TraceEvent = {
+    copy(execId = Option(execId))
+  }
+}
+object TraceEvent {
+  
+  def apply(level: String, message: Throwable, channelName: Option[String], execId: Option[String]): TraceEvent = new TraceEvent(level, message, channelName, execId)
+  def apply(level: String, message: Throwable, channelName: String, execId: String): TraceEvent = new TraceEvent(level, message, Option(channelName), Option(execId))
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/AbstractEntryFormats.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/AbstractEntryFormats.scala
new file mode 100644
index 000000000..396a9cdac
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/AbstractEntryFormats.scala
@@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+
+import _root_.sjsonnew.JsonFormat
+trait AbstractEntryFormats { self: sjsonnew.BasicJsonProtocol with sbt.internal.util.codec.StringEventFormats with sbt.internal.util.codec.TraceEventFormats with sbt.internal.util.codec.ProgressItemFormats with sbt.internal.util.codec.ProgressEventFormats =>
+implicit lazy val AbstractEntryFormat: JsonFormat[sbt.internal.util.AbstractEntry] = flatUnionFormat3[sbt.internal.util.AbstractEntry, sbt.internal.util.StringEvent, sbt.internal.util.TraceEvent, sbt.internal.util.ProgressEvent]("type")
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/JsonProtocol.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/JsonProtocol.scala
new file mode 100644
index 000000000..36e6f72d2
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/JsonProtocol.scala
@@ -0,0 +1,15 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+trait JsonProtocol extends sjsonnew.BasicJsonProtocol
+  with sbt.internal.util.codec.StringEventFormats
+  with sbt.internal.util.codec.TraceEventFormats
+  with sbt.internal.util.codec.ProgressItemFormats
+  with sbt.internal.util.codec.ProgressEventFormats
+  with sbt.internal.util.codec.AbstractEntryFormats
+  with sbt.internal.util.codec.SuccessEventFormats
+  with sbt.internal.util.codec.LogOptionFormats
+object JsonProtocol extends JsonProtocol
\ No newline at end of file
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/LogOptionFormats.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/LogOptionFormats.scala
new file mode 100644
index 000000000..6de8174bd
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/LogOptionFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait LogOptionFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val LogOptionFormat: JsonFormat[sbt.internal.util.LogOption] = new JsonFormat[sbt.internal.util.LogOption] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.LogOption = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.readString(__js) match {
+        case "Always" => sbt.internal.util.LogOption.Always
+        case "Never" => sbt.internal.util.LogOption.Never
+        case "Auto" => sbt.internal.util.LogOption.Auto
+      }
+      case None =>
+      deserializationError("Expected JsString but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.util.LogOption, builder: Builder[J]): Unit = {
+    val str = obj match {
+      case sbt.internal.util.LogOption.Always => "Always"
+      case sbt.internal.util.LogOption.Never => "Never"
+      case sbt.internal.util.LogOption.Auto => "Auto"
+    }
+    builder.writeString(str)
+  }
+}
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressEventFormats.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressEventFormats.scala
new file mode 100644
index 000000000..ea9c7b825
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressEventFormats.scala
@@ -0,0 +1,39 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ProgressEventFormats { self: sbt.internal.util.codec.ProgressItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ProgressEventFormat: JsonFormat[sbt.internal.util.ProgressEvent] = new JsonFormat[sbt.internal.util.ProgressEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.ProgressEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val level = unbuilder.readField[String]("level")
+      val items = unbuilder.readField[Vector[sbt.internal.util.ProgressItem]]("items")
+      val lastTaskCount = unbuilder.readField[Option[Int]]("lastTaskCount")
+      val channelName = unbuilder.readField[Option[String]]("channelName")
+      val execId = unbuilder.readField[Option[String]]("execId")
+      val command = unbuilder.readField[Option[String]]("command")
+      val skipIfActive = unbuilder.readField[Option[Boolean]]("skipIfActive")
+      unbuilder.endObject()
+      sbt.internal.util.ProgressEvent(level, items, lastTaskCount, channelName, execId, command, skipIfActive)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.util.ProgressEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("level", obj.level)
+    builder.addField("items", obj.items)
+    builder.addField("lastTaskCount", obj.lastTaskCount)
+    builder.addField("channelName", obj.channelName)
+    builder.addField("execId", obj.execId)
+    builder.addField("command", obj.command)
+    builder.addField("skipIfActive", obj.skipIfActive)
+    builder.endObject()
+  }
+}
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressItemFormats.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressItemFormats.scala
new file mode 100644
index 000000000..580e72d98
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/ProgressItemFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ProgressItemFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ProgressItemFormat: JsonFormat[sbt.internal.util.ProgressItem] = new JsonFormat[sbt.internal.util.ProgressItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.ProgressItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val name = unbuilder.readField[String]("name")
+      val elapsedMicros = unbuilder.readField[Long]("elapsedMicros")
+      unbuilder.endObject()
+      sbt.internal.util.ProgressItem(name, elapsedMicros)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.util.ProgressItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("elapsedMicros", obj.elapsedMicros)
+    builder.endObject()
+  }
+}
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/StringEventFormats.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/StringEventFormats.scala
new file mode 100644
index 000000000..abdcdf681
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/StringEventFormats.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait StringEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val StringEventFormat: JsonFormat[sbt.internal.util.StringEvent] = new JsonFormat[sbt.internal.util.StringEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.StringEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val level = unbuilder.readField[String]("level")
+      val message = unbuilder.readField[String]("message")
+      val channelName = unbuilder.readField[Option[String]]("channelName")
+      val execId = unbuilder.readField[Option[String]]("execId")
+      unbuilder.endObject()
+      sbt.internal.util.StringEvent(level, message, channelName, execId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.util.StringEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("level", obj.level)
+    builder.addField("message", obj.message)
+    builder.addField("channelName", obj.channelName)
+    builder.addField("execId", obj.execId)
+    builder.endObject()
+  }
+}
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/SuccessEventFormats.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/SuccessEventFormats.scala
new file mode 100644
index 000000000..af6a35e39
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/SuccessEventFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SuccessEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val SuccessEventFormat: JsonFormat[sbt.internal.util.SuccessEvent] = new JsonFormat[sbt.internal.util.SuccessEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.SuccessEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val message = unbuilder.readField[String]("message")
+      unbuilder.endObject()
+      sbt.internal.util.SuccessEvent(message)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.util.SuccessEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("message", obj.message)
+    builder.endObject()
+  }
+}
+}
diff --git a/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/TraceEventFormats.scala b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/TraceEventFormats.scala
new file mode 100644
index 000000000..bef483c6c
--- /dev/null
+++ b/internal/util-logging/src/main/contraband-scala/sbt/internal/util/codec/TraceEventFormats.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.util.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TraceEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TraceEventFormat: JsonFormat[sbt.internal.util.TraceEvent] = new JsonFormat[sbt.internal.util.TraceEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.util.TraceEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val level = unbuilder.readField[String]("level")
+      val message = unbuilder.readField[Throwable]("message")
+      val channelName = unbuilder.readField[Option[String]]("channelName")
+      val execId = unbuilder.readField[Option[String]]("execId")
+      unbuilder.endObject()
+      sbt.internal.util.TraceEvent(level, message, channelName, execId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.util.TraceEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("level", obj.level)
+    builder.addField("message", obj.message)
+    builder.addField("channelName", obj.channelName)
+    builder.addField("execId", obj.execId)
+    builder.endObject()
+  }
+}
+}
diff --git a/internal/util-logging/src/main/contraband/interface.contra.txt b/internal/util-logging/src/main/contraband/interface.contra.txt
new file mode 100644
index 000000000..3b5ed4986
--- /dev/null
+++ b/internal/util-logging/src/main/contraband/interface.contra.txt
@@ -0,0 +1,33 @@
+package sbt.internal.util
+@target(Java)
+@codecPackage("sbt.internal.util.codec")
+@fullCodec("JsonProtocol")
+
+enum Severity
+{
+  Info, Warn, Error
+}
+
+type Position {
+  line: Int
+  lineContent: String!
+  offset: Int
+  pointer: Int
+  pointerSpace: String
+  sourcePath: String
+  sourceFile: java.io.File
+  startOffset: Int
+  endOffset: Int
+  startLine: Int
+  startColumn: Int
+  endLine: Int
+  endColumn: Int
+}
+
+type Problem {
+  category: String!
+  severity: Severity!
+  message: String!
+  position: Position!
+  rendered: String
+}
diff --git a/internal/util-logging/src/main/contraband/logging.contra b/internal/util-logging/src/main/contraband/logging.contra
new file mode 100644
index 000000000..447daa3d0
--- /dev/null
+++ b/internal/util-logging/src/main/contraband/logging.contra
@@ -0,0 +1,53 @@
+package sbt.internal.util
+@target(Scala)
+@codecPackage("sbt.internal.util.codec")
+@fullCodec("JsonProtocol")
+
+interface AbstractEntry {
+  channelName: String
+  execId: String
+}
+
+type StringEvent implements sbt.internal.util.AbstractEntry {
+  level: String!
+  message: String!
+  channelName: String
+  execId: String
+}
+
+type TraceEvent implements sbt.internal.util.AbstractEntry {
+  level: String!
+  message: Throwable!
+  channelName: String
+  execId: String
+}
+
+## used by super shell
+type ProgressEvent implements sbt.internal.util.AbstractEntry {
+  level: String!
+  items: [sbt.internal.util.ProgressItem]
+  lastTaskCount: Int
+  channelName: String
+  execId: String
+  command: String @since("1.4.0")
+  skipIfActive: Boolean @since("1.4.0")
+}
+
+## used by super shell
+type ProgressItem {
+  ## name of a task
+  name: String!
+  ## current elapsed time in micro seconds
+  elapsedMicros: Long!
+}
+
+type SuccessEvent {
+  message: String!
+}
+
+## value for logging options like color
+enum LogOption {
+  Always
+  Never
+  Auto
+}
diff --git a/internal/util-logging/src/main/java/sbt/internal/util/DeprecatedJLine.java b/internal/util-logging/src/main/java/sbt/internal/util/DeprecatedJLine.java
new file mode 100644
index 000000000..4e091a2a5
--- /dev/null
+++ b/internal/util-logging/src/main/java/sbt/internal/util/DeprecatedJLine.java
@@ -0,0 +1,21 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util;
+
+import org.jline.terminal.TerminalBuilder;
+
+/**
+ * This exists to a provide a wrapper to TerminalBuilder.setTerminalOverride that will not emit a
+ * deprecation warning when called from scala.
+ */
+public class DeprecatedJLine {
+  @SuppressWarnings("deprecation")
+  public static void setTerminalOverride(final org.jline.terminal.Terminal terminal) {
+    TerminalBuilder.setTerminalOverride(terminal);
+  }
+}
diff --git a/internal/util-logging/src/main/scala/com/github/ghik/silencer/silent.scala b/internal/util-logging/src/main/scala/com/github/ghik/silencer/silent.scala
new file mode 100644
index 000000000..0918e75aa
--- /dev/null
+++ b/internal/util-logging/src/main/scala/com/github/ghik/silencer/silent.scala
@@ -0,0 +1,17 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package com.github.ghik.silencer
+
+import scala.annotation.Annotation
+
+/**
+ * When silencer compiler plugin is enabled, this annotation suppresses all warnings emitted by scalac for some portion
+ * of source code. It can be applied on any definition (`class`, def`, `val`, `var`, etc.) or on arbitrary expression,
+ * e.g. {123; 456}: @silent`
+ */
+class silent extends Annotation
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala
new file mode 100644
index 000000000..802e60a42
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala
@@ -0,0 +1,23 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+
+/** Implements the level-setting methods of Logger.*/
+abstract class BasicLogger extends AbstractLogger {
+  private var traceEnabledVar: Int = java.lang.Integer.MAX_VALUE
+  private var level: Level.Value = Level.Info
+  private var successEnabledVar = true
+  def successEnabled: Boolean = synchronized { successEnabledVar }
+  def setSuccessEnabled(flag: Boolean): Unit = synchronized { successEnabledVar = flag }
+  def getLevel: Level.Value = synchronized { level }
+  def setLevel(newLevel: Level.Value): Unit = synchronized { level = newLevel }
+  def setTrace(level: Int): Unit = synchronized { traceEnabledVar = level }
+  def getTrace: Int = synchronized { traceEnabledVar }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala
new file mode 100644
index 000000000..827cfa82f
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala
@@ -0,0 +1,251 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+import scala.collection.mutable.ListBuffer
+import org.apache.logging.log4j.core.{ LogEvent => XLogEvent }
+import org.apache.logging.log4j.core.appender.AbstractAppender
+import org.apache.logging.log4j.core.layout.PatternLayout
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicReference
+
+object BufferedAppender {
+  def generateName: String =
+    "buffered-" + generateId.incrementAndGet
+
+  private val generateId: AtomicInteger = new AtomicInteger
+
+  def apply(delegate: Appender): BufferedAppender =
+    apply(generateName, delegate)
+
+  def apply(name: String, delegate: Appender): BufferedAppender =
+    new BufferedAppender(name, delegate)
+}
+
+/**
+ * An appender that can buffer the logging done on it and then can flush the buffer
+ * to the delegate appender provided in the constructor.  Use 'record()' to
+ * start buffering and then 'play' to flush the buffer to the backing appender.
+ *  The logging level set at the time a message is originally logged is used, not
+ * the level at the time 'play' is called.
+ */
+class BufferedAppender(override val name: String, delegate: Appender) extends Appender {
+  override def close(): Unit = log4j.get match {
+    case null =>
+    case a    => a.stop()
+  }
+  override private[sbt] def properties: ConsoleAppender.Properties = delegate.properties
+  override private[sbt] def suppressedMessage: SuppressedTraceContext => Option[String] =
+    delegate.suppressedMessage
+  private[this] val log4j = new AtomicReference[AbstractAppender]
+  override private[sbt] def toLog4J = log4j.get match {
+    case null =>
+      val a = new AbstractAppender(
+        delegate.name + "-log4j",
+        null,
+        PatternLayout.createDefaultLayout(),
+        true,
+        Array.empty
+      ) {
+        start()
+        override def append(event: XLogEvent): Unit = {
+          if (recording) {
+            Util.ignoreResult(buffer.add(Left(event.toImmutable)))
+          } else {
+            delegate.toLog4J.append(event)
+          }
+        }
+      }
+      log4j.set(a)
+      a
+    case a => a
+  }
+
+  private[this] val buffer =
+    new java.util.Vector[Either[XLogEvent, (Level.Value, Option[String], Option[ObjectEvent[_]])]]
+  private[this] var recording = false
+
+  override def appendLog(level: Level.Value, message: => String): Unit = {
+    if (recording) Util.ignoreResult(buffer.add(Right((level, Some(message), None))))
+    else delegate.appendLog(level, message)
+  }
+  override private[sbt] def appendObjectEvent[T](
+      level: Level.Value,
+      message: => ObjectEvent[T]
+  ): Unit = {
+    if (recording) Util.ignoreResult(buffer.add(Right(((level, None, Some(message))))))
+    else delegate.appendObjectEvent(level, message)
+  }
+
+  /** Enables buffering. */
+  def record() = synchronized { recording = true }
+  def buffer[T](f: => T): T = {
+    record()
+    try {
+      f
+    } finally {
+      stopQuietly()
+    }
+  }
+  def bufferQuietly[T](f: => T): T = {
+    record()
+    try {
+      val result = f
+      clearBuffer()
+      result
+    } catch { case e: Throwable => stopQuietly(); throw e }
+  }
+  def stopQuietly() = synchronized {
+    try {
+      stopBuffer()
+    } catch { case _: Exception => () }
+  }
+
+  /**
+   * Flushes the buffer to the delegate logger.  This method calls logAll on the delegate
+   * so that the messages are written consecutively. The buffer is cleared in the process.
+   */
+  def play(): Unit =
+    synchronized {
+      buffer.forEach {
+        case Right((l, Some(m), _))  => delegate.appendLog(l, m)
+        case Right((l, _, Some(oe))) => delegate.appendObjectEvent(l, oe)
+        case Left(x)                 => delegate.toLog4J.append(x)
+        case _                       =>
+      }
+      buffer.clear()
+    }
+
+  /** Clears buffered events and disables buffering. */
+  def clearBuffer(): Unit = synchronized { buffer.clear(); recording = false }
+
+  /** Plays buffered events and disables buffering. */
+  def stopBuffer(): Unit = synchronized { play(); clearBuffer() }
+
+}
+
+/**
+ * A logger that can buffer the logging done on it and then can flush the buffer
+ * to the delegate logger provided in the constructor.  Use 'startRecording' to
+ * start buffering and then 'play' from to flush the buffer to the backing logger.
+ *  The logging level set at the time a message is originally logged is used, not
+ * the level at the time 'play' is called.
+ *
+ * This class assumes that it is the only client of the delegate logger.
+ */
+class BufferedLogger(delegate: AbstractLogger) extends BasicLogger {
+  private[this] val buffer = new ListBuffer[LogEvent]
+  private[this] var recording = false
+
+  /** Enables buffering. */
+  def record() = synchronized { recording = true }
+  def buffer[T](f: => T): T = {
+    record()
+    try {
+      f
+    } finally {
+      stopQuietly()
+    }
+  }
+  def bufferQuietly[T](f: => T): T = {
+    record()
+    try {
+      val result = f
+      clear()
+      result
+    } catch { case e: Throwable => stopQuietly(); throw e }
+  }
+  def stopQuietly() = synchronized {
+    try {
+      stop()
+    } catch { case _: Exception => () }
+  }
+
+  /**
+   * Flushes the buffer to the delegate logger.  This method calls logAll on the delegate
+   * so that the messages are written consecutively. The buffer is cleared in the process.
+   */
+  def play(): Unit = synchronized { delegate.logAll(buffer.toList); buffer.clear() }
+
+  /** Clears buffered events and disables buffering. */
+  def clear(): Unit = synchronized { buffer.clear(); recording = false }
+
+  /** Plays buffered events and disables buffering. */
+  def stop(): Unit = synchronized { play(); clear() }
+
+  @deprecated("No longer used.", "1.0.0")
+  override def ansiCodesSupported = delegate.ansiCodesSupported
+
+  override def setLevel(newLevel: Level.Value): Unit = synchronized {
+    super.setLevel(newLevel)
+    if (recording)
+      buffer += new SetLevel(newLevel)
+    else
+      delegate.setLevel(newLevel)
+    ()
+  }
+
+  override def setSuccessEnabled(flag: Boolean): Unit = synchronized {
+    super.setSuccessEnabled(flag)
+    if (recording)
+      buffer += new SetSuccess(flag)
+    else
+      delegate.setSuccessEnabled(flag)
+    ()
+  }
+
+  override def setTrace(level: Int): Unit = synchronized {
+    super.setTrace(level)
+    if (recording)
+      buffer += new SetTrace(level)
+    else
+      delegate.setTrace(level)
+    ()
+  }
+
+  def trace(t: => Throwable): Unit = doBufferableIf(traceEnabled, new Trace(t), _.trace(t))
+
+  def success(message: => String): Unit =
+    doBufferable(Level.Info, new Success(message), _.success(message))
+
+  def log(level: Level.Value, message: => String): Unit =
+    doBufferable(level, new Log(level, message), _.log(level, message))
+
+  def logAll(events: Seq[LogEvent]): Unit = synchronized {
+    if (recording)
+      buffer ++= events
+    else
+      delegate.logAll(events)
+    ()
+  }
+
+  def control(event: ControlEvent.Value, message: => String): Unit =
+    doBufferable(Level.Info, new ControlEvent(event, message), _.control(event, message))
+
+  private def doBufferable(
+      level: Level.Value,
+      appendIfBuffered: => LogEvent,
+      doUnbuffered: AbstractLogger => Unit
+  ): Unit =
+    doBufferableIf(atLevel(level), appendIfBuffered, doUnbuffered)
+
+  private def doBufferableIf(
+      condition: => Boolean,
+      appendIfBuffered: => LogEvent,
+      doUnbuffered: AbstractLogger => Unit
+  ): Unit = synchronized {
+    if (condition) {
+      if (recording)
+        buffer += appendIfBuffered
+      else
+        doUnbuffered(delegate)
+    }
+    ()
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleAppender.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleAppender.scala
new file mode 100644
index 000000000..7cfed50e6
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleAppender.scala
@@ -0,0 +1,592 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.{ PrintStream, PrintWriter }
+import java.lang.StringBuilder
+import java.nio.channels.ClosedChannelException
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicInteger }
+
+import org.apache.logging.log4j.core.appender.AbstractAppender
+import org.apache.logging.log4j.core.{ Appender => XAppender, LogEvent => XLogEvent }
+import org.apache.logging.log4j.message.{ Message, ObjectMessage, ReusableObjectMessage }
+import org.apache.logging.log4j.{ Level => XLevel }
+import sbt.internal.util.ConsoleAppender._
+import sbt.util._
+import org.apache.logging.log4j.core.AbstractLogEvent
+import org.apache.logging.log4j.message.StringFormatterMessageFactory
+import java.util.concurrent.atomic.AtomicReference
+
+object ConsoleLogger {
+  // These are provided so other modules do not break immediately.
+  @deprecated("Use EscHelpers.ESC instead", "0.13.x")
+  final val ESC = EscHelpers.ESC
+  @deprecated("Use EscHelpers.isEscapeTerminator instead", "0.13.x")
+  private[sbt] def isEscapeTerminator(c: Char): Boolean = EscHelpers.isEscapeTerminator(c)
+  @deprecated("Use EscHelpers.hasEscapeSequence instead", "0.13.x")
+  def hasEscapeSequence(s: String): Boolean = EscHelpers.hasEscapeSequence(s)
+  @deprecated("Use EscHelpers.removeEscapeSequences instead", "0.13.x")
+  def removeEscapeSequences(s: String): String = EscHelpers.removeEscapeSequences(s)
+  @deprecated("Use ConsoleAppender.formatEnabledInEnv instead", "0.13.x")
+  lazy val formatEnabled = ConsoleAppender.formatEnabledInEnv
+  @deprecated("Use ConsoleAppender.noSuppressedMessage instead", "0.13.x")
+  val noSuppressedMessage = ConsoleAppender.noSuppressedMessage
+
+  /**
+   * A new `ConsoleLogger` that logs to `out`.
+   *
+   * @param out Where to log the messages.
+   * @return A new `ConsoleLogger` that logs to `out`.
+   */
+  def apply(out: PrintStream): ConsoleLogger = apply(ConsoleOut.printStreamOut(out))
+
+  /**
+   * A new `ConsoleLogger` that logs to `out`.
+   *
+   * @param out Where to log the messages.
+   * @return A new `ConsoleLogger` that logs to `out`.
+   */
+  def apply(out: PrintWriter): ConsoleLogger = apply(ConsoleOut.printWriterOut(out))
+
+  /**
+   * A new `ConsoleLogger` that logs to `out`.
+   *
+   * @param out                Where to log the messages.
+   * @param ansiCodesSupported `true` if `out` supported ansi codes, `false` otherwise.
+   * @param useFormat          `true` to show formatting, `false` to remove it from messages.
+   * @param suppressedMessage  How to show suppressed stack traces.
+   * @return A new `ConsoleLogger` that logs to `out`.
+   */
+  def apply(
+      out: ConsoleOut = ConsoleOut.systemOut,
+      ansiCodesSupported: Boolean = Terminal.isAnsiSupported,
+      useFormat: Boolean = Terminal.isColorEnabled,
+      suppressedMessage: SuppressedTraceContext => Option[String] =
+        ConsoleAppender.noSuppressedMessage
+  ): ConsoleLogger =
+    new ConsoleLogger(out, ansiCodesSupported, useFormat, suppressedMessage)
+}
+
+/**
+ * A logger that logs to the console.  On supported systems, the level labels are
+ * colored.
+ */
+class ConsoleLogger private[ConsoleLogger] (
+    out: ConsoleOut,
+    override val ansiCodesSupported: Boolean,
+    useFormat: Boolean,
+    suppressedMessage: SuppressedTraceContext => Option[String]
+) extends BasicLogger {
+
+  private[sbt] val appender: Appender =
+    ConsoleAppender(generateName(), out, ansiCodesSupported, useFormat, suppressedMessage)
+
+  override def control(event: ControlEvent.Value, message: => String): Unit =
+    appender.control(event, message)
+
+  override def log(level: Level.Value, message: => String): Unit =
+    if (atLevel(level)) {
+      appender.appendLog(level, message)
+    }
+
+  override def success(message: => String): Unit =
+    if (successEnabled) {
+      appender.success(message)
+    }
+
+  override def trace(t: => Throwable): Unit =
+    appender.trace(t, getTrace)
+
+  override def logAll(events: Seq[LogEvent]) = events.foreach(log)
+}
+
+object ConsoleAppender {
+  private[sbt] def cursorLeft(n: Int): String = s"\u001B[${n}D"
+  private[sbt] def cursorUp(n: Int): String = s"\u001B[${n}A"
+  private[sbt] def cursorDown(n: Int): String = s"\u001B[${n}B"
+  private[sbt] def scrollUp(n: Int): String = s"\u001B[${n}S"
+  private[sbt] def clearScreen(n: Int): String = s"\u001B[${n}J"
+  private[sbt] def clearLine(n: Int): String = s"\u001B[${n}K"
+  private[sbt] final val DeleteLine = "\u001B[2K"
+  private[sbt] final val ClearScreenAfterCursor = clearScreen(0)
+  private[sbt] final val CursorLeft1000 = cursorLeft(1000)
+  private[sbt] final val CursorDown1 = cursorDown(1)
+  private[sbt] final val ClearPromptLine = CursorLeft1000 + ClearScreenAfterCursor
+  private[this] val showProgressHolder: AtomicBoolean = new AtomicBoolean(false)
+  def setShowProgress(b: Boolean): Unit = showProgressHolder.set(b)
+  def showProgress: Boolean = showProgressHolder.get
+  private[sbt] trait Properties {
+    def isAnsiSupported: Boolean
+    def isColorEnabled: Boolean
+    def out: ConsoleOut
+  }
+  private[sbt] object Properties {
+    def from(terminal: Terminal): Properties = new Properties {
+      override def isAnsiSupported: Boolean = terminal.isAnsiSupported
+      override def isColorEnabled: Boolean = terminal.isColorEnabled
+      override def out = ConsoleOut.terminalOut(terminal)
+    }
+    def from(o: ConsoleOut, ansi: Boolean, color: Boolean): Properties = new Properties {
+      override def isAnsiSupported: Boolean = ansi
+      override def isColorEnabled: Boolean = color
+      override def out = o
+    }
+  }
+
+  /** Hide stack trace altogether. */
+  val noSuppressedMessage = (_: SuppressedTraceContext) => None
+
+  /**
+   * Indicates whether formatting has been disabled in environment variables.
+   * 1. -Dsbt.log.noformat=true means no formatting.
+   * 2. -Dsbt.color=always/auto/never/true/false
+   * 3. -Dsbt.colour=always/auto/never/true/false
+   * 4. -Dsbt.log.format=always/auto/never/true/false
+   */
+  @deprecated("Use Terminal.isAnsiSupported or Terminal.isColorEnabled", "1.4.0")
+  lazy val formatEnabledInEnv: Boolean = Terminal.isAnsiSupported
+
+  private[sbt] def parseLogOption(s: String): LogOption = Terminal.parseLogOption(s) match {
+    case Some(true)  => LogOption.Always
+    case Some(false) => LogOption.Never
+    case _           => LogOption.Auto
+  }
+
+  private[this] val generateId: AtomicInteger = new AtomicInteger
+
+  /**
+   * A new `ConsoleAppender` that writes to standard output.
+   *
+   * @return A new `ConsoleAppender` that writes to standard output.
+   */
+  def apply(): Appender = apply(ConsoleOut.systemOut)
+
+  /**
+   * A new `ConsoleAppender` that appends log message to `out`.
+   *
+   * @param out Where to write messages.
+   * @return A new `ConsoleAppender`.
+   */
+  def apply(out: PrintStream): Appender = apply(ConsoleOut.printStreamOut(out))
+
+  /**
+   * A new `ConsoleAppender` that appends log messages to `out`.
+   *
+   * @param out Where to write messages.
+   * @return A new `ConsoleAppender`.
+   */
+  def apply(out: PrintWriter): Appender = apply(ConsoleOut.printWriterOut(out))
+
+  /**
+   * A new `ConsoleAppender` that writes to `out`.
+   *
+   * @param out Where to write messages.
+   * @return A new `ConsoleAppender that writes to `out`.
+   */
+  def apply(out: ConsoleOut): Appender = apply(generateName(), out)
+
+  /**
+   * A new `ConsoleAppender` identified by `name`, and that writes to standard output.
+   *
+   * @param name An identifier for the `ConsoleAppender`.
+   * @return A new `ConsoleAppender` that writes to standard output.
+   */
+  def apply(name: String): Appender = apply(name, ConsoleOut.systemOut)
+
+  /**
+   * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
+   *
+   * @param name An identifier for the `ConsoleAppender`.
+   * @param out Where to write messages.
+   * @return A new `ConsoleAppender` that writes to `out`.
+   */
+  def apply(name: String, out: ConsoleOut): Appender = apply(name, out, Terminal.isAnsiSupported)
+
+  /**
+   * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
+   *
+   * @param name              An identifier for the `ConsoleAppender`.
+   * @param out               Where to write messages.
+   * @param suppressedMessage How to handle stack traces.
+   * @return A new `ConsoleAppender` that writes to `out`.
+   */
+  def apply(
+      name: String,
+      out: ConsoleOut,
+      suppressedMessage: SuppressedTraceContext => Option[String]
+  ): Appender = {
+    val ansi = Terminal.isAnsiSupported
+    apply(name, out, ansi, ansi, suppressedMessage)
+  }
+
+  /**
+   * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
+   *
+   * @param name      An identifier for the `ConsoleAppender`.
+   * @param out       Where to write messages.
+   * @param useFormat `true` to enable format (color, bold, etc.), `false` to remove formatting.
+   * @return A new `ConsoleAppender` that writes to `out`.
+   */
+  def apply(name: String, out: ConsoleOut, useFormat: Boolean): Appender =
+    apply(name, out, useFormat || Terminal.isAnsiSupported, useFormat, noSuppressedMessage)
+
+  /**
+   * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
+   *
+   * @param name      An identifier for the `ConsoleAppender`.
+   * @param terminal  The terminal to which this appender corresponds
+   * @return A new `ConsoleAppender` that writes to `out`.
+   */
+  def apply(name: String, terminal: Terminal): Appender = {
+    new ConsoleAppender(name, Properties.from(terminal), noSuppressedMessage)
+  }
+
+  /**
+   * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
+   *
+   * @param name      An identifier for the `ConsoleAppender`.
+   * @param terminal  The terminal to which this appender corresponds
+   * @param suppressedMessage How to handle stack traces.
+   * @return A new `ConsoleAppender` that writes to `out`.
+   */
+  def apply(
+      name: String,
+      terminal: Terminal,
+      suppressedMessage: SuppressedTraceContext => Option[String]
+  ): Appender = {
+    new ConsoleAppender(name, Properties.from(terminal), suppressedMessage)
+  }
+
+  /**
+   * A new `ConsoleAppender` identified by `name`, and that writes to `out`.
+   *
+   * @param name               An identifier for the `ConsoleAppender`.
+   * @param out                Where to write messages.
+   * @param ansiCodesSupported `true` if the output stream supports ansi codes, `false` otherwise.
+   * @param useFormat          `true` to enable format (color, bold, etc.), `false` to remove
+   *                           formatting.
+   * @return A new `ConsoleAppender` that writes to `out`.
+   */
+  def apply(
+      name: String,
+      out: ConsoleOut,
+      ansiCodesSupported: Boolean,
+      useFormat: Boolean,
+      suppressedMessage: SuppressedTraceContext => Option[String]
+  ): Appender = {
+    new ConsoleAppender(
+      name,
+      Properties.from(out, ansiCodesSupported, useFormat),
+      suppressedMessage
+    )
+  }
+
+  /**
+   * Converts the Log4J `level` to the corresponding sbt level.
+   *
+   * @param level A level, as represented by Log4J.
+   * @return The corresponding level in sbt's world.
+   */
+  def toLevel(level: XLevel): Level.Value =
+    level match {
+      case XLevel.OFF   => Level.Debug
+      case XLevel.FATAL => Level.Error
+      case XLevel.ERROR => Level.Error
+      case XLevel.WARN  => Level.Warn
+      case XLevel.INFO  => Level.Info
+      case XLevel.DEBUG => Level.Debug
+      case _            => Level.Debug
+    }
+
+  /**
+   * Converts the sbt `level` to the corresponding Log4J level.
+   *
+   * @param level A level, as represented by sbt.
+   * @return The corresponding level in Log4J's world.
+   */
+  def toXLevel(level: Level.Value): XLevel =
+    level match {
+      case Level.Error => XLevel.ERROR
+      case Level.Warn  => XLevel.WARN
+      case Level.Info  => XLevel.INFO
+      case Level.Debug => XLevel.DEBUG
+    }
+
+  private[sbt] def generateName(): String = "out-" + generateId.incrementAndGet
+
+  private[this] def ansiSupported: Boolean = Terminal.console.isAnsiSupported
+}
+
+// See http://stackoverflow.com/questions/24205093/how-to-create-a-custom-appender-in-log4j2
+// for custom appender using Java.
+// http://logging.apache.org/log4j/2.x/manual/customconfig.html
+// https://logging.apache.org/log4j/2.x/log4j-core/apidocs/index.html
+
+/**
+ * A logger that logs to the console.  On supported systems, the level labels are
+ * colored.
+ *
+ * This logger is not thread-safe.
+ */
+class ConsoleAppender(
+    override private[sbt] val name: String,
+    override private[sbt] val properties: Properties,
+    override private[sbt] val suppressedMessage: SuppressedTraceContext => Option[String]
+) extends Appender {
+  private[this] val log4j = new AtomicReference[XAppender](null)
+  override private[sbt] lazy val toLog4J = log4j.get match {
+    case null =>
+      log4j.synchronized {
+        log4j.get match {
+          case null =>
+            val l = new Log4JConsoleAppender(name, properties, suppressedMessage, { event =>
+              val level = ConsoleAppender.toLevel(event.getLevel)
+              val message = event.getMessage
+              try appendMessage(level, message)
+              catch { case _: ClosedChannelException => }
+            })
+            log4j.set(l)
+            l
+          case l => l
+        }
+      }
+  }
+  override def close(): Unit = log4j.get match {
+    case null =>
+    case a    => a.stop()
+  }
+}
+trait Appender extends AutoCloseable {
+  private[sbt] def name: String
+  private[sbt] def properties: Properties
+  private[sbt] def suppressedMessage: SuppressedTraceContext => Option[String]
+  import scala.Console.{ BLUE, GREEN, RED, YELLOW }
+
+  private[util] def out: ConsoleOut = properties.out
+  private[util] def ansiCodesSupported: Boolean = properties.isAnsiSupported
+  private[util] def useFormat: Boolean = properties.isColorEnabled
+
+  private def reset: String = scala.Console.RESET
+
+  private val SUCCESS_LABEL_COLOR = GREEN
+  private val SUCCESS_MESSAGE_COLOR = reset
+  private val NO_COLOR = reset
+
+  private var traceEnabledVar: Int = Int.MaxValue
+
+  def setTrace(level: Int): Unit = synchronized { traceEnabledVar = level }
+
+  /**
+   * Returns the number of lines for stacktrace.
+   */
+  def getTrace: Int = synchronized { traceEnabledVar }
+
+  private[sbt] def toLog4J: XAppender
+
+  /**
+   * Logs the stack trace of `t`, possibly shortening it.
+   *
+   * The `traceLevel` parameter configures how the stack trace will be shortened.
+   * See `StackTrace.trimmed`.
+   *
+   * @param t          The `Throwable` whose stack trace to log.
+   * @param traceLevel How to shorten the stack trace.
+   */
+  def trace(t: => Throwable, traceLevel: Int): Unit = {
+    if (traceLevel >= 0)
+      write(StackTrace.trimmed(t, traceLevel))
+    if (traceLevel <= 2) {
+      val ctx = new SuppressedTraceContext(traceLevel, ansiCodesSupported && useFormat)
+      for (msg <- suppressedMessage(ctx))
+        appendLog(NO_COLOR, "trace", NO_COLOR, msg)
+    }
+  }
+
+  /**
+   * Logs a `ControlEvent` to the log.
+   *
+   * @param event   The kind of `ControlEvent`.
+   * @param message The message to log.
+   */
+  def control(event: ControlEvent.Value, message: => String): Unit =
+    appendLog(labelColor(Level.Info), Level.Info.toString, BLUE, message)
+
+  /**
+   * Appends the message `message` to the to the log at level `level`.
+   *
+   * @param level   The importance level of the message.
+   * @param message The message to log.
+   */
+  def appendLog(level: Level.Value, message: => String): Unit = {
+    appendLog(labelColor(level), level.toString, NO_COLOR, message)
+  }
+
+  /**
+   * Select the right color for the label given `level`.
+   *
+   * @param level The label to consider to select the color.
+   * @return The color to use to color the label.
+   */
+  private def labelColor(level: Level.Value): String =
+    level match {
+      case Level.Error => RED
+      case Level.Warn  => YELLOW
+      case _           => NO_COLOR
+    }
+
+  /**
+   * Appends a full message to the log. Each line is prefixed with `[$label]`, written in
+   * `labelColor` if formatting is enabled. The lines of the messages are colored with
+   * `messageColor` if formatting is enabled.
+   *
+   * @param labelColor   The color to use to format the label.
+   * @param label        The label to prefix each line with. The label is shown between square
+   *                     brackets.
+   * @param messageColor The color to use to format the message.
+   * @param message      The message to write.
+   */
+  private def appendLog(
+      labelColor: String,
+      label: String,
+      messageColor: String,
+      message: String
+  ): Unit =
+    try {
+      // according to https://github.com/sbt/sbt/issues/5608, sometimes we get a null message
+      if (message == null) ()
+      else {
+        val len = labelColor.length + label.length + messageColor.length + reset.length * 3
+        val builder: StringBuilder = new StringBuilder(len)
+        message.linesIterator.foreach { line =>
+          builder.ensureCapacity(len + line.length + 4)
+          builder.setLength(0)
+
+          def fmted(a: String, b: String) = {
+            if (useFormat) builder.append(reset).append(a).append(b).append(reset)
+            else builder.append(b)
+          }
+
+          if (useFormat) builder.append(reset)
+          builder.append('[')
+          fmted(labelColor, label)
+          builder.append("] ")
+          fmted(messageColor, line)
+          write(builder.toString)
+        }
+      }
+    } catch { case _: InterruptedException => }
+
+  // success is called by ConsoleLogger.
+  private[sbt] def success(message: => String): Unit = {
+    appendLog(SUCCESS_LABEL_COLOR, Level.SuccessLabel, SUCCESS_MESSAGE_COLOR, message)
+  }
+
+  private def write(msg: String): Unit = {
+    // There is no api for removing only colors but not other ansi escape sequences
+    // so we do nothing if useFormat is false but ansiCodesSupported is true which is
+    // a rare use case but if ansiCodesSupported is true, color codes should work so
+    // the output may have unwanted colors but it would still be legible. This should
+    // only be relevant if the log message string itself contains ansi escape sequences
+    // other than color codes which is very unlikely.
+    val toWrite = if ((!ansiCodesSupported || !useFormat) && msg.getBytes.contains(27.toByte)) {
+      val (bytes, len) =
+        EscHelpers.strip(msg.getBytes, stripAnsi = !ansiCodesSupported, stripColor = !useFormat)
+      new String(bytes, 0, len)
+    } else msg
+    out.println(toWrite)
+  }
+
+  private[util] def appendMessage(level: Level.Value, msg: Message): Unit =
+    msg match {
+      case o: ObjectMessage         => appendMessageContent(level, o.getParameter)
+      case o: ReusableObjectMessage => appendMessageContent(level, o.getParameter)
+      case _                        => appendLog(level, msg.getFormattedMessage)
+    }
+
+  private def appendTraceEvent(te: TraceEvent): Unit = {
+    val traceLevel = getTrace
+    if (traceLevel >= 0) {
+      val throwableShowLines: ShowLines[Throwable] =
+        ShowLines[Throwable]((t: Throwable) => {
+          List(StackTrace.trimmed(t, traceLevel))
+        })
+      val codec: ShowLines[TraceEvent] =
+        ShowLines[TraceEvent]((t: TraceEvent) => {
+          throwableShowLines.showLines(t.message)
+        })
+      codec.showLines(te).toVector foreach { appendLog(Level.Error, _) }
+    }
+    if (traceLevel <= 2) {
+      suppressedMessage(new SuppressedTraceContext(traceLevel, ansiCodesSupported && useFormat)) foreach {
+        appendLog(Level.Error, _)
+      }
+    }
+  }
+
+  private def appendMessageContent(level: Level.Value, o: AnyRef): Unit = {
+    def appendEvent(oe: ObjectEvent[_]): Unit = {
+      val contentType = oe.contentType
+      contentType match {
+        case "sbt.internal.util.TraceEvent"    => appendTraceEvent(oe.message.asInstanceOf[TraceEvent])
+        case "sbt.internal.util.ProgressEvent" =>
+        case _ =>
+          LogExchange.stringCodec[AnyRef](contentType) match {
+            case Some(codec) if contentType == "sbt.internal.util.SuccessEvent" =>
+              codec.showLines(oe.message.asInstanceOf[AnyRef]).toVector foreach { success(_) }
+            case Some(codec) =>
+              codec.showLines(oe.message.asInstanceOf[AnyRef]).toVector foreach (appendLog(
+                level,
+                _
+              ))
+            case _ => appendLog(level, oe.message.toString)
+          }
+      }
+    }
+
+    o match {
+      case x: StringEvent    => Vector(x.message) foreach { appendLog(level, _) }
+      case x: ObjectEvent[_] => appendEvent(x)
+      case _                 => Vector(o.toString) foreach { appendLog(level, _) }
+    }
+  }
+  private[sbt] def appendObjectEvent[T](level: Level.Value, message: => ObjectEvent[T]): Unit =
+    appendMessageContent(level, message)
+
+}
+private[internal] class Log4JConsoleAppender(
+    override private[sbt] val name: String,
+    override private[sbt] val properties: Properties,
+    override private[sbt] val suppressedMessage: SuppressedTraceContext => Option[String],
+    appendEvent: XLogEvent => Unit,
+) extends AbstractAppender(name, null, LogExchange.dummyLayout, true, Array.empty)
+    with Appender {
+  start()
+  override def close(): Unit = stop()
+  override private[sbt] def toLog4J: XAppender = this
+  override def append(event: XLogEvent): Unit = appendEvent(event)
+}
+private[sbt] class ConsoleAppenderFromLog4J(
+    override private[sbt] val name: String,
+    override private[sbt] val properties: Properties,
+    override private[sbt] val suppressedMessage: SuppressedTraceContext => Option[String],
+    val delegate: XAppender,
+) extends Appender {
+  def this(name: String, delegate: XAppender) =
+    this(name, Properties.from(Terminal.get), _ => None, delegate)
+  override def close(): Unit = delegate.stop()
+  private[sbt] def toLog4J: XAppender = delegate
+  override def appendLog(level: sbt.util.Level.Value, message: => String): Unit = {
+    delegate.append(new AbstractLogEvent {
+      override def getLevel(): XLevel = ConsoleAppender.toXLevel(level)
+      override def getMessage(): Message =
+        StringFormatterMessageFactory.INSTANCE.newMessage(message.toString, Array.empty)
+    })
+  }
+}
+
+final class SuppressedTraceContext(val traceLevel: Int, val useFormat: Boolean)
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala
new file mode 100644
index 000000000..b946a0cc8
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala
@@ -0,0 +1,132 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.{ BufferedWriter, PrintStream, PrintWriter }
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicReference
+
+sealed trait ConsoleOut {
+  val lockObject: AnyRef
+  def print(s: String): Unit
+  def println(s: String): Unit
+  def println(): Unit
+  def flush(): Unit
+}
+
+object ConsoleOut {
+  def systemOut: ConsoleOut = terminalOut
+  private[sbt] object NullConsoleOut extends ConsoleOut {
+    override val lockObject: AnyRef = this
+    override def print(s: String): Unit = {}
+    override def println(): Unit = {}
+    override def println(s: String): Unit = {}
+    override def flush(): Unit = {}
+  }
+  private[sbt] def globalProxy: ConsoleOut = Proxy
+  private[sbt] def setGlobalProxy(out: ConsoleOut): Unit = Proxy.set(out)
+  private[sbt] def getGlobalProxy: ConsoleOut = Proxy.proxy.get
+  private object Proxy extends ConsoleOut {
+    private[ConsoleOut] val proxy = new AtomicReference[ConsoleOut](systemOut)
+    private[this] def get: ConsoleOut = proxy.get
+    def set(proxy: ConsoleOut): Unit = this.proxy.set(proxy)
+    override val lockObject: AnyRef = proxy
+    override def print(s: String): Unit = get.print(s)
+    override def println(s: String): Unit = get.println(s)
+    override def println(): Unit = get.println()
+    override def flush(): Unit = get.flush()
+    override def toString: String = s"ProxyConsoleOut"
+  }
+
+  def overwriteContaining(s: String): (String, String) => Boolean =
+    (cur, prev) => cur.contains(s) && prev.contains(s)
+
+  /** Move to beginning of previous line and clear the line. */
+  private[this] final val OverwriteLine = "\u001B[A\r\u001B[2K"
+
+  /**
+   * ConsoleOut instance that is backed by System.out.  It overwrites the previously printed line
+   * if the function `f(lineToWrite, previousLine)` returns true.
+   *
+   * The ConsoleOut returned by this method assumes that the only newlines are from println calls
+   * and not in the String arguments.
+   */
+  def systemOutOverwrite(f: (String, String) => Boolean): ConsoleOut = new ConsoleOut {
+    val lockObject = System.out
+    private[this] var last: Option[String] = None
+    private[this] var current = new java.lang.StringBuffer
+    def print(s: String): Unit = synchronized { current.append(s); () }
+    def println(s: String): Unit = synchronized { current.append(s); println() }
+    def println(): Unit = synchronized {
+      val s = current.toString
+      if (Terminal.isAnsiSupported && last.exists(lmsg => f(s, lmsg)))
+        lockObject.print(OverwriteLine)
+      lockObject.println(s)
+      last = Some(s)
+      current.setLength(0)
+    }
+    def flush(): Unit = synchronized {
+      val s = current.toString
+      if (Terminal.isAnsiSupported && last.exists(lmsg => f(s, lmsg)))
+        lockObject.print(OverwriteLine)
+      lockObject.print(s)
+      last = Some(s)
+      current.setLength(0)
+    }
+    override def toString: String = s"SystemOutOverwrite@${System.identityHashCode(this)}"
+  }
+
+  def terminalOut: ConsoleOut = new ConsoleOut {
+    override val lockObject: AnyRef = System.out
+    override def print(s: String): Unit = Terminal.get.printStream.print(s)
+    override def println(s: String): Unit = Terminal.get.printStream.println(s)
+    override def println(): Unit = Terminal.get.printStream.println()
+    override def flush(): Unit = Terminal.get.printStream.flush()
+    override def toString: String = s"TerminalOut"
+  }
+
+  private[this] val consoleOutPerTerminal = new ConcurrentHashMap[Terminal, ConsoleOut]
+  def terminalOut(terminal: Terminal): ConsoleOut = consoleOutPerTerminal.get(terminal) match {
+    case null =>
+      val res = new ConsoleOut {
+        override val lockObject: AnyRef = terminal
+        override def print(s: String): Unit = terminal.printStream.print(s)
+        override def println(s: String): Unit = terminal.printStream.println(s)
+        override def println(): Unit = terminal.printStream.println()
+        override def flush(): Unit = terminal.printStream.flush()
+        override def toString: String = s"TerminalOut($terminal)"
+      }
+      consoleOutPerTerminal.put(terminal, res)
+      res
+    case c => c
+  }
+  def printStreamOut(out: PrintStream): ConsoleOut = new ConsoleOut {
+    val lockObject = out
+    def print(s: String) = out.print(s)
+    def println(s: String) = out.println(s)
+    def println() = out.println()
+    def flush() = out.flush()
+    override def toString: String = s"PrintStreamConsoleOut($out)"
+  }
+  def printWriterOut(out: PrintWriter): ConsoleOut = new ConsoleOut {
+    val lockObject = out
+    def print(s: String) = out.print(s)
+    def println(s: String) = { out.println(s); flush() }
+    def println() = { out.println(); flush() }
+    def flush() = { out.flush() }
+    override def toString: String = s"PrintWriterConsoleOut($out)"
+  }
+  def bufferedWriterOut(out: BufferedWriter): ConsoleOut = new ConsoleOut {
+    val lockObject = out
+    def print(s: String) = out.write(s)
+    def println(s: String) = { out.write(s); println() }
+    def println() = { out.newLine(); flush() }
+    def flush() = { out.flush() }
+    override def toString: String = s"BufferedWriterConsoleOut($out)"
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/EscHelpers.scala b/internal/util-logging/src/main/scala/sbt/internal/util/EscHelpers.scala
new file mode 100644
index 000000000..ee84680c6
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/EscHelpers.scala
@@ -0,0 +1,253 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import scala.collection.mutable.ArrayBuffer
+import scala.util.Try
+
+object EscHelpers {
+
+  /** Escape character, used to introduce an escape sequence. */
+  final val ESC = '\u001B'
+
+  /**
+   * An escape terminator is a character in the range `@` (decimal value 64) to `~` (decimal value 126).
+   * It is the final character in an escape sequence.
+   *
+   * cf. http://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
+   */
+  private[sbt] def isEscapeTerminator(c: Char): Boolean =
+    c >= '@' && c <= '~'
+
+  /**
+   * Test if the character AFTER an ESC is the ANSI CSI.
+   *
+   * see: http://en.wikipedia.org/wiki/ANSI_escape_code
+   *
+   * The CSI (control sequence instruction) codes start with ESC + '['.   This is for testing the second character.
+   *
+   * There is an additional CSI (one character) that we could test for, but is not frequnetly used, and we don't
+   * check for it.
+   *
+   * cf. http://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
+   */
+  private def isCSI(c: Char): Boolean = c == '['
+
+  /**
+   * Tests whether or not a character needs to immediately terminate the ANSI sequence.
+   *
+   * c.f. http://en.wikipedia.org/wiki/ANSI_escape_code#Sequence_elements
+   */
+  private def isAnsiTwoCharacterTerminator(c: Char): Boolean =
+    (c >= '@') && (c <= '_')
+
+  /**
+   * Returns true if the string contains the ESC character.
+   *
+   * TODO - this should handle raw CSI (not used much)
+   */
+  def hasEscapeSequence(s: String): Boolean =
+    s.indexOf(ESC) >= 0
+
+  /**
+   * Returns the string `s` with escape sequences removed.
+   * An escape sequence starts with the ESC character (decimal value 27) and ends with an escape terminator.
+   * @see isEscapeTerminator
+   */
+  def removeEscapeSequences(s: String): String =
+    if (s.isEmpty || !hasEscapeSequence(s))
+      s
+    else {
+      val sb = new java.lang.StringBuilder
+      nextESC(s, 0, sb)
+      sb.toString
+    }
+
+  private[this] def nextESC(s: String, start: Int, sb: java.lang.StringBuilder): Unit = {
+    val escIndex = s.indexOf(ESC, start)
+    if (escIndex < 0) {
+      sb.append(s, start, s.length)
+      ()
+    } else {
+      sb.append(s, start, escIndex)
+      val next: Int =
+        if (escIndex + 1 >= s.length) skipESC(s, escIndex + 1)
+        // If it's a CSI we skip past it and then look for a terminator.
+        else if (isCSI(s.charAt(escIndex + 1))) skipESC(s, escIndex + 2)
+        else if (isAnsiTwoCharacterTerminator(s.charAt(escIndex + 1))) escIndex + 2
+        else {
+          // There could be non-ANSI character sequences we should make sure we handle here.
+          skipESC(s, escIndex + 1)
+        }
+      nextESC(s, next, sb)
+    }
+  }
+  private[this] val esc = 1
+  private[this] val csi = 2
+  def cursorPosition(s: String): Int = {
+    val bytes = s.getBytes
+    var i = 0
+    var index = 0
+    var state = 0
+    val digit = new ArrayBuffer[Byte]
+    var leftDigit = -1
+    while (i < bytes.length) {
+      bytes(i) match {
+        case 27 => state = esc
+        case b if (state == esc || state == csi) && b >= 48 && b < 58 =>
+          state = csi
+          digit += b
+        case '[' if state == esc => state = csi
+        case 8 =>
+          state = 0
+          index = index - 1
+        case b if state == csi =>
+          leftDigit = Try(new String(digit.toArray).toInt).getOrElse(0)
+          state = 0
+          b.toChar match {
+            case 'D' => index = math.max(index - leftDigit, 0)
+            case 'C' => index += leftDigit
+            case 'K' =>
+            case 'J' => if (leftDigit == 2) index = 0
+            case 'm' =>
+            case ';' => state = csi
+            case _   =>
+          }
+          digit.clear()
+        case _ =>
+          index += 1
+      }
+      i += 1
+    }
+    index
+  }
+
+  /**
+   * Strips ansi escape and color codes from an input string.
+   *
+   * @param bytes the input bytes
+   * @param stripAnsi toggles whether or not to remove general ansi escape codes
+   * @param stripColor toggles whether or not to remove ansi color codes
+   * @return a string with the escape and color codes removed depending on the input
+   * parameter along with the length of the output string (which may be smaller than
+   * the returned array)
+   */
+  def strip(bytes: Array[Byte], stripAnsi: Boolean, stripColor: Boolean): (Array[Byte], Int) = {
+    val res = Array.fill[Byte](bytes.length)(0)
+    var i = 0
+    var index = 0
+    var state = 0
+    var limit = 0
+    val digit = new ArrayBuffer[Byte]
+    var leftDigit = -1
+    var escIndex = -1
+    bytes.foreach { b =>
+      if (index < res.length) res(index) = b
+      index += 1
+      limit = math.max(limit, index)
+      if (state == 0) escIndex = -1
+      b match {
+        case 27 =>
+          escIndex = index - 1
+          state = esc
+        case b if (state == esc || state == csi) && b >= 48 && b < 58 =>
+          state = csi
+          digit += b
+        case '[' if state == esc => state = csi
+        case 8 =>
+          state = 0
+          index = math.max(index - 1, 0)
+        case b if state == csi =>
+          leftDigit = Try(new String(digit.toArray).toInt).getOrElse(0)
+          state = 0
+          b.toChar match {
+            case 'h' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'J' | 'K' =>
+              if (stripAnsi) index = math.max(escIndex, 0)
+            case 'm'                   => if (stripColor) index = escIndex
+            case ';' | 's' | 'u' | '?' => state = csi
+            case b                     =>
+          }
+          digit.clear()
+        case b if state == esc => state = 0
+        case b                 =>
+      }
+    }
+    (res, index)
+  }
+  @deprecated("use EscHelpers.strip", "1.4.2")
+  def stripMoves(s: String): String = {
+    val (bytes, len) = strip(s.getBytes, stripAnsi = true, stripColor = false)
+    new String(bytes, 0, len)
+  }
+
+  /**
+   * Removes the ansi escape sequences from a string and makes a best attempt at
+   * calculating any ansi moves by hand. For example, if the string contains
+   * a backspace character followed by a character, the output string would
+   * replace the character preceding the backspaces with the character proceding it.
+   * This is in contrast to `strip` which just removes all ansi codes entirely.
+   *
+   * @param s the input string
+   * @return a string containing the original characters of the input stream with
+   * the ansi escape codes removed.
+   */
+  def stripColorsAndMoves(s: String): String = {
+    val bytes = s.getBytes
+    val res = Array.fill[Byte](bytes.length)(0)
+    var i = 0
+    var index = 0
+    var state = 0
+    var limit = 0
+    val digit = new ArrayBuffer[Byte]
+    var leftDigit = -1
+    bytes.foreach {
+      case 27 => state = esc
+      case b if (state == esc || state == csi) && b >= 48 && b < 58 =>
+        state = csi
+        digit += b
+      case '[' if state == esc => state = csi
+      case 8 =>
+        state = 0
+        index = math.max(index - 1, 0)
+      case b if state == csi =>
+        leftDigit = Try(new String(digit.toArray).toInt).getOrElse(0)
+        state = 0
+        b.toChar match {
+          case 'h' => index = math.max(index - 1, 0)
+          case 'D' => index = math.max(index - leftDigit, 0)
+          case 'C' => index = math.min(limit, math.min(index + leftDigit, res.length - 1))
+          case 'K' | 'J' =>
+            if (leftDigit > 0) (0 until index).foreach(res(_) = 32)
+            else res(index) = 32
+          case 'm' =>
+          case ';' => state = csi
+          case b   => state = csi
+        }
+        digit.clear()
+      case b if state == esc => state = 0
+      case b =>
+        res(index) = b
+        index += 1
+        limit = math.max(limit, index)
+    }
+    (res, limit)
+    new String(res, 0, limit)
+  }
+
+  /** Skips the escape sequence starting at `i-1`.  `i` should be positioned at the character after the ESC that starts the sequence. */
+  private[this] def skipESC(s: String, i: Int): Int = {
+    if (i >= s.length) {
+      i
+    } else if (isEscapeTerminator(s.charAt(i))) {
+      i + 1
+    } else {
+      skipESC(s, i + 1)
+    }
+  }
+
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala
new file mode 100644
index 000000000..57cad95a9
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala
@@ -0,0 +1,40 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+import scala.annotation.nowarn
+
+/**
+ * A filter logger is used to delegate messages but not the logging level to another logger.  This means
+ * that messages are logged at the higher of the two levels set by this logger and its delegate.
+ */
+class FilterLogger(delegate: AbstractLogger) extends BasicLogger {
+  @nowarn override lazy val ansiCodesSupported = delegate.ansiCodesSupported
+  def trace(t: => Throwable): Unit = {
+    if (traceEnabled)
+      delegate.trace(t)
+  }
+  override def setSuccessEnabled(flag: Boolean): Unit = delegate.setSuccessEnabled(flag)
+  override def successEnabled = delegate.successEnabled
+  override def setTrace(level: Int): Unit = delegate.setTrace(level)
+  override def getTrace = delegate.getTrace
+  def log(level: Level.Value, message: => String): Unit = {
+    if (atLevel(level))
+      delegate.log(level, message)
+  }
+  def success(message: => String): Unit = {
+    if (successEnabled)
+      delegate.success(message)
+  }
+  def control(event: ControlEvent.Value, message: => String): Unit = {
+    if (atLevel(Level.Info))
+      delegate.control(event, message)
+  }
+  def logAll(events: Seq[LogEvent]): Unit = delegate.logAll(events)
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala
new file mode 100644
index 000000000..3298d26a0
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala
@@ -0,0 +1,39 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+import com.github.ghik.silencer.silent
+
+/** Promotes the simple Logger interface to the full AbstractLogger interface. */
+class FullLogger(delegate: Logger) extends BasicLogger {
+  @deprecated("No longer used.", "1.0.0")
+  @silent override val ansiCodesSupported: Boolean = delegate.ansiCodesSupported
+
+  def trace(t: => Throwable): Unit = {
+    if (traceEnabled)
+      delegate.trace(t)
+  }
+  def log(level: Level.Value, message: => String): Unit = {
+    if (atLevel(level))
+      delegate.log(level, message)
+  }
+  def success(message: => String): Unit =
+    if (successEnabled)
+      delegate.success(message)
+  def control(event: ControlEvent.Value, message: => String): Unit =
+    info(message)
+  def logAll(events: Seq[LogEvent]): Unit = events.foreach(log)
+}
+object FullLogger {
+  def apply(delegate: Logger): AbstractLogger =
+    delegate match {
+      case d: AbstractLogger => d
+      case _                 => new FullLogger(delegate)
+    }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala b/internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala
new file mode 100644
index 000000000..9be015da7
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala
@@ -0,0 +1,90 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+import java.io.{ File, PrintWriter }
+
+/**
+ * Provides the current global logging configuration.
+ *
+ * `full` is the current global logger.  It should not be set directly because it is generated as needed from `backing.newLogger`.
+ * `console` is where all logging from all ConsoleLoggers should go.
+ * `backed` is the Logger that other loggers should feed into.
+ * `backing` tracks the files that persist the global logging.
+ * `newLogger` creates a new global logging configuration from a sink and backing configuration.
+ */
+final case class GlobalLogging(
+    full: ManagedLogger,
+    console: ConsoleOut,
+    backed: Appender,
+    backing: GlobalLogBacking,
+    newAppender: (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging
+)
+
+final case class GlobalLogging1(
+    full: Logger,
+    console: ConsoleOut,
+    backed: AbstractLogger,
+    backing: GlobalLogBacking,
+    newLogger: (PrintWriter, GlobalLogBacking) => GlobalLogging1
+)
+
+/**
+ * Tracks the files that persist the global logging.
+ * `file` is the current backing file.  `last` is the previous backing file, if there is one.
+ * `newBackingFile` creates a new temporary location for the next backing file.
+ */
+final case class GlobalLogBacking(file: File, last: Option[File], newBackingFile: () => File) {
+
+  /** Shifts the current backing file to `last` and sets the current backing to `newFile`. */
+  def shift(newFile: File) = GlobalLogBacking(newFile, Some(file), newBackingFile)
+
+  /** Shifts the current backing file to `last` and sets the current backing to a new temporary file generated by `newBackingFile`. */
+  def shiftNew() = shift(newBackingFile())
+
+  /**
+   * If there is a previous backing file in `last`, that becomes the current backing file and the previous backing is cleared.
+   * Otherwise, no changes are made.
+   */
+  def unshift = GlobalLogBacking(last getOrElse file, None, newBackingFile)
+
+}
+
+object GlobalLogBacking {
+  def apply(newBackingFile: => File): GlobalLogBacking =
+    GlobalLogBacking(newBackingFile, None, newBackingFile _)
+}
+
+object GlobalLogging {
+  import java.util.concurrent.atomic.AtomicInteger
+
+  private def generateName: String = "GlobalLogging" + generateId.incrementAndGet
+  private val generateId: AtomicInteger = new AtomicInteger
+
+  def initial1(
+      newLogger: (PrintWriter, GlobalLogBacking) => GlobalLogging1,
+      newBackingFile: => File,
+      console: ConsoleOut
+  ): GlobalLogging1 = {
+    val log = ConsoleLogger(console)
+    GlobalLogging1(log, console, log, GlobalLogBacking(newBackingFile), newLogger)
+  }
+
+  def initial(
+      newAppender: (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging,
+      newBackingFile: => File,
+      console: ConsoleOut
+  ): GlobalLogging = {
+    val loggerName = generateName
+    val log = LoggerContext.globalContext.logger(loggerName, None, None)
+    val appender = ConsoleAppender(ConsoleAppender.generateName, console)
+    LoggerContext.globalContext.addAppender(loggerName, appender -> Level.Info)
+    GlobalLogging(log, console, appender, GlobalLogBacking(newBackingFile), newAppender)
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/JLine3.scala b/internal/util-logging/src/main/scala/sbt/internal/util/JLine3.scala
new file mode 100644
index 000000000..a4811a2cc
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/JLine3.scala
@@ -0,0 +1,326 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.{ InputStream, OutputStream, PrintWriter }
+import java.nio.ByteBuffer
+import java.nio.charset.{ CharacterCodingException, Charset, CharsetDecoder }
+import java.util.{ Arrays, EnumSet }
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+import org.jline.utils.InfoCmp.Capability
+import org.jline.utils.{ ClosedException, NonBlockingReader }
+import org.jline.terminal.{ Attributes, Size, Terminal => JTerminal }
+import org.jline.terminal.Attributes.{ InputFlag, LocalFlag }
+import org.jline.terminal.Terminal.SignalHandler
+import org.jline.terminal.impl.{ AbstractTerminal, DumbTerminal }
+import org.jline.terminal.impl.jansi.JansiSupportImpl
+import org.jline.terminal.impl.jansi.win.JansiWinSysTerminal
+import org.jline.utils.OSUtils
+import scala.collection.JavaConverters._
+import scala.util.Try
+import java.util.concurrent.LinkedBlockingQueue
+
+private[sbt] object JLine3 {
+  private[util] val initialAttributes = new AtomicReference[Attributes]
+
+  private[this] val forceWindowsJansiHolder = new AtomicBoolean(false)
+  private[sbt] def forceWindowsJansi(): Unit = forceWindowsJansiHolder.set(true)
+  private[this] def windowsJansi(): org.jline.terminal.Terminal = {
+    val support = new JansiSupportImpl
+    val winConsole = support.isWindowsConsole();
+    val termType = sys.props.get("org.jline.terminal.type").orElse(sys.env.get("TERM")).orNull
+    val term = JansiWinSysTerminal.createTerminal(
+      "console",
+      termType,
+      OSUtils.IS_CONEMU,
+      Charset.forName("UTF-8"),
+      -1,
+      false,
+      SignalHandler.SIG_DFL,
+      true
+    )
+    term.disableScrolling()
+    term
+  }
+  private val jansi = {
+    val (major, minor) =
+      (JansiSupportImpl.getJansiMajorVersion, JansiSupportImpl.getJansiMinorVersion)
+    (major > 1 || minor >= 18) && Util.isWindows
+  }
+  private[util] def system: org.jline.terminal.Terminal = {
+    val term =
+      if (forceWindowsJansiHolder.get) windowsJansi()
+      else {
+        // Only use jna on windows. Both jna and jansi use illegal reflective
+        // accesses on posix system.
+        org.jline.terminal.TerminalBuilder
+          .builder()
+          .system(System.console != null)
+          .jna(Util.isWindows && !jansi)
+          .jansi(jansi)
+          .paused(true)
+          .build()
+      }
+    initialAttributes.get match {
+      case null => initialAttributes.set(term.getAttributes)
+      case _    =>
+    }
+    term
+  }
+  private[sbt] def apply(term: Terminal): JTerminal = {
+    if (System.getProperty("jline.terminal", "") == "none")
+      new DumbTerminal(term.inputStream, term.outputStream)
+    else wrapTerminal(term)
+  }
+  private[util] def decodeInput(decoder: CharsetDecoder, inputStream: InputStream): Int = {
+    val bytes = new Array[Byte](4)
+    var i = 0
+    var res = -2
+    do {
+      inputStream.read() match {
+        case -1 => res = -1
+        case byte =>
+          bytes(i) = byte.toByte
+          i += 1
+          val bb = ByteBuffer.wrap(bytes, 0, i)
+          try {
+            val cb = decoder.decode(bb)
+            val it = cb.codePoints().iterator
+            if (it.hasNext) res = it.next
+          } catch { case _: CharacterCodingException => }
+      }
+
+    } while (i < 4 && res == -2)
+    res
+  }
+  private[this] def wrapTerminal(term: Terminal): JTerminal = {
+    new AbstractTerminal(
+      term.name,
+      "nocapabilities",
+      Charset.forName("UTF-8"),
+      SignalHandler.SIG_DFL
+    ) {
+      val closed = new AtomicBoolean(false)
+      setOnClose { () =>
+        doClose()
+        reader.close()
+        if (closed.compareAndSet(false, true)) {
+          // This is necessary to shutdown the non blocking input reader
+          // so that it doesn't keep blocking
+          term.inputStream match {
+            case w: Terminal.WriteableInputStream => w.cancel()
+            case _                                =>
+          }
+        }
+      }
+      override val input: InputStream = new InputStream {
+        override def read: Int = {
+          val res = term.inputStream match {
+            case w: Terminal.WriteableInputStream =>
+              val result = new LinkedBlockingQueue[Integer]
+              try {
+                w.read(result)
+                result.poll match {
+                  case null => throw new ClosedException
+                  case i    => i.toInt
+                }
+              } catch {
+                case _: InterruptedException =>
+                  w.cancel()
+                  throw new ClosedException
+              }
+            case _ => throw new ClosedException
+          }
+          res match {
+            case 3 /* ctrl+c */ => throw new ClosedException
+            case r              => r
+          }
+        }
+      }
+      override val output: OutputStream = new OutputStream {
+        override def write(b: Int): Unit = write(Array[Byte](b.toByte))
+        override def write(b: Array[Byte]): Unit = if (!closed.get) term.withPrintStream { ps =>
+          ps.write(b)
+          term.prompt match {
+            case a: Prompt.AskUser => a.write(b)
+            case _                 =>
+          }
+        }
+        override def write(b: Array[Byte], offset: Int, len: Int) =
+          write(Arrays.copyOfRange(b, offset, offset + len))
+        override def flush(): Unit = term.withPrintStream(_.flush())
+      }
+
+      override val reader = new NonBlockingReader {
+        val buffer = new LinkedBlockingQueue[Integer]
+        val thread = new AtomicReference[Thread]
+        private def fillBuffer(): Unit = thread.synchronized {
+          thread.set(Thread.currentThread)
+          try buffer.put(decodeInput(encoding.newDecoder, term.inputStream))
+          catch { case _: InterruptedException => buffer.put(-3) }
+        }
+        override def close(): Unit = thread.get match {
+          case null =>
+          case t    => t.interrupt()
+        }
+        override def read(timeout: Long, peek: Boolean) = {
+          if (buffer.isEmpty && !peek) fillBuffer()
+          (if (peek) buffer.peek else buffer.take) match {
+            case null => -2
+            case i    => if (i == -3) throw new InterruptedException else i
+          }
+        }
+        override def peek(timeout: Long): Int = buffer.peek() match {
+          case null => -1
+          case i    => i.toInt
+        }
+        override def readBuffered(buf: Array[Char]): Int = {
+          if (buffer.isEmpty) fillBuffer()
+          buffer.take match {
+            case i if i == -1 => -1
+            case i =>
+              buf(0) = i.toChar
+              1
+          }
+        }
+      }
+      override val writer: PrintWriter = new PrintWriter(output, true)
+      /*
+       * For now assume that the terminal capabilities for client and server
+       * are the same.
+       */
+      override def getStringCapability(cap: Capability): String = {
+        term.getStringCapability(cap.toString) match {
+          case null if cap == Capability.key_dc && Util.isWindows  => "\\E[3~"
+          case null if cap == Capability.key_end && Util.isWindows => "\\E[4~"
+          case null if cap == Capability.key_ic && Util.isWindows  => "\\E[2~"
+          case c                                                   => c
+        }
+      }
+      override def getNumericCapability(cap: Capability): Integer = {
+        if (cap == Capability.max_colors && !term.isColorEnabled) 1
+        else term.getNumericCapability(cap.toString)
+      }
+      override def getBooleanCapability(cap: Capability): Boolean =
+        term.getBooleanCapability(cap.toString)
+      def getAttributes(): Attributes = attributesFromMap(term.getAttributes)
+      def getSize(): Size = new Size(term.getWidth, term.getHeight)
+      def setAttributes(a: Attributes): Unit = {} // don't allow the jline line reader to change attributes
+      def setSize(size: Size): Unit = term.setSize(size.getColumns, size.getRows)
+
+      override def enterRawMode(): Attributes = {
+        // don't actually modify the term, that is handled by LineReader
+        attributesFromMap(term.getAttributes)
+      }
+    }
+  }
+  private def enterRawModeImpl(term: JTerminal): Attributes = {
+    val prvAttr = term.getAttributes()
+    val newAttr = new Attributes(prvAttr)
+    newAttr.setLocalFlags(EnumSet.of(LocalFlag.ICANON, LocalFlag.ECHO, LocalFlag.IEXTEN), false)
+    newAttr.setInputFlags(EnumSet.of(InputFlag.IXON, InputFlag.ICRNL, InputFlag.INLCR), false)
+    term.setAttributes(newAttr)
+    prvAttr
+  }
+  // We need to set the ENABLE_PROCESS_INPUT flag for ctrl+c to be treated as a signal in windows
+  // https://docs.microsoft.com/en-us/windows/console/setconsolemode
+  private[this] val ENABLE_PROCESS_INPUT = 1
+  private[util] def setEnableProcessInput(): Unit = if (Util.isWindows) {
+    WindowsSupport.setConsoleMode(WindowsSupport.getConsoleMode | ENABLE_PROCESS_INPUT)
+  }
+  private[util] def enterRawMode(term: JTerminal): Unit = {
+    val prevAttr = initialAttributes.get
+    val newAttr = new Attributes(prevAttr)
+    // These flags are copied from the jline3 enterRawMode but the jline implementation
+    // also puts the input stream in non blocking mode, which we do not want.
+    newAttr.setLocalFlags(EnumSet.of(LocalFlag.ICANON, LocalFlag.IEXTEN, LocalFlag.ECHO), false)
+    newAttr.setInputFlags(EnumSet.of(InputFlag.IXON, InputFlag.ICRNL, InputFlag.INLCR), false)
+    term.setAttributes(newAttr)
+    setEnableProcessInput()
+  }
+  private[util] def exitRawMode(term: JTerminal): Unit = {
+    val initAttr = initialAttributes.get
+    val newAttr = new Attributes(initAttr)
+    newAttr.setLocalFlags(EnumSet.of(LocalFlag.ICANON, LocalFlag.ECHO), true)
+    term.setAttributes(newAttr)
+    setEnableProcessInput()
+  }
+  private[util] def toMap(jattributes: Attributes): Map[String, String] = {
+    val result = new java.util.LinkedHashMap[String, String]
+    result.put(
+      "iflag",
+      jattributes.getInputFlags.iterator.asScala.map(_.name.toLowerCase).mkString(" ")
+    )
+    result.put(
+      "oflag",
+      jattributes.getOutputFlags.iterator.asScala.map(_.name.toLowerCase).mkString(" ")
+    )
+    result.put(
+      "cflag",
+      jattributes.getControlFlags.iterator.asScala.map(_.name.toLowerCase).mkString(" ")
+    )
+    result.put(
+      "lflag",
+      jattributes.getLocalFlags.iterator.asScala.map(_.name.toLowerCase).mkString(" ")
+    )
+    result.put(
+      "cchars",
+      jattributes.getControlChars.entrySet.iterator.asScala
+        .map { e =>
+          s"${e.getKey.name.toLowerCase},${e.getValue}"
+        }
+        .mkString(" ")
+    )
+    result.asScala.toMap
+  }
+  private[this] val iflagMap: Map[String, InputFlag] =
+    InputFlag.values.map(f => f.name.toLowerCase -> f).toMap
+  private[this] val oflagMap: Map[String, Attributes.OutputFlag] =
+    Attributes.OutputFlag.values.map(f => f.name.toLowerCase -> f).toMap
+  private[this] val cflagMap: Map[String, Attributes.ControlFlag] =
+    Attributes.ControlFlag.values.map(f => f.name.toLowerCase -> f).toMap
+  private[this] val lflagMap: Map[String, LocalFlag] =
+    LocalFlag.values.map(f => f.name.toLowerCase -> f).toMap
+  private[this] val charMap: Map[String, Attributes.ControlChar] =
+    Attributes.ControlChar.values().map(f => f.name.toLowerCase -> f).toMap
+  private[sbt] def setMode(term: Terminal, canonical: Boolean, echo: Boolean): Unit = {
+    val prev = attributesFromMap(term.getAttributes)
+    val newAttrs = new Attributes(prev)
+    newAttrs.setLocalFlag(LocalFlag.ICANON, canonical)
+    newAttrs.setLocalFlag(LocalFlag.ECHO, echo)
+    term.setAttributes(toMap(newAttrs))
+  }
+  private[util] def attributesFromMap(map: Map[String, String]): Attributes = {
+    val attributes = new Attributes
+    map.get("iflag").foreach { flags =>
+      flags.split(" ").foreach(f => iflagMap.get(f).foreach(attributes.setInputFlag(_, true)))
+    }
+    map.get("oflag").foreach { flags =>
+      flags.split(" ").foreach(f => oflagMap.get(f).foreach(attributes.setOutputFlag(_, true)))
+    }
+    map.get("cflag").foreach { flags =>
+      flags.split(" ").foreach(f => cflagMap.get(f).foreach(attributes.setControlFlag(_, true)))
+    }
+    map.get("lflag").foreach { flags =>
+      flags.split(" ").foreach(f => lflagMap.get(f).foreach(attributes.setLocalFlag(_, true)))
+    }
+    map.get("cchars").foreach { chars =>
+      chars.split(" ").foreach { keyValue =>
+        keyValue.split(",") match {
+          case Array(k, v) =>
+            Try(v.toInt).foreach(i => charMap.get(k).foreach(c => attributes.setControlChar(c, i)))
+          case _ =>
+        }
+      }
+    }
+    attributes
+  }
+  private[sbt] def isEchoEnabled(map: Map[String, String]): Boolean = {
+    attributesFromMap(map).getLocalFlag(LocalFlag.ECHO)
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala b/internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala
new file mode 100644
index 000000000..8c8fe34b7
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala
@@ -0,0 +1,64 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+
+/**
+ * Provides a `java.io.Writer` interface to a `Logger`.  Content is line-buffered and logged at `level`.
+ * A line is delimited by `nl`, which is by default the platform line separator.
+ */
+class LoggerWriter(
+    delegate: Logger,
+    unbufferedLevel: Option[Level.Value],
+    nl: String = System.getProperty("line.separator")
+) extends java.io.Writer {
+  def this(delegate: Logger, level: Level.Value) = this(delegate, Some(level))
+  def this(delegate: Logger) = this(delegate, None)
+
+  private[this] val buffer = new StringBuilder
+  private[this] val lines = new collection.mutable.ListBuffer[String]
+
+  override def close() = flush()
+
+  override def flush(): Unit =
+    synchronized {
+      if (buffer.nonEmpty) {
+        log(buffer.toString)
+        buffer.clear()
+      }
+    }
+
+  def flushLines(level: Level.Value): Unit =
+    synchronized {
+      for (line <- lines)
+        delegate.log(level, line)
+      lines.clear()
+    }
+
+  override def write(content: Array[Char], offset: Int, length: Int): Unit =
+    synchronized {
+      buffer.appendAll(content, offset, length)
+      process()
+    }
+
+  private[this] def process(): Unit = {
+    val i = buffer.indexOf(nl)
+    if (i >= 0) {
+      log(buffer.substring(0, i))
+      buffer.delete(0, i + nl.length)
+      process()
+    }
+  }
+
+  private[this] def log(s: String): Unit = unbufferedLevel match {
+    case None =>
+      lines += s; ()
+    case Some(level) => delegate.log(level, s)
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/MainLogging.scala b/internal/util-logging/src/main/scala/sbt/internal/util/MainLogging.scala
new file mode 100644
index 000000000..db5d2e25e
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/MainLogging.scala
@@ -0,0 +1,117 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+import java.io.PrintWriter
+
+object MainAppender {
+  import java.util.concurrent.atomic.AtomicInteger
+  private def generateGlobalBackingName: String =
+    "GlobalBacking" + generateId.incrementAndGet
+  private val generateId: AtomicInteger = new AtomicInteger
+
+  def multiLogger(
+      log: ManagedLogger,
+      config: MainAppenderConfig,
+      context: LoggerContext
+  ): ManagedLogger = {
+    import config._
+    // TODO
+    // backed setTrace backingTrace
+    // multi: Logger
+
+    context.clearAppenders(log.name)
+    consoleOpt match {
+      case Some(a: ConsoleAppender) =>
+        a.setTrace(screenTrace)
+        context.addAppender(log.name, a -> screenLevel)
+      case _ =>
+    }
+    context.addAppender(log.name, backed -> backingLevel)
+    extra.foreach(a => context.addAppender(log.name, a -> Level.Info))
+    log
+  }
+
+  def globalDefault(
+      console: ConsoleOut
+  ): (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging = {
+    lazy val newAppender
+        : (ManagedLogger, PrintWriter, GlobalLogBacking, LoggerContext) => GlobalLogging =
+      (log, writer, backing, lc) => {
+        val backed: Appender = defaultBacked(generateGlobalBackingName)(writer)
+        val full = multiLogger(log, defaultMultiConfig(Option(console), backed, Nil), lc)
+        GlobalLogging(full, console, backed, backing, newAppender)
+      }
+    newAppender
+  }
+
+  def defaultMultiConfig(
+      consoleOpt: Option[ConsoleOut],
+      backing: Appender,
+      extra: List[Appender]
+  ): MainAppenderConfig =
+    MainAppenderConfig(
+      consoleOpt map { defaultScreen(_, ConsoleAppender.noSuppressedMessage) },
+      backing,
+      extra,
+      Level.Info,
+      Level.Debug,
+      -1,
+      Int.MaxValue
+    )
+
+  def defaultScreen(console: ConsoleOut): Appender =
+    ConsoleAppender(ConsoleAppender.generateName, console)
+
+  def defaultScreen(
+      console: ConsoleOut,
+      suppressedMessage: SuppressedTraceContext => Option[String]
+  ): Appender = {
+    ConsoleAppender(
+      ConsoleAppender.generateName,
+      Terminal.get,
+      suppressedMessage = suppressedMessage
+    )
+  }
+
+  def defaultScreen(
+      name: String,
+      console: ConsoleOut,
+      suppressedMessage: SuppressedTraceContext => Option[String]
+  ): Appender =
+    ConsoleAppender(name, console, suppressedMessage = suppressedMessage)
+
+  def defaultBacked: PrintWriter => Appender =
+    defaultBacked(generateGlobalBackingName, Terminal.isAnsiSupported)
+
+  def defaultBacked(loggerName: String): PrintWriter => Appender =
+    defaultBacked(loggerName, Terminal.isAnsiSupported)
+
+  def defaultBacked(useFormat: Boolean): PrintWriter => Appender =
+    defaultBacked(generateGlobalBackingName, useFormat)
+
+  def defaultBacked(loggerName: String, useFormat: Boolean): PrintWriter => Appender =
+    to => {
+      ConsoleAppender(
+        ConsoleAppender.generateName,
+        ConsoleOut.printWriterOut(to),
+        useFormat = useFormat
+      )
+    }
+
+  final case class MainAppenderConfig(
+      consoleOpt: Option[Appender],
+      backed: Appender,
+      extra: List[Appender],
+      screenLevel: Level.Value,
+      backingLevel: Level.Value,
+      screenTrace: Int,
+      backingTrace: Int
+  )
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ManagedLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ManagedLogger.scala
new file mode 100644
index 000000000..21e2bbfa6
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ManagedLogger.scala
@@ -0,0 +1,97 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.internal.util.codec.JsonProtocol._
+import sbt.util._
+import scala.reflect.runtime.universe.TypeTag
+import sjsonnew.JsonFormat
+
+private[sbt] trait MiniLogger {
+  def log[T](level: Level.Value, message: ObjectEvent[T]): Unit
+  def log(level: Level.Value, message: => String): Unit
+}
+
+/**
+ * Delegates log events to the associated LogExchange.
+ */
+class ManagedLogger(
+    val name: String,
+    val channelName: Option[String],
+    val execId: Option[String],
+    xlogger: MiniLogger,
+    terminal: Option[Terminal],
+    private[sbt] val context: LoggerContext,
+) extends Logger {
+  def this(
+      name: String,
+      channelName: Option[String],
+      execId: Option[String],
+      xlogger: MiniLogger
+  ) =
+    this(name, channelName, execId, xlogger, None, LoggerContext.globalContext)
+  override def trace(t: => Throwable): Unit =
+    logEvent(Level.Error, TraceEvent("Error", t, channelName, execId))
+  override def log(level: Level.Value, message: => String): Unit =
+    xlogger.log(level, message)
+
+  // send special event for success since it's not a real log level
+  override def success(message: => String): Unit = {
+    if (terminal.fold(true)(_.isSuccessEnabled)) {
+      infoEvent[SuccessEvent](SuccessEvent(message))(
+        implicitly[JsonFormat[SuccessEvent]],
+        StringTypeTag.fast[SuccessEvent],
+      )
+    }
+  }
+
+  @deprecated("Use macro-powered StringTypeTag.fast instead", "1.4.0")
+  def registerStringCodec[A](
+      s: ShowLines[A],
+      tt: scala.reflect.runtime.universe.TypeTag[A]
+  ): Unit = {
+    LogExchange.registerStringCodec[A](s, tt)
+  }
+  def registerStringCodec[A: ShowLines: StringTypeTag]: Unit = {
+    LogExchange.registerStringCodec[A]
+  }
+
+  @deprecated("Use macro-powered StringTypeTag.fast instead", "1.4.0")
+  final def debugEvent[A](event: => A, f: JsonFormat[A], t: TypeTag[A]): Unit =
+    debugEvent(event)(f, StringTypeTag.apply(t))
+  @deprecated("Use macro-powered StringTypeTag.fast instead", "1.4.0")
+  final def infoEvent[A](event: => A, f: JsonFormat[A], t: TypeTag[A]): Unit =
+    infoEvent(event)(f, StringTypeTag.apply(t))
+  @deprecated("Use macro-powered StringTypeTag.fast instead", "1.4.0")
+  final def warnEvent[A](event: => A, f: JsonFormat[A], t: TypeTag[A]): Unit =
+    warnEvent(event)(f, StringTypeTag.apply(t))
+  @deprecated("Use macro-powered StringTypeTag.fast instead", "1.4.0")
+  final def errorEvent[A](event: => A, f: JsonFormat[A], t: TypeTag[A]): Unit =
+    errorEvent(event)(f, StringTypeTag.apply(t))
+
+  final def debugEvent[A: JsonFormat: StringTypeTag](event: => A): Unit =
+    logEvent(Level.Debug, event)
+  final def infoEvent[A: JsonFormat: StringTypeTag](event: => A): Unit = logEvent(Level.Info, event)
+  final def warnEvent[A: JsonFormat: StringTypeTag](event: => A): Unit = logEvent(Level.Warn, event)
+  final def errorEvent[A: JsonFormat: StringTypeTag](event: => A): Unit =
+    logEvent(Level.Error, event)
+  @deprecated("Use macro-powered StringTypeTag.fast instead", "1.4.0")
+  def logEvent[A](level: Level.Value, event: => A, f: JsonFormat[A], t: TypeTag[A]): Unit =
+    logEvent(level, event)(f, StringTypeTag.apply(t))
+  def logEvent[A: JsonFormat](level: Level.Value, event: => A)(
+      implicit tag: StringTypeTag[A]
+  ): Unit = {
+    val v: A = event
+    // println("logEvent " + tag.key)
+    val entry: ObjectEvent[A] = ObjectEvent(level, v, channelName, execId, tag.key)
+    xlogger.log(level, entry)
+  }
+
+  @deprecated("No longer used.", "1.0.0")
+  override def ansiCodesSupported = ConsoleAppender.formatEnabledInEnv
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala b/internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala
new file mode 100644
index 000000000..3169b868d
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala
@@ -0,0 +1,48 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+import scala.annotation.nowarn
+
+// note that setting the logging level on this logger has no effect on its behavior, only
+//   on the behavior of the delegates.
+class MultiLogger(delegates: List[AbstractLogger]) extends BasicLogger {
+  @deprecated("No longer used.", "1.0.0")
+  override lazy val ansiCodesSupported = delegates exists supported
+  @nowarn private[this] def supported = (_: AbstractLogger).ansiCodesSupported
+
+  override def setLevel(newLevel: Level.Value): Unit = {
+    super.setLevel(newLevel)
+    dispatch(new SetLevel(newLevel))
+  }
+
+  override def setTrace(level: Int): Unit = {
+    super.setTrace(level)
+    dispatch(new SetTrace(level))
+  }
+
+  override def setSuccessEnabled(flag: Boolean): Unit = {
+    super.setSuccessEnabled(flag)
+    dispatch(new SetSuccess(flag))
+  }
+
+  def trace(t: => Throwable): Unit = dispatch(new Trace(t))
+  def log(level: Level.Value, message: => String): Unit = dispatch(new Log(level, message))
+  def success(message: => String): Unit = dispatch(new Success(message))
+  def logAll(events: Seq[LogEvent]): Unit = delegates.foreach(_.logAll(events))
+
+  def control(event: ControlEvent.Value, message: => String): Unit =
+    delegates.foreach(_.control(event, message))
+
+  private[this] def dispatch(event: LogEvent): Unit = {
+    for (d <- delegates) {
+      d.log(event)
+    }
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ObjectEvent.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ObjectEvent.scala
new file mode 100644
index 000000000..e73b76183
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ObjectEvent.scala
@@ -0,0 +1,45 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package util
+
+import sbt.util.Level
+import sjsonnew.JsonFormat
+import sjsonnew.support.scalajson.unsafe.Converter
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+final class ObjectEvent[A](
+    val level: Level.Value,
+    val message: A,
+    val channelName: Option[String],
+    val execId: Option[String],
+    val contentType: String,
+    val json: JValue
+) extends Serializable {
+  override def toString: String =
+    s"ObjectEvent($level, $message, $channelName, $execId, $contentType, $json)"
+}
+
+object ObjectEvent {
+  def apply[A: JsonFormat](
+      level: Level.Value,
+      message: A,
+      channelName: Option[String],
+      execId: Option[String],
+      contentType: String
+  ): ObjectEvent[A] =
+    new ObjectEvent(
+      level,
+      message,
+      channelName,
+      execId,
+      contentType,
+      Converter.toJsonUnsafe(message)
+    )
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/ProgressState.scala b/internal/util-logging/src/main/scala/sbt/internal/util/ProgressState.scala
new file mode 100644
index 000000000..37ba3ccab
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/ProgressState.scala
@@ -0,0 +1,225 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.PrintStream
+import java.util.concurrent.ArrayBlockingQueue
+import java.util.concurrent.atomic.{ AtomicInteger, AtomicReference }
+
+import sbt.internal.util.ConsoleAppender.{
+  ClearScreenAfterCursor,
+  CursorLeft1000,
+  DeleteLine,
+  cursorUp,
+  setShowProgress,
+}
+
+import scala.collection.mutable.ArrayBuffer
+import scala.collection.JavaConverters._
+
+private[sbt] final class ProgressState(
+    val progressLines: AtomicReference[Seq[String]],
+    val padding: AtomicInteger,
+    val blankZone: Int,
+    val currentLineBytes: AtomicReference[ArrayBuffer[Byte]],
+    val maxItems: Int,
+) {
+  def this(blankZone: Int, maxItems: Int) = this(
+    new AtomicReference(Nil),
+    new AtomicInteger(0),
+    blankZone,
+    new AtomicReference(new ArrayBuffer[Byte]),
+    maxItems,
+  )
+  def this(blankZone: Int) = this(blankZone, 8)
+  def currentLine: Option[String] =
+    new String(currentLineBytes.get.toArray, "UTF-8").linesIterator.toSeq.lastOption
+      .map(EscHelpers.stripColorsAndMoves)
+      .filter(_.nonEmpty)
+  def reset(): Unit = {
+    progressLines.set(Nil)
+    padding.set(0)
+    currentLineBytes.set(new ArrayBuffer[Byte])
+  }
+  private[this] val lineBuffer = new ArrayBlockingQueue[String](300)
+  private[util] def getLines: Seq[String] = lineBuffer.asScala.toVector
+  private[this] def appendLine(line: String) = while (!lineBuffer.offer(line)) { lineBuffer.poll }
+  private[util] def clearBytes(): Unit = {
+    val pad = padding.get
+    if (currentLineBytes.get.isEmpty && pad > 0) padding.decrementAndGet()
+    currentLineBytes.set(new ArrayBuffer[Byte])
+  }
+
+  private[this] val lineSeparatorBytes: Array[Byte] = System.lineSeparator.getBytes("UTF-8")
+  private[util] def addBytes(terminal: Terminal, bytes: Seq[Byte]): Unit = {
+    val previous: ArrayBuffer[Byte] = currentLineBytes.get
+    val padding = this.padding.get
+    val prevLineCount = if (padding > 0) terminal.lineCount(new String(previous.toArray)) else 0
+    previous ++= bytes
+    if (padding > 0) {
+      val newLineCount = terminal.lineCount(new String(previous.toArray))
+      val diff = newLineCount - prevLineCount
+      this.padding.set(math.max(padding - diff, 0))
+    }
+    val lines = new String(previous.toArray, "UTF-8")
+    if (lines.contains(System.lineSeparator)) {
+      currentLineBytes.set(new ArrayBuffer[Byte])
+      if (!lines.endsWith(System.lineSeparator)) {
+        val allLines = lines.split(System.lineSeparator)
+        allLines.dropRight(1).foreach(appendLine)
+        allLines.lastOption.foreach(currentLineBytes.get ++= _.getBytes("UTF-8"))
+      } else if (lines.contains(System.lineSeparator)) {
+        lines.split(System.lineSeparator).foreach(appendLine)
+      }
+    }
+  }
+
+  private[util] def getPrompt(terminal: Terminal): Array[Byte] = {
+    if (terminal.prompt.isInstanceOf[Prompt.AskUser]) {
+      val prefix = if (terminal.isAnsiSupported) s"$DeleteLine$CursorLeft1000" else ""
+      prefix.getBytes ++ terminal.prompt.render().getBytes("UTF-8")
+    } else Array.empty
+  }
+  private[this] val cleanPrompt =
+    (DeleteLine + ClearScreenAfterCursor + CursorLeft1000).getBytes("UTF-8")
+  private[this] val clearScreenBytes = ClearScreenAfterCursor.getBytes("UTF-8")
+  private[util] def write(
+      terminal: Terminal,
+      bytes: Array[Byte],
+      printStream: PrintStream,
+      hasProgress: Boolean
+  ): Unit = {
+    if (hasProgress) {
+      val canClearPrompt = currentLineBytes.get.isEmpty
+      addBytes(terminal, bytes)
+      val toWrite = new ArrayBuffer[Byte]
+      terminal.prompt match {
+        case a: Prompt.AskUser if a.render.nonEmpty && canClearPrompt => toWrite ++= cleanPrompt
+        case _                                                        =>
+      }
+      val endsWithNewLine = bytes.endsWith(lineSeparatorBytes)
+      if (endsWithNewLine || bytes.containsSlice(lineSeparatorBytes)) {
+        val parts = new String(bytes, "UTF-8").split(System.lineSeparator)
+        def appendLine(l: String, appendNewline: Boolean): Unit = {
+          toWrite ++= l.getBytes("UTF-8")
+          toWrite ++= clearScreenBytes
+          if (appendNewline) toWrite ++= lineSeparatorBytes
+        }
+        parts.dropRight(1).foreach(appendLine(_, true))
+        parts.lastOption match {
+          case Some(l) => appendLine(l, bytes.endsWith(lineSeparatorBytes))
+          case None    => toWrite ++= lineSeparatorBytes
+        }
+      } else toWrite ++= bytes
+      toWrite ++= clearScreenBytes
+      if (endsWithNewLine) {
+        if (progressLines.get.nonEmpty) {
+          val lastLine = terminal.prompt match {
+            case a: Prompt.AskUser => a.render()
+            case _                 => currentLine.getOrElse("")
+          }
+          val lines = printProgress(terminal, lastLine)
+          toWrite ++= lines.getBytes("UTF-8")
+        }
+        toWrite ++= getPrompt(terminal)
+      }
+      printStream.write(toWrite.toArray)
+      printStream.flush()
+    } else printStream.write(bytes)
+  }
+
+  private[util] def printProgress(terminal: Terminal, lastLine: String): String = {
+    val previousLines = progressLines.get
+    if (previousLines.nonEmpty) {
+      val currentLength = previousLines.foldLeft(0)(_ + terminal.lineCount(_))
+      val (height, width) = terminal.getLineHeightAndWidth(lastLine)
+      val offset = width > 0
+      val pad = math.max(padding.get - height, 0)
+      val start = (if (offset) s"\n$CursorLeft1000" else "")
+      val totalSize = currentLength + blankZone + pad
+      val blank = CursorLeft1000 + s"\n$DeleteLine" * (totalSize - currentLength)
+      val lines = previousLines.mkString(DeleteLine, s"\n$DeleteLine", s"\n$DeleteLine")
+      val resetCursorUp = cursorUp(totalSize + (if (offset) 1 else 0))
+      val resetCursor = resetCursorUp + CursorLeft1000 + lastLine
+      start + blank + lines + resetCursor
+    } else {
+      ClearScreenAfterCursor
+    }
+  }
+}
+
+private[sbt] object ProgressState {
+  private val SERVER_IS_RUNNING = "sbt server is running "
+  // the + 2 is for the quotation marks
+  private val SERVER_IS_RUNNING_LENGTH = SERVER_IS_RUNNING.length + 3
+
+  /**
+   * Receives a new task report and replaces the old one. In the event that the new
+   * report has fewer lines than the previous report, padding lines are added on top
+   * so that the console log lines remain contiguous. When a console line is printed
+   * at the info or greater level, we can decrement the padding because the console
+   * line will have filled in the blank line.
+   */
+  private[sbt] def updateProgressState(
+      pe: ProgressEvent,
+      terminal: Terminal
+  ): Unit = {
+    val state = terminal.progressState
+    val isAskUser = terminal.prompt.isInstanceOf[Prompt.AskUser]
+    val isRunning = terminal.prompt == Prompt.Running
+    val isBatch = terminal.prompt == Prompt.Batch
+    val isWatch = terminal.prompt == Prompt.Watch
+    if (terminal.isSupershellEnabled) {
+      setShowProgress(true) // used by Zinc to not show "done compiling"
+      if (!pe.skipIfActive.getOrElse(false) || (!isRunning && !isBatch)) {
+        terminal.withPrintStream { ps =>
+          val commandFromThisTerminal = pe.channelName.fold(true)(_ == terminal.name)
+          val info = if (commandFromThisTerminal) {
+            val base = pe.items.map { item =>
+              val elapsed = item.elapsedMicros / 1000000L
+              s"  | => ${item.name} ${elapsed}s"
+            }
+            val limit = state.maxItems
+            if (base.size > limit + 1)
+              s"  | ... (${base.size - limit} other tasks)" +: base.takeRight(limit)
+            else base
+          } else {
+            pe.command.toSeq.flatMap { cmd =>
+              val width = terminal.getWidth
+              val sanitized = if ((cmd.length + SERVER_IS_RUNNING_LENGTH) > width) {
+                cmd.take(width - 3 - SERVER_IS_RUNNING_LENGTH) + "..."
+              } else cmd
+              val tail = if (isWatch) Nil else "enter 'cancel' to stop evaluation" :: Nil
+              s"$SERVER_IS_RUNNING '$sanitized'" :: tail
+            }
+          }
+
+          val currentLength = info.foldLeft(0)(_ + terminal.lineCount(_))
+          val previousLines = state.progressLines.getAndSet(info)
+          val prevLength = previousLines.foldLeft(0)(_ + terminal.lineCount(_))
+          val prevSize = prevLength + state.padding.get
+
+          val lastLine =
+            if (isAskUser) terminal.prompt.render() else terminal.getLastLine.getOrElse("")
+          state.padding.set(math.max(0, prevSize - currentLength))
+          val toWrite =
+            state.getPrompt(terminal) ++ state.printProgress(terminal, lastLine).getBytes("UTF-8")
+          ps.write(toWrite)
+          ps.flush()
+        }
+      } else if (state.progressLines.get.nonEmpty) {
+        state.progressLines.set(Nil)
+        terminal.withPrintStream { ps =>
+          val lastLine = terminal.getLastLine.getOrElse("")
+          ps.print(lastLine + ClearScreenAfterCursor)
+          ps.flush()
+        }
+      }
+    }
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/Prompt.scala b/internal/util-logging/src/main/scala/sbt/internal/util/Prompt.scala
new file mode 100644
index 000000000..89c1872cb
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/Prompt.scala
@@ -0,0 +1,39 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.util.concurrent.LinkedBlockingQueue
+import scala.collection.JavaConverters._
+
+private[sbt] sealed trait Prompt {
+  def mkPrompt: () => String
+  def render(): String
+  def reset(): Unit
+}
+
+private[sbt] object Prompt {
+  private[sbt] case class AskUser(override val mkPrompt: () => String) extends Prompt {
+    private[this] val bytes = new LinkedBlockingQueue[Byte]
+    def write(b: Array[Byte]): Unit = b.foreach(bytes.put)
+    override def render(): String = {
+      val res = new String(bytes.asScala.toArray, "UTF-8")
+      if (res.endsWith(System.lineSeparator)) "" else res
+    }
+    override def reset(): Unit = bytes.clear()
+  }
+  private[sbt] trait NoPrompt extends Prompt {
+    override val mkPrompt: () => String = () => ""
+    override def render(): String = ""
+    override def reset(): Unit = {}
+  }
+  private[sbt] case object Running extends NoPrompt
+  private[sbt] case object Batch extends NoPrompt
+  private[sbt] case object Watch extends NoPrompt
+  private[sbt] case object Pending extends NoPrompt
+  private[sbt] case object NoPrompt extends NoPrompt
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/StackTrace.scala b/internal/util-logging/src/main/scala/sbt/internal/util/StackTrace.scala
new file mode 100644
index 000000000..f98c2d9ce
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/StackTrace.scala
@@ -0,0 +1,85 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.io.IO
+import scala.collection.mutable.ListBuffer
+
+object StackTrace {
+  def isSbtClass(name: String) = name.startsWith("sbt.") || name.startsWith("xsbt.")
+
+  /**
+   * Return a printable representation of the stack trace associated
+   * with t.  Information about t and its Throwable causes is included.
+   * The number of lines to be included for each Throwable is configured
+   * via d which should be greater than or equal to 0.
+   *
+   * - If d is 0, then all elements are included up to (but not including)
+   *   the first element that comes from sbt.
+   * - If d is greater than 0, then up to that many lines are included,
+   *   where the line for the Throwable is counted plus one line for each stack element.
+   *   Less lines will be included if there are not enough stack elements.
+   *
+   * See also ConsoleAppender where d <= 2 is treated specially by
+   * printing a prepared statement.
+   */
+  def trimmedLines(t: Throwable, d: Int): List[String] = {
+    require(d >= 0)
+    val b = new ListBuffer[String]()
+
+    def appendStackTrace(t: Throwable, first: Boolean): Unit = {
+
+      val include: StackTraceElement => Boolean =
+        if (d == 0)
+          element => !isSbtClass(element.getClassName)
+        else {
+          var count = d - 1
+          (_ => { count -= 1; count >= 0 })
+        }
+
+      def appendElement(e: StackTraceElement): Unit = {
+        b.append("\tat " + e)
+        ()
+      }
+
+      if (!first) b.append("Caused by: " + t.toString)
+      else b.append(t.toString)
+
+      val els = t.getStackTrace()
+      var i = 0
+      while ((i < els.size) && include(els(i))) {
+        appendElement(els(i))
+        i += 1
+      }
+
+    }
+
+    appendStackTrace(t, true)
+    var c = t
+    while (c.getCause() != null) {
+      c = c.getCause()
+      appendStackTrace(c, false)
+    }
+    b.toList
+  }
+
+  /**
+   * Return a printable representation of the stack trace associated
+   * with t.  Information about t and its Throwable causes is included.
+   * The number of lines to be included for each Throwable is configured
+   * via d which should be greater than or equal to 0.
+   *
+   * - If d is 0, then all elements are included up to (but not including)
+   *   the first element that comes from sbt.
+   * - If d is greater than 0, then up to that many lines are included,
+   *   where the line for the Throwable is counted plus one line for each stack element.
+   *   Less lines will be included if there are not enough stack elements.
+   */
+  def trimmed(t: Throwable, d: Int): String =
+    trimmedLines(t, d).mkString(IO.Newline)
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/StringTypeTag.scala b/internal/util-logging/src/main/scala/sbt/internal/util/StringTypeTag.scala
new file mode 100644
index 000000000..e2b54232a
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/StringTypeTag.scala
@@ -0,0 +1,57 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import scala.language.experimental.macros
+import scala.reflect.runtime.universe._
+
+/** This is used to carry type information in JSON. */
+final case class StringTypeTag[A](key: String) {
+  override def toString: String = key
+}
+
+object StringTypeTag {
+
+  /** Generates a StringTypeTag for any type at compile time. */
+  implicit def fast[A]: StringTypeTag[A] = macro appmacro.StringTypeTag.impl[A]
+  @deprecated("Prefer macro generated StringTypeTag", "1.4.0")
+  def apply[A: TypeTag]: StringTypeTag[A] =
+    synchronized {
+      def doApply: StringTypeTag[A] = {
+        val tag = implicitly[TypeTag[A]]
+        val tpe = tag.tpe
+        val k = typeToString(tpe)
+        // println(tpe.getClass.toString + " " + k)
+        StringTypeTag[A](k)
+      }
+      def retry(n: Int): StringTypeTag[A] =
+        try {
+          doApply
+        } catch {
+          case e: NullPointerException =>
+            if (n < 1) throw new RuntimeException("NPE in StringTypeTag", e)
+            else {
+              Thread.sleep(1)
+              retry(n - 1)
+            }
+        }
+      retry(3)
+    }
+
+  @deprecated("Prefer macro generated StringTypeTag", "1.4.0")
+  def typeToString(tpe: Type): String =
+    tpe match {
+      case TypeRef(_, sym, args) =>
+        if (args.nonEmpty) {
+          val typeCon = tpe.typeSymbol.fullName
+          val typeArgs = args map typeToString
+          s"""$typeCon[${typeArgs.mkString(",")}]"""
+        } else tpe.toString
+      case _ => tpe.toString
+    }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala b/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala
new file mode 100644
index 000000000..dac378cdf
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala
@@ -0,0 +1,1022 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.{ InputStream, InterruptedIOException, IOException, OutputStream, PrintStream }
+import java.nio.channels.ClosedChannelException
+import java.util.{ Arrays, Locale }
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+import java.util.concurrent.{ Executors, LinkedBlockingQueue, TimeUnit }
+
+import jline.console.ConsoleReader
+import scala.annotation.tailrec
+import scala.concurrent.duration._
+import scala.util.Try
+import scala.util.control.NonFatal
+
+trait Terminal extends AutoCloseable {
+
+  /**
+   * Gets the current width of the terminal. The implementation reads a property from the jline
+   * config which is updated if it has been more than a second since the last update. It is thus
+   * possible for this value to be stale.
+   *
+   * @return the terminal width.
+   */
+  def getWidth: Int
+
+  /**
+   * Gets the current height of the terminal. The implementation reads a property from the jline
+   * config which is updated if it has been more than a second since the last update. It is thus
+   * possible for this value to be stale.
+   *
+   * @return the terminal height.
+   */
+  def getHeight: Int
+
+  /**
+   * Returns the height and width of the current line that is displayed on the terminal. If the
+   * most recently flushed byte is a newline, this will be `(0, 0)`.
+   *
+   * @return the (height, width) pair
+   */
+  def getLineHeightAndWidth(line: String): (Int, Int)
+
+  /**
+   * Gets the input stream for this Terminal. This could be a wrapper around System.in for the
+   * process or it could be a remote input stream for a network channel.
+   * @return the input stream.
+   */
+  def inputStream: InputStream
+
+  /**
+   * Gets the output stream for this Terminal.
+   * @return the output stream.
+   */
+  def outputStream: OutputStream
+
+  /**
+   * Gets the error stream for this Terminal.
+   * @return the error stream.
+   */
+  def errorStream: OutputStream
+
+  /**
+   * Returns true if the terminal supports ansi characters.
+   *
+   * @return true if the terminal supports ansi escape codes.
+   */
+  def isAnsiSupported: Boolean
+
+  /**
+   * Returns true if color is enabled for this terminal.
+   *
+   * @return true if color is enabled for this terminal.
+   */
+  def isColorEnabled: Boolean
+
+  /**
+   * Returns true if the terminal has echo enabled.
+   *
+   * @return true if the terminal has echo enabled.
+   */
+  def isEchoEnabled: Boolean
+
+  /**
+   * Returns true if the terminal has success enabled, which it may not if it is for batch
+   * commands because the client will print the success results when received from the
+   * server.
+   *
+   * @return true if the terminal has success enabled
+   */
+  def isSuccessEnabled: Boolean
+
+  /**
+   * Returns true if the terminal has supershell enabled.
+   *
+   * @return true if the terminal has supershell enabled.
+   */
+  def isSupershellEnabled: Boolean
+
+  /**
+   * Toggles whether or not the terminal should echo characters back to stdout
+   *
+   * @return the previous value of the toggle
+   */
+  def setEchoEnabled(toggle: Boolean): Unit
+
+  /*
+   * The methods below this comment are implementation details that are in
+   * some cases specific to jline2. These methods may need to change or be
+   * removed if/when sbt upgrades to jline 3.
+   */
+
+  /**
+   * Returns the last line written to the terminal's output stream.
+   * @return the last line
+   */
+  private[sbt] def getLastLine: Option[String]
+
+  /**
+   * Returns the buffered lines that have been written to the terminal. The
+   * main use case is to display the system startup log lines when a client
+   * connects to a booting server. This could also be used to implement a more
+   * tmux like experience where multiple clients connect to the same console.
+   *
+   * @return the lines
+   */
+  private[sbt] def getLines: Seq[String]
+
+  private[sbt] def getBooleanCapability(capability: String): Boolean
+  private[sbt] def getNumericCapability(capability: String): Integer
+  private[sbt] def getStringCapability(capability: String): String
+  private[sbt] def getAttributes: Map[String, String]
+  private[sbt] def setAttributes(attributes: Map[String, String]): Unit
+  private[sbt] def setSize(width: Int, height: Int): Unit
+
+  private[sbt] def name: String
+  private[sbt] final def withRawInput[T](f: => T): T = {
+    enterRawMode()
+    try f
+    catch { case e: InterruptedIOException => throw new InterruptedException } finally exitRawMode()
+  }
+  private[sbt] def enterRawMode(): Unit
+  private[sbt] def exitRawMode(): Unit
+  private[sbt] def write(bytes: Int*): Unit
+  private[sbt] def printStream: PrintStream
+  private[sbt] def withPrintStream[T](f: PrintStream => T): T
+  private[sbt] def withRawOutput[R](f: => R): R
+  private[sbt] def restore(): Unit = {}
+  private[sbt] def progressState: ProgressState
+  private[this] val promptHolder: AtomicReference[Prompt] = new AtomicReference(Prompt.Batch)
+  private[sbt] final def prompt: Prompt = promptHolder.get
+  private[sbt] final def setPrompt(newPrompt: Prompt): Unit =
+    if (prompt != Prompt.NoPrompt) promptHolder.set(newPrompt)
+
+  /**
+   * Returns the number of lines that the input string will cover given the current width of the
+   * terminal.
+   *
+   * @param line the input line
+   * @return the number of lines that the line will cover on the terminal
+   */
+  private[sbt] def lineCount(line: String): Int = {
+    val lines = EscHelpers.stripColorsAndMoves(line).split('\n')
+    val width = getWidth
+    def count(l: String): Int = {
+      val len = l.length
+      if (width > 0 && len > 0) (len - 1 + width) / width else 0
+    }
+    if (lines.nonEmpty) lines.tail.foldLeft(lines.headOption.fold(0)(count))(_ + count(_))
+    else 0
+  }
+  private[sbt] def flush(): Unit = printStream.flush()
+}
+
+object Terminal {
+  val NO_BOOT_CLIENTS_CONNECTED: Int = -2
+  // Disable noisy jline log spam
+  if (System.getProperty("sbt.jline.verbose", "false") != "true")
+    jline.internal.Log.setOutput(new PrintStream(_ => {}, false))
+  private[this] val isCI = System.getProperty("sbt.ci", "") == "true" ||
+    sys.env.contains("BUILD_NUMBER") || sys.env.contains("CI")
+  def consoleLog(string: String): Unit = {
+    try Terminal.console.printStream.println(s"[info] $string")
+    catch { case _: IOException => }
+  }
+  private[sbt] def set(terminal: Terminal): Terminal = activeTerminal.getAndSet(terminal)
+  implicit class TerminalOps(private val term: Terminal) extends AnyVal {
+    def ansi(richString: => String, string: => String): String =
+      if (term.isAnsiSupported) richString else string
+    /*
+     * Whenever we are dealing with JLine, which is true in sbt's ConsoleReader
+     * as well as in the scala `console` task, we need to provide a jline.Terminal2
+     * instance that can be consumed by the ConsoleReader. The ConsoleTerminal
+     * already wraps a jline terminal, so we can just return the wrapped jline
+     * terminal.
+     */
+    private[sbt] def toJLine: jline.Terminal with jline.Terminal2 = term match {
+      case _ =>
+        new jline.Terminal with jline.Terminal2 {
+          override def init(): Unit = {}
+          override def restore(): Unit = {}
+          override def reset(): Unit = {}
+          override def isSupported: Boolean = true
+          override def getWidth: Int = term.getWidth
+          override def getHeight: Int = term.getHeight
+          override def isAnsiSupported: Boolean = term.isAnsiSupported
+          override def wrapOutIfNeeded(out: OutputStream): OutputStream = out
+          override def wrapInIfNeeded(in: InputStream): InputStream = in
+          override def hasWeirdWrap: Boolean = false
+          override def isEchoEnabled: Boolean = term.isEchoEnabled
+          override def setEchoEnabled(enabled: Boolean): Unit = {}
+          override def disableInterruptCharacter(): Unit = {}
+          override def enableInterruptCharacter(): Unit = {}
+          override def getOutputEncoding: String = null
+          override def getBooleanCapability(capability: String): Boolean =
+            term.getBooleanCapability(capability)
+          override def getNumericCapability(capability: String): Integer =
+            term.getNumericCapability(capability)
+          override def getStringCapability(capability: String): String =
+            term.getStringCapability(capability)
+        }
+    }
+  }
+
+  /*
+   * Closes the standard input and output streams for the process. This allows
+   * the sbt client to detach from the server it launches.
+   */
+  def close(): Unit = {
+    if (System.console == null) {
+      originalOut.close()
+      originalIn.close()
+      originalErr.close()
+    }
+  }
+
+  /**
+   * Returns true if System.in is attached. When sbt is run as a subprocess, like in scripted or
+   * as a server, System.in will not be attached and this method will return false. Otherwise
+   * it will return true.
+   *
+   * @return true if System.in is attached.
+   */
+  def systemInIsAttached: Boolean = attached.get
+
+  def read: Int = inputStream.get match {
+    case null => -1
+    case is   => is.read
+  }
+
+  /**
+   * Returns an InputStream that will throw a [[ClosedChannelException]] if read returns -1.
+   * @return the wrapped InputStream.
+   */
+  private[sbt] def throwOnClosedSystemIn(in: InputStream): InputStream = new InputStream {
+    override def available(): Int = in.available()
+    override def read(): Int = in.read() match {
+      case -1          => throw new ClosedChannelException
+      case r if r >= 0 => r
+      case _           => -1
+    }
+  }
+
+  /**
+   * Provides a wrapper around System.in. The wrapped stream in will check if the terminal is attached
+   * in available and read. If a read returns -1, it will mark System.in as unattached so that
+   * it can be detected by [[systemInIsAttached]].
+   *
+   * @return the wrapped InputStream
+   */
+  private[sbt] def wrappedSystemIn: InputStream = WrappedSystemIn
+
+  /**
+   * Restore the terminal to its initial state.
+   */
+  private[sbt] def restore(): Unit = console.toJLine.restore()
+
+  private[this] val hasProgress: AtomicBoolean = new AtomicBoolean(false)
+
+  private[sbt] def parseLogOption(s: String): Option[Boolean] =
+    s.toLowerCase match {
+      case "always" => Some(true)
+      case "auto"   => None
+      case "never"  => Some(false)
+      case "true"   => Some(true)
+      case "false"  => Some(false)
+      case _        => None
+    }
+
+  /**
+   * Indicates whether formatting has been disabled in environment variables.
+   * 1. -Dsbt.log.noformat=true means no formatting.
+   * 2. -Dsbt.color=always/auto/never/true/false
+   * 3. -Dsbt.colour=always/auto/never/true/false
+   * 4. -Dsbt.log.format=always/auto/never/true/false
+   */
+  private[this] lazy val logFormatEnabled: Option[Boolean] = {
+    sys.props.get("sbt.log.noformat") match {
+      case Some(_) => Some(!java.lang.Boolean.getBoolean("sbt.log.noformat"))
+      case _       => sys.props.get("sbt.log.format").flatMap(parseLogOption)
+    }
+  }
+  private[sbt] lazy val isAnsiSupported: Boolean = logFormatEnabled.getOrElse(useColorDefault)
+
+  private[this] val isDumb = "dumb" == System.getenv("TERM")
+  private[this] def isDumbTerminal = isDumb || System.getProperty("jline.terminal", "") == "none"
+  private[this] val hasConsole = Option(java.lang.System.console).isDefined
+  private[this] def useColorDefault: Boolean = {
+    // This approximates that both stdin and stdio are connected,
+    // so by default color will be turned off for pipes and redirects.
+    props
+      .map(_.color)
+      .orElse(isColorEnabledProp)
+      .getOrElse(
+        logFormatEnabled
+          .getOrElse(true) && ((hasConsole && !isDumbTerminal) || isCI || Util.isEmacs)
+      )
+  }
+  private[this] lazy val isColorEnabledProp: Option[Boolean] =
+    sys.props.get("sbt.color").orElse(sys.props.get("sbt.colour")).flatMap(parseLogOption)
+  private[sbt] lazy val isColorEnabled = useColorDefault
+
+  private[sbt] def red(str: String, doRed: Boolean): String =
+    if (isColorEnabled && doRed) Console.RED + str + Console.RESET
+    else str
+
+  private[this] def hasVirtualIO = System.getProperty("sbt.io.virtual", "") == "true" || !isCI
+  private[sbt] def canPollSystemIn: Boolean = hasConsole && !isDumbTerminal && hasVirtualIO
+
+  /**
+   *
+   * @param isServer toggles whether or not this is a server of client process
+   * @param f the thunk to run
+   * @tparam T the result type of the thunk
+   * @return the result of the thunk
+   */
+  private[sbt] def withStreams[T](isServer: Boolean, isSubProcess: Boolean)(f: => T): T = {
+    // In ci environments, don't touch the io streams unless run with -Dsbt.io.virtual=true
+    if ((hasConsole && !isDumbTerminal) || isSubProcess)
+      consoleTerminalHolder.set(newConsoleTerminal())
+    if (hasVirtualIO) {
+      hasProgress.set(isServer && isAnsiSupported)
+      activeTerminal.set(consoleTerminalHolder.get)
+      try withOut(withIn(f))
+      finally {
+        jline.TerminalFactory.reset()
+        if (isServer) {
+          console match {
+            case c: ConsoleTerminal if !isWindows =>
+              /*
+               * Entering raw mode in this way causes the standard in InputStream
+               * to become non-blocking. After we set it to non-blocking, we spin
+               * up a thread that reads from the inputstream and the resets it
+               * back to blocking mode. We can then close the console. We do
+               * this on a background thread in case the read blocks indefinitely.
+               */
+              c.system.enterRawMode()
+              val runnable: Runnable = () => {
+                try Util.ignoreResult(c.inputStream.read)
+                catch { case _: InterruptedException => }
+              }
+              val thread = new Thread(runnable, "sbt-console-background-close")
+              thread.setDaemon(true)
+              thread.start()
+              // The thread should exit almost instantly but give it 200ms to spin up
+              thread.join(200)
+              if (thread.isAlive) thread.interrupt()
+              c.close()
+            case c => c.close()
+          }
+        } else {
+          console.close()
+        }
+      }
+    } else f
+  }
+
+  private[this] object ProxyTerminal extends Terminal {
+    private def t: Terminal = activeTerminal.get
+    override private[sbt] def progressState: ProgressState = t.progressState
+    override private[sbt] def enterRawMode(): Unit = t.enterRawMode()
+    override private[sbt] def exitRawMode(): Unit = t.exitRawMode()
+    override def getWidth: Int = t.getWidth
+    override def getHeight: Int = t.getHeight
+    override def getLineHeightAndWidth(line: String): (Int, Int) = t.getLineHeightAndWidth(line)
+    override def lineCount(line: String): Int = t.lineCount(line)
+    override def inputStream: InputStream = t.inputStream
+    override def outputStream: OutputStream = t.outputStream
+    override def errorStream: OutputStream = t.errorStream
+    override def isAnsiSupported: Boolean = t.isAnsiSupported
+    override def isColorEnabled: Boolean = t.isColorEnabled
+    override def isEchoEnabled: Boolean = t.isEchoEnabled
+    override def isSuccessEnabled: Boolean = t.isSuccessEnabled
+    override def isSupershellEnabled: Boolean = t.isSupershellEnabled
+    override def setEchoEnabled(toggle: Boolean): Unit = t.setEchoEnabled(toggle)
+    override def getBooleanCapability(capability: String): Boolean =
+      t.getBooleanCapability(capability)
+    override def getNumericCapability(capability: String): Integer =
+      t.getNumericCapability(capability)
+    override def getStringCapability(capability: String): String =
+      t.getStringCapability(capability)
+    override private[sbt] def getAttributes: Map[String, String] = t.getAttributes
+    override private[sbt] def setAttributes(attributes: Map[String, String]): Unit =
+      t.setAttributes(attributes)
+    override private[sbt] def setSize(width: Int, height: Int): Unit = t.setSize(width, height)
+    override def printStream: PrintStream = t.printStream
+    override def withPrintStream[T](f: PrintStream => T): T = t.withPrintStream(f)
+    override private[sbt] def withRawOutput[R](f: => R): R = t.withRawOutput(f)
+    override def restore(): Unit = t.restore()
+    override def close(): Unit = {}
+    override private[sbt] def write(bytes: Int*): Unit = t.write(bytes: _*)
+    override def getLastLine: Option[String] = t.getLastLine
+    override def getLines: Seq[String] = t.getLines
+    override private[sbt] def name: String = t.name
+    override def toString: String = s"ProxyTerminal(current = $t)"
+  }
+  private[sbt] def get: Terminal = ProxyTerminal
+
+  private[sbt] def withIn[T](in: InputStream)(f: => T): T = {
+    val original = inputStream.get
+    try {
+      inputStream.set(in)
+      System.setIn(in)
+      scala.Console.withIn(in)(f)
+    } finally {
+      inputStream.set(original)
+      System.setIn(original)
+    }
+  }
+
+  private[sbt] def withOut[T](out: PrintStream)(f: => T): T = {
+    val originalOut = System.out
+    val originalErr = System.err
+    val originalProxyOut = ConsoleOut.getGlobalProxy
+    try {
+      ConsoleOut.setGlobalProxy(ConsoleOut.printStreamOut(out))
+      System.setOut(out)
+      System.setErr(out)
+      scala.Console.withErr(out)(scala.Console.withOut(out)(f))
+    } finally {
+      ConsoleOut.setGlobalProxy(originalProxyOut)
+      System.setOut(originalOut)
+      System.setErr(originalErr)
+    }
+  }
+
+  val sepBytes = System.lineSeparator.getBytes("UTF-8")
+  private class LinePrintStream(outputStream: OutputStream)
+      extends PrintStream(outputStream, true) {
+    override def println(s: String): Unit = synchronized {
+      out.write(s.getBytes("UTF-8") ++ sepBytes)
+      out.flush()
+    }
+  }
+  private[this] val originalOut = new LinePrintStream(System.out)
+  private[this] val originalErr = System.err
+  private[this] val originalIn = System.in
+  private[sbt] class WriteableInputStream(in: InputStream, name: String)
+      extends SimpleInputStream
+      with AutoCloseable {
+    private[this] val isRaw = new AtomicBoolean(false)
+    final def write(bytes: Int*): Unit = buffer.synchronized {
+      bytes.foreach(b => buffer.put(b))
+    }
+    def setRawMode(toggle: Boolean): Unit = {
+      isRaw.set(toggle)
+      in match {
+        case win: WindowsInputStream => win.setRawMode(toggle)
+        case _                       =>
+      }
+    }
+    private[this] val executor =
+      Executors.newSingleThreadExecutor(r => new Thread(r, s"sbt-$name-input-reader"))
+    private[this] val buffer = new LinkedBlockingQueue[Integer]
+    private[this] val closed = new AtomicBoolean(false)
+    private[this] val readQueue = new LinkedBlockingQueue[Unit]
+    private[this] val readThread = new AtomicReference[Thread]
+    /*
+     * Starts a loop that fills a buffer with bytes from stdin. We only read from
+     * the underlying stream when the buffer is empty and there is an active reader.
+     * If the reader detaches without consuming any bytes, we just buffer the
+     * next byte that we read from the stream. One known issue with this approach
+     * is that if a remote client triggers a reboot, we cannot necessarily stop this
+     * loop from consuming the next byte from standard in even if sbt has fully
+     * rebooted and the byte will never be consumed. We try to fix this in withStreams
+     * by setting the terminal to raw mode, which the input stream makes it non blocking,
+     * but this approach only works on posix platforms.
+     */
+    private[this] val runnable: Runnable = () => {
+      @tailrec def impl(): Unit = {
+        val _ = readQueue.take
+        val b = in.read
+        buffer.synchronized(buffer.put(b))
+        if (Thread.interrupted() || (b == -1 && isRaw.get)) closed.set(true)
+        else impl()
+      }
+      try impl()
+      catch { case _: InterruptedException => closed.set(true) }
+    }
+    executor.submit(runnable)
+    def read(result: LinkedBlockingQueue[Integer]): Unit =
+      if (!closed.get)
+        readThread.synchronized {
+          readThread.set(Thread.currentThread)
+          try buffer.poll match {
+            case null =>
+              readQueue.put(())
+              result.put(buffer.take)
+            case b if b == -1 => throw new ClosedChannelException
+            case b            => result.put(b)
+          } finally readThread.set(null)
+        }
+    override def read(): Int = {
+      val result = new LinkedBlockingQueue[Integer]
+      read(result)
+      result.poll match {
+        case null => -1
+        case i    => i.toInt
+      }
+    }
+    def cancel(): Unit = readThread.synchronized {
+      Option(readThread.getAndSet(null)).foreach(_.interrupt())
+      readQueue.clear()
+    }
+
+    override def available(): Int = {
+      buffer.size
+    }
+    override def close(): Unit = if (closed.compareAndSet(false, true)) {
+      executor.shutdownNow()
+      ()
+    }
+  }
+  private[this] def nonBlockingIn(term: org.jline.terminal.Terminal): WriteableInputStream = {
+    val in = if (Util.isNonCygwinWindows) new WindowsInputStream(term, originalIn) else originalIn
+    new WriteableInputStream(in, "console")
+  }
+
+  private[this] val inputStream = new AtomicReference[InputStream](System.in)
+  private[this] def withOut[T](f: => T): T = {
+    try {
+      System.setOut(proxyPrintStream)
+      System.setErr(proxyErrorStream)
+      scala.Console.withErr(proxyErrorStream)(scala.Console.withOut(proxyPrintStream)(f))
+    } finally {
+      System.setOut(originalOut)
+      System.setErr(originalErr)
+    }
+  }
+  private[this] def withIn[T](f: => T): T =
+    try {
+      inputStream.set(proxyInputStream)
+      System.setIn(proxyInputStream)
+      scala.Console.withIn(proxyInputStream)(f)
+    } finally System.setIn(originalIn)
+
+  private[sbt] def withPrintStream[T](f: PrintStream => T): T = console.withPrintStream(f)
+  private[this] val attached = new AtomicBoolean(true)
+
+  /**
+   * A wrapped instance of a jline.Terminal2 instance. It should only ever be changed when the
+   * backgrounds sbt with ctrl+z and then foregrounds sbt which causes a call to reset. The
+   * Terminal.console method returns this terminal and the ConsoleChannel delegates its
+   * terminal method to it.
+   */
+  private[this] val consoleTerminalHolder: AtomicReference[Terminal] =
+    new AtomicReference(SimpleTerminal)
+
+  /**
+   * The terminal that is currently being used by the proxyInputStream and proxyOutputStream.
+   * It is set through the Terminal.set method which is called by the SetTerminal command, which
+   * is used to change the terminal during task evaluation. This allows us to route System.in and
+   * System.out through the terminal's input and output streams.
+   */
+  private[this] val activeTerminal = new AtomicReference[Terminal](consoleTerminalHolder.get)
+
+  /**
+   * The boot input stream allows a remote client to forward input to the sbt process while
+   * it is still loading. It works by updating proxyInputStream to read from the
+   * value of bootInputStreamHolder if it is non-null as well as from the normal process
+   * console io (assuming there is console io).
+   */
+  private[this] val bootInputStreamHolder = new AtomicReference[InputStream]
+
+  /**
+   * The boot output stream allows sbt to relay the bytes written to stdout to one or
+   * more remote clients while the sbt build is loading and hasn't yet loaded a server.
+   * The output stream of TerminalConsole is updated to write to value of
+   * bootOutputStreamHolder when it is non-null as well as the normal process console
+   * output stream.
+   */
+  private[this] val bootOutputStreamHolder = new AtomicReference[OutputStream]
+  private[sbt] def setBootStreams(
+      bootInputStream: InputStream,
+      bootOutputStream: OutputStream
+  ): Unit = {
+    bootInputStreamHolder.set(bootInputStream)
+    bootOutputStreamHolder.set(bootOutputStream)
+  }
+
+  private[sbt] trait SimpleInputStream extends InputStream {
+    override def read(b: Array[Byte]): Int = read(b, 0, b.length)
+    override def read(b: Array[Byte], off: Int, len: Int): Int = {
+      read() match {
+        case -1 => -1
+        case byte =>
+          b(off) = byte.toByte
+          1
+      }
+    }
+  }
+  private[this] object proxyInputStream extends SimpleInputStream {
+    private[this] val isScripted = System.getProperty("sbt.scripted", "false") == "true"
+    /*
+     * This is to handle the case when a remote client starts sbt and the build fails.
+     * We need to be able to consume input bytes from the remote client, but they
+     * haven't yet connected to the main server but may be connected to the
+     * BootServerSocket. Unfortunately there is no poll method on input stream that
+     * takes a duration so we have to manually implement that here. All of the input
+     * streams that we create in sbt are interruptible, so we can just poll each
+     * of the input streams and periodically interrupt the thread to switch between
+     * the two input streams.
+     */
+    private class ReadThread extends Thread with AutoCloseable {
+      val result = new LinkedBlockingQueue[Integer]
+      val running = new AtomicBoolean(true)
+      setDaemon(true)
+      start()
+      override def run(): Unit = while (running.get) {
+        bootInputStreamHolder.get match {
+          case null =>
+          case is =>
+            def readFrom(inputStream: InputStream) =
+              try {
+                if (running.get) {
+                  inputStream.read match {
+                    case -1 =>
+                    case `NO_BOOT_CLIENTS_CONNECTED` =>
+                      if (System.console == null) {
+                        result.put(-1)
+                        running.set(false)
+                      }
+                    case i =>
+                      result.put(i)
+                      running.set(false)
+                  }
+                }
+              } catch { case _: InterruptedException => }
+            readFrom(is)
+            readFrom(activeTerminal.get().inputStream)
+        }
+      }
+      override def close(): Unit = if (running.compareAndSet(true, false)) this.interrupt()
+    }
+    def read(): Int = {
+      if (isScripted) -1
+      else if (bootInputStreamHolder.get == null) activeTerminal.get().inputStream.read()
+      else {
+        val thread = new ReadThread
+        @tailrec def poll(): Int = thread.result.poll(10, TimeUnit.MILLISECONDS) match {
+          case null =>
+            thread.interrupt()
+            poll()
+          case i => i
+        }
+        poll()
+      }
+    }
+  }
+  private[this] object proxyOutputStream extends OutputStream {
+    private[this] def os: OutputStream = activeTerminal.get().outputStream
+    def write(byte: Int): Unit = {
+      os.write(byte)
+      os.flush()
+      if (byte == 10) os.flush()
+    }
+    override def write(bytes: Array[Byte]): Unit = write(bytes, 0, bytes.length)
+    override def write(bytes: Array[Byte], offset: Int, len: Int): Unit = {
+      os.write(bytes, offset, len)
+      os.flush()
+    }
+    override def flush(): Unit = os.flush()
+  }
+  private[this] val proxyPrintStream = new LinePrintStream(proxyOutputStream) {
+    override def toString: String = s"proxyPrintStream($proxyOutputStream)"
+  }
+  private[this] object proxyErrorOutputStream extends OutputStream {
+    private[this] def os: OutputStream = activeTerminal.get().errorStream
+    def write(byte: Int): Unit = os.write(byte)
+    override def write(bytes: Array[Byte]): Unit = write(bytes, 0, bytes.length)
+    override def write(bytes: Array[Byte], offset: Int, len: Int): Unit =
+      os.write(bytes, offset, len)
+    override def flush(): Unit = os.flush()
+  }
+  private[this] object proxyErrorStream extends PrintStream(proxyErrorOutputStream, true)
+  private[this] lazy val isWindows =
+    System.getProperty("os.name", "").toLowerCase(Locale.ENGLISH).indexOf("windows") >= 0
+  private[this] object WrappedSystemIn extends SimpleInputStream {
+    private[this] val in = proxyInputStream
+    override def available(): Int = if (attached.get) in.available() else 0
+    override def read(): Int = synchronized {
+      if (attached.get) {
+        val res = in.read()
+        if (res == -1) attached.set(false)
+        res
+      } else -1
+    }
+  }
+
+  /*
+   * When the server is booted by a remote client, it may not be able to accurately
+   * calculate the terminal properties. To work around this, we can set the
+   * properties via an environment property. It was too difficult to get system
+   * properties working correctly with windows.
+   */
+  private class Props(
+      val width: Int,
+      val height: Int,
+      val ansi: Boolean,
+      val color: Boolean,
+      val supershell: Boolean
+  )
+  private[sbt] val TERMINAL_PROPS = "SBT_TERMINAL_PROPS"
+  private val props = System.getenv(TERMINAL_PROPS) match {
+    case null => None
+    case p =>
+      p.split(",") match {
+        case Array(width, height, ansi, color, supershell) =>
+          Try(
+            new Props(
+              width.toInt,
+              height.toInt,
+              ansi.toBoolean,
+              color.toBoolean,
+              supershell.toBoolean
+            )
+          ).toOption
+        case _ => None
+      }
+  }
+  private[sbt] def startedByRemoteClient = props.isDefined
+
+  private[this] def newConsoleTerminal(): Terminal = {
+    val system = JLine3.system
+    new ConsoleTerminal(nonBlockingIn(system), originalOut, system)
+  }
+
+  private[sbt] def reset(): Unit = {
+    jline.TerminalFactory.reset()
+    console.close()
+    if (hasConsole && !isDumbTerminal) consoleTerminalHolder.set(newConsoleTerminal())
+  }
+
+  // translate explicit class names to type in order to support
+  //  older Scala, since it shaded classes but not the system property
+  private[this] def fixTerminalProperty(): Unit = {
+    val terminalProperty = "jline.terminal"
+    val newValue =
+      if (!isAnsiSupported && System.getProperty("sbt.io.virtual", "") == "false") "none"
+      else
+        System.getProperty(terminalProperty) match {
+          case "jline.UnixTerminal"                             => "unix"
+          case null if System.getProperty("sbt.cygwin") != null => "unix"
+          case "jline.WindowsTerminal"                          => "windows"
+          case "jline.AnsiWindowsTerminal"                      => "windows"
+          case "jline.UnsupportedTerminal"                      => "none"
+          case null if isDumb                                   => "none"
+          case x                                                => x
+        }
+    if (newValue != null) {
+      System.setProperty(terminalProperty, newValue)
+      ()
+    }
+  }
+  fixTerminalProperty()
+
+  private[sbt] def createReader(term: Terminal, prompt: Prompt): ConsoleReader = {
+    new ConsoleReader(term.inputStream, term.outputStream, term.toJLine) {
+      override def readLine(prompt: String, mask: Character): String =
+        term.withRawInput(super.readLine(prompt, mask))
+      override def readLine(prompt: String): String = term.withRawInput(super.readLine(prompt))
+    }
+  }
+
+  def console: Terminal = consoleTerminalHolder.get match {
+    case null => throw new IllegalStateException("Uninitialized terminal.")
+    case term => term
+  }
+
+  private val capabilityMap =
+    org.jline.utils.InfoCmp.Capability.values().map(c => c.toString -> c).toMap
+  private val consoleProgressState = new AtomicReference[ProgressState](new ProgressState(1))
+  private[sbt] def setConsoleProgressState(progressState: ProgressState): Unit =
+    consoleProgressState.set(progressState)
+
+  @deprecated("For compatibility only", "1.4.0")
+  private[sbt] def deprecatedTeminal: jline.Terminal = console.toJLine
+  private[util] class ConsoleTerminal(
+      in: WriteableInputStream,
+      out: OutputStream,
+      private[util] val system: org.jline.terminal.Terminal,
+  ) extends TerminalImpl(in, out, originalErr, "console0") {
+    private[this] val rawMode = new AtomicBoolean(false)
+    if (Util.isWindows && hasConsole) {
+      // It is necessary to enter and exit raw mode in order to get the windows
+      // console to echo input.
+      enterRawMode()
+      exitRawMode()
+    }
+    override private[sbt] def getSizeImpl: (Int, Int) = {
+      val size = system.getSize
+      (size.getColumns, size.getRows)
+    }
+    override lazy val isAnsiSupported: Boolean =
+      !isDumbTerminal && Terminal.isAnsiSupported && !isCI
+    override private[sbt] def progressState: ProgressState = consoleProgressState.get
+    override def isEchoEnabled: Boolean =
+      try system.echo()
+      catch { case _: InterruptedIOException => false }
+    override def isSuccessEnabled: Boolean = true
+    override def setEchoEnabled(toggle: Boolean): Unit =
+      try Util.ignoreResult(system.echo(toggle))
+      catch { case _: InterruptedIOException => }
+    override def getBooleanCapability(capability: String): Boolean =
+      capabilityMap.get(capability).fold(false)(system.getBooleanCapability)
+    override def getNumericCapability(capability: String): Integer =
+      capabilityMap.get(capability).fold(null: Integer)(system.getNumericCapability)
+    override def getStringCapability(capability: String): String = {
+      val res = capabilityMap.get(capability).fold(null: String)(system.getStringCapability)
+      res
+    }
+    override private[sbt] def restore(): Unit = exitRawMode()
+
+    override private[sbt] def getAttributes: Map[String, String] =
+      Try(JLine3.toMap(system.getAttributes)).getOrElse(Map.empty)
+    override private[sbt] def setAttributes(attributes: Map[String, String]): Unit = {
+      system.setAttributes(JLine3.attributesFromMap(attributes))
+      JLine3.setEnableProcessInput()
+    }
+    override private[sbt] def setSize(width: Int, height: Int): Unit =
+      system.setSize(new org.jline.terminal.Size(width, height))
+
+    override def inputStream: InputStream = in
+
+    override private[sbt] def enterRawMode(): Unit =
+      if (rawMode.compareAndSet(false, true) && hasConsole) {
+        in.setRawMode(true)
+        try JLine3.enterRawMode(system)
+        catch { case _: java.io.IOError => }
+      }
+    override private[sbt] def exitRawMode(): Unit =
+      if (rawMode.compareAndSet(true, false) && hasConsole) {
+        in.setRawMode(false)
+        try JLine3.exitRawMode(system)
+        catch { case _: java.io.IOError => }
+      }
+    override def isColorEnabled: Boolean =
+      props
+        .map(_.color)
+        .getOrElse(isColorEnabledProp.getOrElse(Terminal.isColorEnabled))
+
+    override def isSupershellEnabled: Boolean =
+      props
+        .map(_.supershell)
+        .getOrElse(System.getProperty("sbt.supershell") match {
+          case null =>
+            !(sys.env.contains("BUILD_NUMBER") || sys.env
+              .contains("CI")) && isColorEnabled && !Util.isEmacs
+          case "true" => true
+          case _      => false
+        })
+    override def close(): Unit = {
+      try {
+        system.setAttributes(JLine3.initialAttributes.get)
+        system.close()
+        in.close()
+      } catch { case NonFatal(_) => }
+      super.close()
+    }
+  }
+  private[sbt] abstract class TerminalImpl private[sbt] (
+      val in: WriteableInputStream,
+      val out: OutputStream,
+      override val errorStream: OutputStream,
+      override private[sbt] val name: String
+  ) extends Terminal {
+    private[sbt] def getSizeImpl: (Int, Int)
+    private[this] val sizeRefreshPeriod = 1.second
+    private[this] val size =
+      new AtomicReference[((Int, Int), Deadline)](((1, 1), Deadline.now - 1.day))
+    private[this] def setSize() = size.set((Try(getSizeImpl).getOrElse((1, 1)), Deadline.now))
+    private[this] def getSize = size.get match {
+      case (s, d) if (d + sizeRefreshPeriod).isOverdue =>
+        setSize()
+        size.get._1
+      case (s, _) => s
+    }
+    override def getWidth: Int = getSize._1
+    override def getHeight: Int = getSize._2
+    private[this] val rawMode = new AtomicBoolean(false)
+    private[this] val writeLock = new AnyRef
+    def throwIfClosed[R](f: => R): R = if (isStopped.get) throw new ClosedChannelException else f
+    override def getLastLine: Option[String] = progressState.currentLine
+    override def getLines: Seq[String] = progressState.getLines
+
+    private val combinedOutputStream = new OutputStream {
+      override def write(b: Int): Unit = {
+        Option(bootOutputStreamHolder.get).foreach(_.write(b))
+        out.write(b)
+      }
+      override def write(b: Array[Byte]): Unit = {
+        write(b, 0, b.length)
+      }
+      override def write(b: Array[Byte], offset: Int, len: Int): Unit = {
+        Option(bootOutputStreamHolder.get).foreach(_.write(b, offset, len))
+        out.write(b, offset, len)
+      }
+      override def flush(): Unit = {
+        Option(bootOutputStreamHolder.get).foreach(_.flush())
+        out.flush()
+      }
+    }
+
+    override val outputStream = new OutputStream {
+      override def write(b: Int): Unit = throwIfClosed {
+        write(Array((b & 0xFF).toByte))
+      }
+      override def write(b: Array[Byte]): Unit = throwIfClosed {
+        writeLock.synchronized(doWrite(b))
+      }
+      override def write(b: Array[Byte], offset: Int, length: Int): Unit = throwIfClosed {
+        write(Arrays.copyOfRange(b, offset, offset + length))
+      }
+      override def flush(): Unit = combinedOutputStream.flush()
+    }
+    private def doWrite(rawBytes: Array[Byte]): Unit = withPrintStream { ps =>
+      val (toWrite, len) =
+        if (rawBytes.contains(27.toByte)) {
+          if (!isAnsiSupported || !isColorEnabled)
+            EscHelpers.strip(rawBytes, stripAnsi = !isAnsiSupported, stripColor = !isColorEnabled)
+          else (rawBytes, rawBytes.length)
+        } else (rawBytes, rawBytes.length)
+      val bytes = if (len < toWrite.length) toWrite.take(len) else toWrite
+      progressState.write(TerminalImpl.this, bytes, ps, hasProgress.get && !rawMode.get)
+    }
+    override private[sbt] val printStream: PrintStream = new LinePrintStream(outputStream)
+    override def inputStream: InputStream = in
+
+    private[sbt] def write(bytes: Int*): Unit = in.write(bytes: _*)
+    private[this] val isStopped = new AtomicBoolean(false)
+
+    override def getLineHeightAndWidth(line: String): (Int, Int) = getWidth match {
+      case width if width > 0 =>
+        val position = EscHelpers.cursorPosition(line)
+        val count = (position + width - 1) / width
+        (count, position - (math.max((count - 1), 0) * width))
+      case _ => (0, 0)
+    }
+
+    private[sbt] def withRawOutput[R](f: => R): R = {
+      rawMode.set(true)
+      try f
+      finally rawMode.set(false)
+    }
+    private[this] val rawPrintStream: PrintStream = new LinePrintStream(combinedOutputStream)
+    override def withPrintStream[T](f: PrintStream => T): T =
+      writeLock.synchronized(f(rawPrintStream))
+
+    override def close(): Unit = if (isStopped.compareAndSet(false, true)) {
+      in.close()
+    }
+  }
+  private lazy val nullInputStream: InputStream = () => {
+    try this.synchronized(this.wait)
+    catch { case _: InterruptedException => }
+    -1
+  }
+  private[sbt] class DefaultTerminal extends Terminal {
+    override def close(): Unit = {}
+    override private[sbt] def progressState: ProgressState = new ProgressState(1)
+    override private[sbt] def enterRawMode(): Unit = {}
+    override private[sbt] def exitRawMode(): Unit = {}
+    override def getBooleanCapability(capability: String): Boolean = false
+    override def getHeight: Int = 0
+    override def getLastLine: Option[String] = None
+    override def getLines: Seq[String] = Nil
+    override def getLineHeightAndWidth(line: String): (Int, Int) = (0, 0)
+    override def getNumericCapability(capability: String): Integer = null
+    override def getStringCapability(capability: String): String = null
+    override def getWidth: Int = 0
+    override def inputStream: InputStream = nullInputStream
+    override def isAnsiSupported: Boolean = Terminal.isAnsiSupported
+    override def isColorEnabled: Boolean = isColorEnabledProp.getOrElse(Terminal.isColorEnabled)
+    override def isEchoEnabled: Boolean = false
+    override def isSuccessEnabled: Boolean = true
+    override def isSupershellEnabled: Boolean = false
+    override def setEchoEnabled(toggle: Boolean): Unit = {}
+    override def outputStream: OutputStream = _ => {}
+    override def errorStream: OutputStream = _ => {}
+    override private[sbt] def getAttributes: Map[String, String] = Map.empty
+    override private[sbt] def setAttributes(attributes: Map[String, String]): Unit = {}
+    override private[sbt] def setSize(width: Int, height: Int): Unit = {}
+    override private[sbt] def name: String = "NullTerminal"
+    override private[sbt] val printStream: PrintStream =
+      new PrintStream(outputStream, false)
+    override private[sbt] def withPrintStream[T](f: PrintStream => T): T = f(printStream)
+    override private[sbt] def write(bytes: Int*): Unit = {}
+    override private[sbt] def withRawOutput[R](f: => R): R = f
+  }
+  private[sbt] object NullTerminal extends DefaultTerminal
+  private[sbt] object SimpleTerminal extends DefaultTerminal {
+    override lazy val inputStream: InputStream = originalIn
+    override lazy val outputStream: OutputStream = originalOut
+    override lazy val errorStream: OutputStream = originalErr
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/WindowsInputStream.scala b/internal/util-logging/src/main/scala/sbt/internal/util/WindowsInputStream.scala
new file mode 100644
index 000000000..486759cbb
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/WindowsInputStream.scala
@@ -0,0 +1,154 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.InputStream
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.atomic.AtomicBoolean
+import org.fusesource.jansi.internal.Kernel32
+import org.jline.utils.InfoCmp.Capability
+import scala.annotation.tailrec
+import Terminal.SimpleInputStream
+
+private object WindowsSupport {
+  def getConsoleMode = {
+    val console = Kernel32.GetStdHandle(Kernel32.STD_INPUT_HANDLE);
+    val mode = new Array[Int](1);
+    if (Kernel32.GetConsoleMode(console, mode) == 0) -1 else mode.head
+  }
+  def setConsoleMode(mode: Int): Unit = {
+    val console = Kernel32.GetStdHandle(Kernel32.STD_INPUT_HANDLE);
+    Kernel32.SetConsoleMode(console, mode)
+    ()
+  }
+  def readConsoleInput(count: Int) = {
+    val console = Kernel32.GetStdHandle(Kernel32.STD_INPUT_HANDLE);
+    Kernel32.readConsoleInputHelper(console, 1, false)
+  }
+}
+/*
+ * We need a special input stream for windows because special key events
+ * like arrow keys are not reported by System.in. What makes this extra
+ * tricky is that in canonical mode, ReadConsoleInput does not echo
+ * characters, even when echo is set. The ReadConsole api does, but that
+ * api isn't exposed by jansi so we can't use it without rolling our own
+ * jni library or using the jna. That is more trouble than it's worth. To
+ * work around the canonical mode issue, we can switch between reading using
+ * ReadConsoleInput and just reading directly from the original System.in,
+ * which does echo characters in canonical mode, when we enter and exit
+ * raw mode.
+ */
+private[util] class WindowsInputStream(term: org.jline.terminal.Terminal, in: InputStream)
+    extends SimpleInputStream {
+  private val SHIFT_FLAG = 0x01;
+  private val ALT_FLAG = 0x02;
+  private val CTRL_FLAG = 0x04;
+
+  private val RIGHT_ALT_PRESSED = 0x0001;
+  private val LEFT_ALT_PRESSED = 0x0002;
+  private val RIGHT_CTRL_PRESSED = 0x0004;
+  private val LEFT_CTRL_PRESSED = 0x0008;
+  private val SHIFT_PRESSED = 0x0010;
+  private def getCapability(cap: Capability): String = term.getStringCapability(cap) match {
+    case null => null
+    case c    => c.replaceAllLiterally("\\E", "\u001B")
+  }
+  /*
+   * This function is a hybrid of jline 2 WindowsTerminal.readConsoleInput
+   * and jline3 AbstractTerminal.getEscapeSequence.
+   */
+  private def readConsoleInput(): Array[Byte] = {
+    WindowsSupport.readConsoleInput(1) match {
+      case null => Array.empty
+      case events =>
+        val sb = new StringBuilder();
+        events.foreach { event =>
+          val keyEvent = event.keyEvent
+          val controlKeyState = keyEvent.controlKeyState
+          val isCtrl = (controlKeyState & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)) > 0;
+          val isAlt = (controlKeyState & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED)) > 0;
+          val isShift = (controlKeyState & SHIFT_PRESSED) > 0;
+          if (keyEvent.keyDown) {
+            if (keyEvent.uchar > 0) {
+              if (((keyEvent.uchar >= '@' && keyEvent.uchar <= '_') || (keyEvent.uchar >= 'a' && keyEvent.uchar <= 'z'))
+                  && isAlt && !isCtrl) {
+                sb.append('\u001B') // ESC
+              }
+              if (isShift && keyEvent.keyCode == 9) {
+                getCapability(Capability.key_btab) match {
+                  case null => sb.append(keyEvent.uchar)
+                  case cap  => sb.append(cap)
+                }
+              } else {
+                sb.append(keyEvent.uchar)
+              }
+            } else {
+              // virtual keycodes: http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
+              // just add support for basic editing keys (no control state, no numpad keys)
+              val escapeSequence = keyEvent.keyCode match {
+                case 0x21 /* VK_PRIOR PageUp*/  => getCapability(Capability.key_ppage);
+                case 0x22 /* VK_NEXT PageDown*/ => getCapability(Capability.key_npage);
+                case 0x24 /* VK_HOME */         => getCapability(Capability.key_home)
+                case 0x25 /* VK_LEFT */         => getCapability(Capability.key_left)
+                case 0x26 /* VK_UP */           => getCapability(Capability.key_up)
+                case 0x27 /* VK_RIGHT */        => getCapability(Capability.key_right)
+                case 0x28 /* VK_DOWN */         => getCapability(Capability.key_down)
+                case 0x70 /* VK_F1 */           => getCapability(Capability.key_f1)
+                case 0x71 /* VK_F2 */           => getCapability(Capability.key_f2)
+                case 0x72 /* VK_F3 */           => getCapability(Capability.key_f3)
+                case 0x73 /* VK_F4 */           => getCapability(Capability.key_f4)
+                case 0x74 /* VK_F5 */           => getCapability(Capability.key_f5)
+                case 0x75 /* VK_F6 */           => getCapability(Capability.key_f6)
+                case 0x76 /* VK_F7 */           => getCapability(Capability.key_f7)
+                case 0x77 /* VK_F8 */           => getCapability(Capability.key_f8)
+                case 0x78 /* VK_F9 */           => getCapability(Capability.key_f9)
+                case 0x79 /* VK_F10 */          => getCapability(Capability.key_f10)
+                case 0x7A /* VK_F11 */          => getCapability(Capability.key_f11)
+                case 0x7B /* VK_F12 */          => getCapability(Capability.key_f12)
+                // VK_END, VK_INSERT and VK_DELETE are not in the ansi key bindings so we
+                // have to manually apply the the sequences here and in JLine3.wrap
+                case 0x23 /* VK_END */ =>
+                  Option(getCapability(Capability.key_end)).getOrElse("\u001B[4~")
+                case 0x2D /* VK_INSERT */ =>
+                  Option(getCapability(Capability.key_ic)).getOrElse("\u001B[2~")
+                case 0x2E /* VK_DELETE */ =>
+                  Option(getCapability(Capability.key_dc)).getOrElse("\u001B[3~")
+                case _ => null
+              }
+              escapeSequence match {
+                case null =>
+                case es   => (0 until keyEvent.repeatCount.toInt).foreach(_ => sb.append(es))
+              }
+            }
+          } else {
+            // key up event
+            // support ALT+NumPad input method
+            if (keyEvent.keyCode == 0x12 /*VK_MENU ALT key*/ && keyEvent.uchar > 0) {
+              sb.append(keyEvent.uchar);
+            }
+          }
+        }
+        sb.toString().getBytes()
+    }
+  }
+  private[this] val raw: InputStream = new SimpleInputStream {
+    val buffer = new LinkedBlockingQueue[Integer]
+    @tailrec
+    override def read(): Int = {
+      buffer.poll match {
+        case null =>
+          readConsoleInput().foreach(b => buffer.put(b & 0xFF))
+          if (!Thread.interrupted) read() else throw new InterruptedException
+        case b => b
+      }
+    }
+  }
+  private[this] val isRaw = new AtomicBoolean(true)
+  private[sbt] def setRawMode(toggle: Boolean): Unit = isRaw.set(toggle)
+  override def read(): Int = if (isRaw.get) raw.read() else in.read()
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/JValueFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/JValueFormats.scala
new file mode 100644
index 000000000..1b67fa425
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/JValueFormats.scala
@@ -0,0 +1,59 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package util.codec
+
+import sjsonnew.{ JsonWriter => JW, JsonReader => JR, JsonFormat => JF, _ }
+import sjsonnew.shaded.scalajson.ast.unsafe._
+
+trait JValueFormats { self: sjsonnew.BasicJsonProtocol =>
+  implicit val JNullFormat: JF[JNull.type] = new JF[JNull.type] {
+    def write[J](x: JNull.type, b: Builder[J]) = b.writeNull()
+    def read[J](j: Option[J], u: Unbuilder[J]) = JNull
+  }
+
+  implicit val JBooleanFormat: JF[JBoolean] = projectFormat(_.get, (x: Boolean) => JBoolean(x))
+  implicit val JStringFormat: JF[JString] = projectFormat(_.value, (x: String) => JString(x))
+
+  implicit val JNumberFormat: JF[JNumber] =
+    projectFormat(x => BigDecimal(x.value), (x: BigDecimal) => JNumber(x.toString))
+
+  implicit val JArrayFormat: JF[JArray] = projectFormat[JArray, Array[JValue]](_.value, JArray(_))
+
+  implicit lazy val JObjectJsonWriter: JW[JObject] = new JW[JObject] {
+    def write[J](x: JObject, b: Builder[J]) = {
+      b.beginObject()
+      x.value foreach (jsonField => JValueFormat.addField(jsonField.field, jsonField.value, b))
+      b.endObject()
+    }
+  }
+
+  implicit lazy val JValueJsonWriter: JW[JValue] = new JW[JValue] {
+    def write[J](x: JValue, b: Builder[J]) = x match {
+      case x: JNull.type => JNullFormat.write(x, b)
+      case x: JBoolean   => JBooleanFormat.write(x, b)
+      case x: JString    => JStringFormat.write(x, b)
+      case x: JNumber    => JNumberFormat.write(x, b)
+      case x: JArray     => JArrayFormat.write(x, b)
+      case x: JObject    => JObjectJsonWriter.write(x, b)
+    }
+  }
+
+  // This passes through JValue, or returns JNull instead of blowing up with unimplemented.
+  implicit lazy val JValueJsonReader: JR[JValue] = new JR[JValue] {
+    def read[J](j: Option[J], u: Unbuilder[J]) = j match {
+      case Some(x: JValue) => x
+      case Some(x)         => sys.error(s"Uknown AST $x")
+      case _               => JNull
+    }
+  }
+
+  implicit lazy val JValueFormat: JF[JValue] =
+    jsonFormat[JValue](JValueJsonReader, JValueJsonWriter)
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/PositionFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/PositionFormats.scala
new file mode 100644
index 000000000..9b77889df
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/PositionFormats.scala
@@ -0,0 +1,73 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util.codec
+import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
+import xsbti.Position
+import java.util.Optional
+
+trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
+  implicit lazy val PositionFormat: JsonFormat[Position] = new JsonFormat[Position] {
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Position = {
+      jsOpt match {
+        case Some(js) =>
+          unbuilder.beginObject(js)
+          val line0 = unbuilder.readField[Optional[java.lang.Integer]]("line")
+          val lineContent0 = unbuilder.readField[String]("lineContent")
+          val offset0 = unbuilder.readField[Optional[java.lang.Integer]]("offset")
+          val pointer0 = unbuilder.readField[Optional[java.lang.Integer]]("pointer")
+          val pointerSpace0 = unbuilder.readField[Optional[String]]("pointerSpace")
+          val sourcePath0 = unbuilder.readField[Optional[String]]("sourcePath")
+          val sourceFile0 = unbuilder.readField[Optional[java.io.File]]("sourceFile")
+          val startOffset0 = unbuilder.readField[Optional[java.lang.Integer]]("startOffset")
+          val endOffset0 = unbuilder.readField[Optional[java.lang.Integer]]("endOffset")
+          val startLine0 = unbuilder.readField[Optional[java.lang.Integer]]("startLine")
+          val startColumn0 = unbuilder.readField[Optional[java.lang.Integer]]("startColumn")
+          val endLine0 = unbuilder.readField[Optional[java.lang.Integer]]("endLine")
+          val endColumn0 = unbuilder.readField[Optional[java.lang.Integer]]("endColumn")
+
+          unbuilder.endObject()
+          new Position() {
+            override val line = line0
+            override val lineContent = lineContent0
+            override val offset = offset0
+            override val pointer = pointer0
+            override val pointerSpace = pointerSpace0
+            override val sourcePath = sourcePath0
+            override val sourceFile = sourceFile0
+            override val startOffset = startOffset0
+            override val endOffset = endOffset0
+            override val startLine = startLine0
+            override val startColumn = startColumn0
+            override val endLine = endLine0
+            override val endColumn = endColumn0
+
+          }
+        case None =>
+          deserializationError("Expected JsObject but found None")
+      }
+    }
+    override def write[J](obj: Position, builder: Builder[J]): Unit = {
+      builder.beginObject()
+      builder.addField("line", obj.line)
+      builder.addField("lineContent", obj.lineContent)
+      builder.addField("offset", obj.offset)
+      builder.addField("pointer", obj.pointer)
+      builder.addField("pointerSpace", obj.pointerSpace)
+      builder.addField("sourcePath", obj.sourcePath)
+      builder.addField("sourceFile", obj.sourceFile)
+      builder.addField("startOffset", obj.startOffset)
+      builder.addField("endOffset", obj.endOffset)
+      builder.addField("startLine", obj.startLine)
+      builder.addField("startColumn", obj.startColumn)
+      builder.addField("endLine", obj.endLine)
+      builder.addField("endColumn", obj.endColumn)
+
+      builder.endObject()
+    }
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/ProblemFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ProblemFormats.scala
new file mode 100644
index 000000000..2ae0d7512
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ProblemFormats.scala
@@ -0,0 +1,48 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util.codec
+
+import xsbti.{ Problem, Severity, Position }
+import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
+import java.util.Optional
+
+trait ProblemFormats { self: SeverityFormats with PositionFormats with sjsonnew.BasicJsonProtocol =>
+  implicit lazy val ProblemFormat: JsonFormat[Problem] = new JsonFormat[Problem] {
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Problem = {
+      jsOpt match {
+        case Some(js) =>
+          unbuilder.beginObject(js)
+          val category0 = unbuilder.readField[String]("category")
+          val severity0 = unbuilder.readField[Severity]("severity")
+          val message0 = unbuilder.readField[String]("message")
+          val position0 = unbuilder.readField[Position]("position")
+          val rendered0 = unbuilder.readField[Optional[String]]("rendered")
+
+          unbuilder.endObject()
+          new Problem {
+            override val category = category0
+            override val position = position0
+            override val message = message0
+            override val severity = severity0
+            override val rendered = rendered0
+          }
+        case None =>
+          deserializationError("Expected JsObject but found None")
+      }
+    }
+    override def write[J](obj: Problem, builder: Builder[J]): Unit = {
+      builder.beginObject()
+      builder.addField("category", obj.category)
+      builder.addField("severity", obj.severity)
+      builder.addField("message", obj.message)
+      builder.addField("position", obj.position)
+      builder.addField("rendered", obj.rendered)
+      builder.endObject()
+    }
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/SeverityFormats.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SeverityFormats.scala
new file mode 100644
index 000000000..982d248d0
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SeverityFormats.scala
@@ -0,0 +1,36 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util.codec
+
+import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
+import xsbti.Severity;
+
+trait SeverityFormats { self: sjsonnew.BasicJsonProtocol =>
+  implicit lazy val SeverityFormat: JsonFormat[Severity] = new JsonFormat[Severity] {
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Severity = {
+      jsOpt match {
+        case Some(js) =>
+          unbuilder.readString(js) match {
+            case "Info"  => Severity.Info
+            case "Warn"  => Severity.Warn
+            case "Error" => Severity.Error
+          }
+        case None =>
+          deserializationError("Expected JsString but found None")
+      }
+    }
+    override def write[J](obj: Severity, builder: Builder[J]): Unit = {
+      val str = obj match {
+        case Severity.Info  => "Info"
+        case Severity.Warn  => "Warn"
+        case Severity.Error => "Error"
+      }
+      builder.writeString(str)
+    }
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/SuccessEventShowLines.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SuccessEventShowLines.scala
new file mode 100644
index 000000000..d0bb12ea3
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/SuccessEventShowLines.scala
@@ -0,0 +1,21 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal.util.codec
+
+import sbt.util.ShowLines
+import sbt.internal.util.SuccessEvent
+
+trait SuccessEventShowLines {
+  implicit val sbtSuccessEventShowLines: ShowLines[SuccessEvent] =
+    ShowLines[SuccessEvent]((e: SuccessEvent) => {
+      Vector(e.message)
+    })
+}
+
+object SuccessEventShowLines extends SuccessEventShowLines
diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/codec/ThrowableShowLines.scala b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ThrowableShowLines.scala
new file mode 100644
index 000000000..21f400ee4
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/internal/util/codec/ThrowableShowLines.scala
@@ -0,0 +1,32 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal.util.codec
+
+import sbt.util.ShowLines
+import sbt.internal.util.{ StackTrace, TraceEvent }
+
+trait ThrowableShowLines {
+  implicit val sbtThrowableShowLines: ShowLines[Throwable] =
+    ShowLines[Throwable]((t: Throwable) => {
+      // 0 means enabled with default behavior. See StackTrace.scala.
+      val traceLevel = 0
+      List(StackTrace.trimmed(t, traceLevel))
+    })
+}
+
+object ThrowableShowLines extends ThrowableShowLines
+
+trait TraceEventShowLines {
+  implicit val sbtTraceEventShowLines: ShowLines[TraceEvent] =
+    ShowLines[TraceEvent]((t: TraceEvent) => {
+      ThrowableShowLines.sbtThrowableShowLines.showLines(t.message)
+    })
+}
+
+object TraceEventShowLines extends TraceEventShowLines
diff --git a/internal/util-logging/src/main/scala/sbt/util/AbstractLogger.scala b/internal/util-logging/src/main/scala/sbt/util/AbstractLogger.scala
new file mode 100644
index 000000000..1337aaf97
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/AbstractLogger.scala
@@ -0,0 +1,36 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+abstract class AbstractLogger extends Logger {
+  def getLevel: Level.Value
+  def setLevel(newLevel: Level.Value): Unit
+  def setTrace(flag: Int): Unit
+  def getTrace: Int
+  final def traceEnabled: Boolean = getTrace >= 0
+  def successEnabled: Boolean
+  def setSuccessEnabled(flag: Boolean): Unit
+
+  def atLevel(level: Level.Value): Boolean = level.id >= getLevel.id
+  def control(event: ControlEvent.Value, message: => String): Unit
+
+  def logAll(events: Seq[LogEvent]): Unit
+
+  /** Defined in terms of other methods in Logger and should not be called from them. */
+  final def log(event: LogEvent): Unit = {
+    event match {
+      case s: Success       => success(s.msg)
+      case l: Log           => log(l.level, l.msg)
+      case t: Trace         => trace(t.exception)
+      case setL: SetLevel   => setLevel(setL.newLevel)
+      case setT: SetTrace   => setTrace(setT.level)
+      case setS: SetSuccess => setSuccessEnabled(setS.enabled)
+      case c: ControlEvent  => control(c.event, c.msg)
+    }
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala b/internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala
new file mode 100644
index 000000000..40fecbae1
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala
@@ -0,0 +1,178 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import xsbti.{ Position, Problem, Severity, T2 }
+import java.io.File
+import java.util.Optional
+import java.util.function.Supplier
+
+object InterfaceUtil {
+  def toSupplier[A](a: => A): Supplier[A] = new Supplier[A] {
+    override def get: A = a
+  }
+
+  import java.util.function.{ Function => JavaFunction }
+  def toJavaFunction[A1, R](f: A1 => R): JavaFunction[A1, R] = new JavaFunction[A1, R] {
+    override def apply(t: A1): R = f(t)
+  }
+
+  def t2[A1, A2](x: (A1, A2)): T2[A1, A2] = new ConcreteT2(x._1, x._2)
+
+  def toOption[A](m: Optional[A]): Option[A] =
+    if (m.isPresent) Some(m.get) else None
+
+  def toOptional[A](o: Option[A]): Optional[A] =
+    o match {
+      case Some(v) => Optional.of(v)
+      case None    => Optional.empty()
+    }
+
+  def jo2o[A](o: Optional[A]): Option[A] =
+    if (o.isPresent) Some(o.get)
+    else None
+
+  def o2jo[A](o: Option[A]): Optional[A] =
+    o match {
+      case Some(v) => Optional.ofNullable(v)
+      case None    => Optional.empty[A]()
+    }
+
+  @deprecated("Use the overload of this method with more arguments", "1.2.2")
+  def position(
+      line0: Option[Integer],
+      content: String,
+      offset0: Option[Integer],
+      pointer0: Option[Integer],
+      pointerSpace0: Option[String],
+      sourcePath0: Option[String],
+      sourceFile0: Option[File]
+  ): Position =
+    position(
+      line0,
+      content,
+      offset0,
+      pointer0,
+      pointerSpace0,
+      sourcePath0,
+      sourceFile0,
+      None,
+      None,
+      None,
+      None,
+      None,
+      None
+    )
+
+  def position(
+      line0: Option[Integer],
+      content: String,
+      offset0: Option[Integer],
+      pointer0: Option[Integer],
+      pointerSpace0: Option[String],
+      sourcePath0: Option[String],
+      sourceFile0: Option[File],
+      startOffset0: Option[Integer],
+      endOffset0: Option[Integer],
+      startLine0: Option[Integer],
+      startColumn0: Option[Integer],
+      endLine0: Option[Integer],
+      endColumn0: Option[Integer]
+  ): Position =
+    new ConcretePosition(
+      line0,
+      content,
+      offset0,
+      pointer0,
+      pointerSpace0,
+      sourcePath0,
+      sourceFile0,
+      startOffset0,
+      endOffset0,
+      startLine0,
+      startColumn0,
+      endLine0,
+      endColumn0
+    )
+
+  @deprecated("Use the overload of this method with more arguments", "1.2.2")
+  def problem(cat: String, pos: Position, msg: String, sev: Severity): Problem =
+    problem(cat, pos, msg, sev, None)
+
+  def problem(
+      cat: String,
+      pos: Position,
+      msg: String,
+      sev: Severity,
+      rendered: Option[String]
+  ): Problem =
+    new ConcreteProblem(cat, pos, msg, sev, rendered)
+
+  private final class ConcreteT2[A1, A2](a1: A1, a2: A2) extends T2[A1, A2] {
+    val get1: A1 = a1
+    val get2: A2 = a2
+    override def toString: String = s"ConcreteT2($a1, $a2)"
+    override def equals(o: Any): Boolean = o match {
+      case o: ConcreteT2[A1, A2] =>
+        this.get1 == o.get1 &&
+          this.get2 == o.get2
+      case _ => false
+    }
+    override def hashCode: Int = {
+      var hash = 1
+      hash = hash * 31 + this.get1.##
+      hash = hash * 31 + this.get2.##
+      hash
+    }
+  }
+
+  private final class ConcretePosition(
+      line0: Option[Integer],
+      content: String,
+      offset0: Option[Integer],
+      pointer0: Option[Integer],
+      pointerSpace0: Option[String],
+      sourcePath0: Option[String],
+      sourceFile0: Option[File],
+      startOffset0: Option[Integer],
+      endOffset0: Option[Integer],
+      startLine0: Option[Integer],
+      startColumn0: Option[Integer],
+      endLine0: Option[Integer],
+      endColumn0: Option[Integer]
+  ) extends Position {
+    val line = o2jo(line0)
+    val lineContent = content
+    val offset = o2jo(offset0)
+    val pointer = o2jo(pointer0)
+    val pointerSpace = o2jo(pointerSpace0)
+    val sourcePath = o2jo(sourcePath0)
+    val sourceFile = o2jo(sourceFile0)
+    override val startOffset = o2jo(startOffset0)
+    override val endOffset = o2jo(endOffset0)
+    override val startLine = o2jo(startLine0)
+    override val startColumn = o2jo(startColumn0)
+    override val endLine = o2jo(endLine0)
+    override val endColumn = o2jo(endColumn0)
+  }
+
+  private final class ConcreteProblem(
+      cat: String,
+      pos: Position,
+      msg: String,
+      sev: Severity,
+      rendered0: Option[String]
+  ) extends Problem {
+    val category = cat
+    val position = pos
+    val message = msg
+    val severity = sev
+    override val rendered = o2jo(rendered0)
+    override def toString = s"[$severity] $pos: $message"
+  }
+}
diff --git a/internal/util-logging/src/main/scala/sbt/util/Level.scala b/internal/util-logging/src/main/scala/sbt/util/Level.scala
new file mode 100644
index 000000000..b9d30dca7
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/Level.scala
@@ -0,0 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+/**
+ * An enumeration defining the levels available for logging.  A level includes all of the levels
+ * with id larger than its own id.  For example, Warn (id=3) includes Error (id=4).
+ */
+object Level extends Enumeration {
+  val Debug = Value(1, "debug")
+  val Info = Value(2, "info")
+  val Warn = Value(3, "warn")
+  val Error = Value(4, "error")
+
+  /**
+   * Defines the label to use for success messages.
+   * Because the label for levels is defined in this module, the success label is also defined here.
+   */
+  val SuccessLabel = "success"
+
+  def union(a: Value, b: Value) = if (a.id < b.id) a else b
+  def unionAll(vs: Seq[Value]) = vs reduceLeft union
+
+  /** Returns the level with the given name wrapped in Some, or None if no level exists for that name. */
+  def apply(s: String) = values.find(s == _.toString)
+
+  /** Same as apply, defined for use in pattern matching. */
+  private[sbt] def unapply(s: String) = apply(s)
+}
diff --git a/internal/util-logging/src/main/scala/sbt/util/LogEvent.scala b/internal/util-logging/src/main/scala/sbt/util/LogEvent.scala
new file mode 100644
index 000000000..28798feef
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/LogEvent.scala
@@ -0,0 +1,21 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+sealed trait LogEvent
+final class Success(val msg: String) extends LogEvent
+final class Log(val level: Level.Value, val msg: String) extends LogEvent
+final class Trace(val exception: Throwable) extends LogEvent
+final class SetLevel(val newLevel: Level.Value) extends LogEvent
+final class SetTrace(val level: Int) extends LogEvent
+final class SetSuccess(val enabled: Boolean) extends LogEvent
+final class ControlEvent(val event: ControlEvent.Value, val msg: String) extends LogEvent
+
+object ControlEvent extends Enumeration {
+  val Start, Header, Finish = Value
+}
diff --git a/internal/util-logging/src/main/scala/sbt/util/LogExchange.scala b/internal/util-logging/src/main/scala/sbt/util/LogExchange.scala
new file mode 100644
index 000000000..99ee76192
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/LogExchange.scala
@@ -0,0 +1,156 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.util.concurrent.ConcurrentHashMap
+import org.apache.logging.log4j.{ LogManager => XLogManager, Level => XLevel }
+import org.apache.logging.log4j.core.{ Appender => XAppender, LoggerContext => XLoggerContext }
+import org.apache.logging.log4j.core.config.{ AppenderRef, LoggerConfig }
+import org.apache.logging.log4j.core.layout.PatternLayout
+import sbt.internal.util._
+import scala.collection.concurrent
+import sjsonnew.JsonFormat
+import org.apache.logging.log4j.core.appender.AsyncAppender
+
+// http://logging.apache.org/log4j/2.x/manual/customconfig.html
+// https://logging.apache.org/log4j/2.x/log4j-core/apidocs/index.html
+
+sealed abstract class LogExchange {
+  private[sbt] lazy val context: XLoggerContext = init()
+  private[sbt] val stringCodecs: concurrent.Map[String, ShowLines[_]] = concurrent.TrieMap()
+  private[sbt] val builtInStringCodecs: Unit = initStringCodecs()
+  private[util] val configs = new ConcurrentHashMap[String, LoggerConfig]
+  private[util] def addConfig(name: String, config: LoggerConfig): Unit =
+    Util.ignoreResult(configs.putIfAbsent(name, config))
+  private[util] def removeConfig(name: String): Option[LoggerConfig] = Option(configs.remove(name))
+
+  @deprecated("Use LoggerContext to create loggers", "1.4.0")
+  def logger(name: String): ManagedLogger = logger(name, None, None)
+  @deprecated("Use LoggerContext to create loggers", "1.4.0")
+  def logger(name: String, channelName: Option[String], execId: Option[String]): ManagedLogger =
+    LoggerContext.globalContext.logger(name, channelName, execId)
+  @deprecated("Use LoggerContext to unbind appenders", "1.4.0")
+  def unbindLoggerAppenders(loggerName: String): Unit = {
+    LoggerContext.globalContext.clearAppenders(loggerName)
+  }
+  @deprecated("Use LoggerContext to bind appenders", "1.4.0")
+  def bindLoggerAppenders(
+      loggerName: String,
+      appenders: List[(XAppender, Level.Value)]
+  ): Unit = {
+    appenders.foreach {
+      case (a, l) =>
+        LoggerContext.globalContext
+          .addAppender(loggerName, new ConsoleAppenderFromLog4J(loggerName, a) -> l)
+    }
+  }
+  @deprecated("Use LoggerContext to bind appenders", "1.4.0")
+  def bindLoggerAppenders(
+      loggerName: String,
+      appenders: Seq[(Appender, Level.Value)]
+  ): Unit = bindLoggerAppenders(loggerName, appenders.map { case (a, l) => a.toLog4J -> l }.toList)
+  @deprecated("unused", "1.4.0")
+  def loggerConfig(loggerName: String): LoggerConfig = configs.get(loggerName)
+
+  @deprecated("unused", "1.4.0")
+  lazy val asyncStdout = buildAsyncStdout
+  @deprecated("unused", "1.4.0")
+  private[sbt] def buildAsyncStdout: AsyncAppender = {
+    val ctx = XLogManager.getContext(false) match { case x: XLoggerContext => x }
+    val config = ctx.getConfiguration
+    val appender = ConsoleAppender("Stdout").toLog4J
+    // CustomConsoleAppender.createAppender("Stdout", layout, null, null)
+    appender.start
+    config.addAppender(appender)
+    val asyncAppender: AsyncAppender = AsyncAppender
+      .newBuilder()
+      .setName("AsyncStdout")
+      .setAppenderRefs(Array(AppenderRef.createAppenderRef("Stdout", XLevel.DEBUG, null)))
+      .setBlocking(false)
+      .setConfiguration(config)
+      .build
+    asyncAppender.start
+    config.addAppender(asyncAppender)
+    asyncAppender
+  }
+
+  // Construct these StringTypeTags manually, because they're used at the very startup of sbt
+  // and we'll try not to initialize the universe by using the StringTypeTag.apply that requires a TypeTag
+  // A better long-term solution could be to make StringTypeTag.apply a macro.
+  lazy val stringTypeTagThrowable = StringTypeTag[Throwable]("scala.Throwable")
+  lazy val stringTypeTagTraceEvent = StringTypeTag[TraceEvent]("sbt.internal.util.TraceEvent")
+  lazy val stringTypeTagSuccessEvent = StringTypeTag[SuccessEvent]("sbt.internal.util.SuccessEvent")
+
+  private[sbt] def initStringCodecs(): Unit = {
+    import sbt.internal.util.codec.ThrowableShowLines._
+    import sbt.internal.util.codec.TraceEventShowLines._
+    import sbt.internal.util.codec.SuccessEventShowLines._
+
+    registerStringCodecByStringTypeTag(stringTypeTagThrowable)
+    registerStringCodecByStringTypeTag(stringTypeTagTraceEvent)
+    registerStringCodecByStringTypeTag(stringTypeTagSuccessEvent)
+  }
+
+  // This is a dummy layout to avoid casting error during PatternLayout.createDefaultLayout()
+  // that was originally used for ConsoleAppender.
+  // The stacktrace shows it's having issue initializing default DefaultConfiguration.
+  // Since we currently do not use Layout inside ConsoleAppender, the actual pattern is not relevant.
+  private[sbt] lazy val dummyLayout: PatternLayout = {
+    val _ = context
+    val ctx = XLogManager.getContext(false) match { case x: XLoggerContext => x }
+    val config = ctx.getConfiguration
+    val lo = PatternLayout.newBuilder
+      .withConfiguration(config)
+      .withPattern(PatternLayout.SIMPLE_CONVERSION_PATTERN)
+      .build
+    lo
+  }
+
+  @deprecated("It is now necessary to provide a json format instance", "1.4.0")
+  def jsonCodec[A](tag: String): Option[JsonFormat[A]] = None
+  @deprecated("Always returns false", "1.4.0")
+  def hasJsonCodec(tag: String): Boolean = false
+  @deprecated("This is a no-op", "1.4.0")
+  def getOrElseUpdateJsonCodec[A](tag: String, v: JsonFormat[A]): JsonFormat[A] = v
+  @deprecated("The log manager no longer caches jsonCodecs", "1.4.0")
+  def jsonCodecs(): concurrent.Map[String, JsonFormat[_]] = concurrent.TrieMap.empty
+
+  def stringCodec[A](tag: String): Option[ShowLines[A]] =
+    stringCodecs.get(tag) map { _.asInstanceOf[ShowLines[A]] }
+  def hasStringCodec(tag: String): Boolean =
+    stringCodecs.contains(tag)
+  def getOrElseUpdateStringCodec[A](tag: String, v: ShowLines[A]): ShowLines[A] =
+    stringCodecs.getOrElseUpdate(tag, v).asInstanceOf[ShowLines[A]]
+
+  @deprecated("Prefer macro based registerStringCodec", "1.4.0")
+  def registerStringCodec[A](
+      st: ShowLines[A],
+      tt: scala.reflect.runtime.universe.TypeTag[A]
+  ): Unit = {
+    registerStringCodecByStringTypeTag(StringTypeTag.apply[A](tt))(st)
+  }
+  private[sbt] def registerStringCodec[A: ShowLines: StringTypeTag]: Unit = {
+    registerStringCodecByStringTypeTag(implicitly[StringTypeTag[A]])
+  }
+
+  private[sbt] def registerStringCodecByStringTypeTag[A: ShowLines](tag: StringTypeTag[A]): Unit = {
+    val ev = implicitly[ShowLines[A]]
+    val _ = getOrElseUpdateStringCodec(tag.key, ev)
+  }
+
+  private[sbt] def init(): XLoggerContext = {
+    import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilderFactory
+    import org.apache.logging.log4j.core.config.Configurator
+    val builder = ConfigurationBuilderFactory.newConfigurationBuilder
+    builder.setConfigurationName("sbt.util.logging")
+    val ctx = Configurator.initialize(builder.build())
+    ctx match { case x: XLoggerContext => x }
+  }
+  private[sbt] def init(name: String): XLoggerContext = new XLoggerContext(name)
+}
+object LogExchange extends LogExchange
diff --git a/internal/util-logging/src/main/scala/sbt/util/Logger.scala b/internal/util-logging/src/main/scala/sbt/util/Logger.scala
new file mode 100644
index 000000000..135c92da4
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/Logger.scala
@@ -0,0 +1,127 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import xsbti.{ Logger => xLogger }
+import xsbti.{ Position, Problem, Severity }
+
+import sys.process.ProcessLogger
+import sbt.internal.util.{ BufferedLogger, FullLogger }
+import java.io.File
+import java.util.Optional
+import java.util.function.Supplier
+
+/**
+ * This is intended to be the simplest logging interface for use by code that wants to log.
+ * It does not include configuring the logger.
+ */
+abstract class Logger extends xLogger {
+  final def verbose(message: => String): Unit = debug(message)
+  final def debug(message: => String): Unit = log(Level.Debug, message)
+  final def info(message: => String): Unit = log(Level.Info, message)
+  final def warn(message: => String): Unit = log(Level.Warn, message)
+  final def error(message: => String): Unit = log(Level.Error, message)
+
+  // Added by sys.process.ProcessLogger
+  final def err(message: => String): Unit = log(Level.Error, message)
+  // sys.process.ProcessLogger
+  final def out(message: => String): Unit = log(Level.Info, message)
+
+  @deprecated("No longer used.", "1.0.0")
+  def ansiCodesSupported: Boolean = false
+
+  def trace(t: => Throwable): Unit
+  def success(message: => String): Unit
+  def log(level: Level.Value, message: => String): Unit
+
+  def debug(msg: Supplier[String]): Unit = log(Level.Debug, msg)
+  def warn(msg: Supplier[String]): Unit = log(Level.Warn, msg)
+  def info(msg: Supplier[String]): Unit = log(Level.Info, msg)
+  def error(msg: Supplier[String]): Unit = log(Level.Error, msg)
+  def trace(msg: Supplier[Throwable]): Unit = trace(msg.get())
+  def log(level: Level.Value, msg: Supplier[String]): Unit = log(level, msg.get)
+}
+
+object Logger {
+  def transferLevels(oldLog: AbstractLogger, newLog: AbstractLogger): Unit = {
+    newLog.setLevel(oldLog.getLevel)
+    newLog.setTrace(oldLog.getTrace)
+  }
+
+  val Null: AbstractLogger = new AbstractLogger {
+    def getLevel: Level.Value = Level.Error
+    def setLevel(newLevel: Level.Value): Unit = ()
+    def getTrace: Int = 0
+    def setTrace(flag: Int): Unit = ()
+    def successEnabled: Boolean = false
+    def setSuccessEnabled(flag: Boolean): Unit = ()
+    def control(event: ControlEvent.Value, message: => String): Unit = ()
+    def logAll(events: Seq[LogEvent]): Unit = ()
+    def trace(t: => Throwable): Unit = ()
+    def success(message: => String): Unit = ()
+    def log(level: Level.Value, message: => String): Unit = ()
+  }
+
+  implicit def absLog2PLog(log: AbstractLogger): ProcessLogger =
+    new BufferedLogger(log) with ProcessLogger
+
+  implicit def log2PLog(log: Logger): ProcessLogger = absLog2PLog(new FullLogger(log))
+
+  implicit def xlog2Log(lg: xLogger): Logger = lg match {
+    case l: Logger => l
+    case _         => wrapXLogger(lg)
+  }
+
+  private[this] def wrapXLogger(lg: xLogger): Logger = new Logger {
+    import InterfaceUtil.toSupplier
+    override def debug(msg: Supplier[String]): Unit = lg.debug(msg)
+    override def warn(msg: Supplier[String]): Unit = lg.warn(msg)
+    override def info(msg: Supplier[String]): Unit = lg.info(msg)
+    override def error(msg: Supplier[String]): Unit = lg.error(msg)
+    override def trace(msg: Supplier[Throwable]): Unit = lg.trace(msg)
+    override def log(level: Level.Value, msg: Supplier[String]): Unit = lg.log(level, msg)
+    def trace(t: => Throwable): Unit = trace(toSupplier(t))
+    def success(s: => String): Unit = info(toSupplier(s))
+    def log(level: Level.Value, msg: => String): Unit = {
+      val fmsg = toSupplier(msg)
+      level match {
+        case Level.Debug => lg.debug(fmsg)
+        case Level.Info  => lg.info(fmsg)
+        case Level.Warn  => lg.warn(fmsg)
+        case Level.Error => lg.error(fmsg)
+      }
+    }
+  }
+
+  def jo2o[A](o: Optional[A]): Option[A] = InterfaceUtil.jo2o(o)
+  def o2jo[A](o: Option[A]): Optional[A] = InterfaceUtil.o2jo(o)
+
+  @deprecated("Use InterfaceUtil.position", "1.2.2")
+  def position(
+      line0: Option[Integer],
+      content: String,
+      offset0: Option[Integer],
+      pointer0: Option[Integer],
+      pointerSpace0: Option[String],
+      sourcePath0: Option[String],
+      sourceFile0: Option[File]
+  ): Position =
+    InterfaceUtil.position(
+      line0,
+      content,
+      offset0,
+      pointer0,
+      pointerSpace0,
+      sourcePath0,
+      sourceFile0
+    )
+
+  @deprecated("Use InterfaceUtil.problem", "1.2.2")
+  def problem(cat: String, pos: Position, msg: String, sev: Severity): Problem =
+    InterfaceUtil.problem(cat, pos, msg, sev)
+}
diff --git a/internal/util-logging/src/main/scala/sbt/util/LoggerContext.scala b/internal/util-logging/src/main/scala/sbt/util/LoggerContext.scala
new file mode 100644
index 000000000..ee1069061
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/LoggerContext.scala
@@ -0,0 +1,191 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+import org.apache.logging.log4j.{ Level => XLevel }
+import org.apache.logging.log4j.core.{ Appender => XAppender, LoggerContext => XLoggerContext }
+import org.apache.logging.log4j.core.config.{ AppenderRef, LoggerConfig }
+import sbt.internal.util._
+import scala.collection.JavaConverters._
+import org.apache.logging.log4j.core.config.AbstractConfiguration
+import org.apache.logging.log4j.message.ObjectMessage
+
+/**
+ * Provides a context for generating loggers during task evaluation. The logger context
+ * can be initialized for a single command evaluation run and all of the resources
+ * created (such as cached logger appenders) can be cleaned up after task evaluation.
+ * This trait evolved out of LogExchange when it became clear that it was very difficult
+ * to manage the loggers and appenders without introducing memory leaks.
+ */
+sealed trait LoggerContext extends AutoCloseable {
+  def logger(name: String, channelName: Option[String], execId: Option[String]): ManagedLogger
+  def clearAppenders(loggerName: String): Unit
+  def addAppender(
+      loggerName: String,
+      appender: (Appender, Level.Value)
+  ): Unit
+  def appenders(loggerName: String): Seq[Appender]
+  def remove(name: String): Unit
+}
+object LoggerContext {
+  private[this] val useLog4J = System.getProperty("sbt.log.uselog4j", "false") == "true"
+  private[this] lazy val global = new LoggerContext.LoggerContextImpl
+  private[this] lazy val globalLog4J = new LoggerContext.Log4JLoggerContext(LogExchange.context)
+  private[sbt] lazy val globalContext = if (useLog4J) globalLog4J else global
+  private[util] class Log4JLoggerContext(val xlc: XLoggerContext) extends LoggerContext {
+    private val config = xlc.getConfiguration match {
+      case a: AbstractConfiguration => a
+      case _                        => throw new IllegalStateException("")
+    }
+    val loggers = new java.util.Vector[String]
+    private[this] val closed = new AtomicBoolean(false)
+    override def logger(
+        name: String,
+        channelName: Option[String],
+        execId: Option[String]
+    ): ManagedLogger = {
+      if (closed.get) {
+        throw new IllegalStateException("Tried to create logger for closed LoggerContext")
+      }
+      val loggerConfig = LoggerConfig.createLogger(
+        false,
+        XLevel.DEBUG,
+        name,
+        // disable the calculation of caller location as it is very expensive
+        // https://issues.apache.org/jira/browse/LOG4J2-153
+        "false",
+        Array[AppenderRef](),
+        null,
+        config,
+        null
+      )
+      config.addLogger(name, loggerConfig)
+      val logger = xlc.getLogger(name)
+      LogExchange.addConfig(name, loggerConfig)
+      loggers.add(name)
+      val xlogger = new MiniLogger {
+        def log(level: Level.Value, message: => String): Unit =
+          logger.log(
+            ConsoleAppender.toXLevel(level),
+            new ObjectMessage(StringEvent(level.toString, message, channelName, execId))
+          )
+        def log[T](level: Level.Value, message: ObjectEvent[T]): Unit =
+          logger.log(ConsoleAppender.toXLevel(level), new ObjectMessage(message))
+      }
+      new ManagedLogger(name, channelName, execId, xlogger, Some(Terminal.get), this)
+    }
+    override def clearAppenders(loggerName: String): Unit = {
+      val lc = config.getLoggerConfig(loggerName)
+      lc.getAppenders.asScala foreach {
+        case (name, a) =>
+          a.stop()
+          lc.removeAppender(name)
+      }
+    }
+    override def addAppender(
+        loggerName: String,
+        appender: (Appender, Level.Value)
+    ): Unit = {
+      val lc = config.getLoggerConfig(loggerName)
+      appender match {
+        case (x: XAppender, lv) => lc.addAppender(x, ConsoleAppender.toXLevel(lv), null)
+        case (x, lv)            => lc.addAppender(x.toLog4J, ConsoleAppender.toXLevel(lv), null)
+      }
+    }
+    override def appenders(loggerName: String): Seq[Appender] = {
+      val lc = config.getLoggerConfig(loggerName)
+      lc.getAppenders.asScala.collect { case (name, ca: ConsoleAppender) => ca }.toVector
+    }
+    override def remove(name: String): Unit = {
+      val lc = config.getLoggerConfig(name)
+      config.removeLogger(name)
+    }
+    def close(): Unit = if (closed.compareAndSet(false, true)) {
+      loggers.forEach(l => remove(l))
+      loggers.clear()
+    }
+  }
+  private[util] class LoggerContextImpl extends LoggerContext {
+    private class Log extends MiniLogger {
+      private val consoleAppenders: java.util.Vector[(Appender, Level.Value)] =
+        new java.util.Vector
+      def log(level: Level.Value, message: => String): Unit = {
+        val toAppend = consoleAppenders.asScala.filter { case (a, l) => level.compare(l) >= 0 }
+        if (toAppend.nonEmpty) {
+          val m = message
+          toAppend.foreach { case (a, l) => a.appendLog(level, m) }
+        }
+      }
+      def log[T](level: Level.Value, message: ObjectEvent[T]): Unit = {
+        consoleAppenders.forEach {
+          case (a, l) =>
+            if (level.compare(l) >= 0) a.appendObjectEvent(level, message)
+        }
+      }
+      def addAppender(newAppender: (Appender, Level.Value)): Unit =
+        Util.ignoreResult(consoleAppenders.add(newAppender))
+      def clearAppenders(): Unit = {
+        consoleAppenders.forEach { case (a, _) => a.close() }
+        consoleAppenders.clear()
+      }
+      def appenders: Seq[Appender] = consoleAppenders.asScala.map(_._1).toVector
+    }
+    private[this] val loggers = new ConcurrentHashMap[String, Log]
+    private[this] val closed = new AtomicBoolean(false)
+    override def logger(
+        name: String,
+        channelName: Option[String],
+        execId: Option[String]
+    ): ManagedLogger = {
+      if (closed.get) {
+        throw new IllegalStateException("Tried to create logger for closed LoggerContext")
+      }
+      val xlogger = new Log
+      loggers.put(name, xlogger)
+      new ManagedLogger(name, channelName, execId, xlogger, Some(Terminal.get), this)
+    }
+    override def clearAppenders(loggerName: String): Unit = {
+      loggers.get(loggerName) match {
+        case null =>
+        case l    => l.clearAppenders()
+      }
+    }
+    override def addAppender(
+        loggerName: String,
+        appender: (Appender, Level.Value)
+    ): Unit = {
+      if (closed.get) {
+        throw new IllegalStateException("Tried to add appender for closed LoggerContext")
+      }
+      loggers.get(loggerName) match {
+        case null =>
+        case l    => l.addAppender(appender)
+      }
+    }
+    override def appenders(loggerName: String): Seq[Appender] = {
+      loggers.get(loggerName) match {
+        case null => Nil
+        case l    => l.appenders
+      }
+    }
+    override def remove(name: String): Unit = {
+      loggers.remove(name) match {
+        case null =>
+        case l    => l.clearAppenders()
+      }
+    }
+    def close(): Unit = {
+      loggers.forEach((name, l) => l.clearAppenders())
+      loggers.clear()
+    }
+  }
+  private[sbt] def apply(useLog4J: Boolean) =
+    if (useLog4J) new Log4JLoggerContext(LogExchange.context) else new LoggerContextImpl
+}
diff --git a/internal/util-logging/src/main/scala/sbt/util/ShowLines.scala b/internal/util-logging/src/main/scala/sbt/util/ShowLines.scala
new file mode 100644
index 000000000..2f428086f
--- /dev/null
+++ b/internal/util-logging/src/main/scala/sbt/util/ShowLines.scala
@@ -0,0 +1,22 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+trait ShowLines[A] {
+  def showLines(a: A): Seq[String]
+}
+object ShowLines {
+  def apply[A](f: A => Seq[String]): ShowLines[A] =
+    new ShowLines[A] {
+      def showLines(a: A): Seq[String] = f(a)
+    }
+
+  implicit class ShowLinesOp[A: ShowLines](a: A) {
+    def lines: Seq[String] = implicitly[ShowLines[A]].showLines(a)
+  }
+}
diff --git a/internal/util-logging/src/test/resources/log4j2.component.properties b/internal/util-logging/src/test/resources/log4j2.component.properties
new file mode 100644
index 000000000..ee7c90784
--- /dev/null
+++ b/internal/util-logging/src/test/resources/log4j2.component.properties
@@ -0,0 +1 @@
+Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector
diff --git a/internal/util-logging/src/test/scala/Escapes.scala b/internal/util-logging/src/test/scala/Escapes.scala
new file mode 100644
index 000000000..82d144d99
--- /dev/null
+++ b/internal/util-logging/src/test/scala/Escapes.scala
@@ -0,0 +1,150 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalacheck._
+import Prop._
+import Gen.{ listOf, oneOf }
+
+import EscHelpers.{ ESC, hasEscapeSequence, isEscapeTerminator, removeEscapeSequences }
+
+object Escapes extends Properties("Escapes") {
+  property("genTerminator only generates terminators") =
+    forAllNoShrink(genTerminator)((c: Char) => isEscapeTerminator(c))
+
+  property("genWithoutTerminator only generates terminators") =
+    forAllNoShrink(genWithoutTerminator) { (s: String) =>
+      s.forall(c => !isEscapeTerminator(c))
+    }
+
+  property("hasEscapeSequence is false when no escape character is present") =
+    forAllNoShrink(genWithoutEscape)((s: String) => !hasEscapeSequence(s))
+
+  property("hasEscapeSequence is true when escape character is present") =
+    forAllNoShrink(genWithRandomEscapes)((s: String) => hasEscapeSequence(s))
+
+  property("removeEscapeSequences is the identity when no escape character is present") =
+    forAllNoShrink(genWithoutEscape) { (s: String) =>
+      val removed: String = removeEscapeSequences(s)
+      ("Escape sequence removed: '" + removed + "'") |:
+        (removed == s)
+    }
+
+  property("No escape characters remain after removeEscapeSequences") = forAll { (s: String) =>
+    val removed: String = removeEscapeSequences(s)
+    ("Escape sequence removed: '" + removed + "'") |:
+      !hasEscapeSequence(removed)
+  }
+
+  private[this] final val ecs = ESC.toString
+  private val partialEscapeSequences =
+    Gen.oneOf(Gen const ecs, Gen const ecs ++ "[", Gen.choose('@', '_').map(ecs :+ _))
+
+  property("removeEscapeSequences handles partial escape sequences") =
+    forAll(partialEscapeSequences) { s =>
+      val removed: String = removeEscapeSequences(s)
+      s"Escape sequence removed: '$removed'" |: !hasEscapeSequence(removed)
+    }
+
+  property("removeEscapeSequences returns string without escape sequences") =
+    forAllNoShrink(genWithoutEscape, genEscapePairs) {
+      (start: String, escapes: List[EscapeAndNot]) =>
+        val withEscapes: String =
+          start + escapes.map(ean => ean.escape.makeString + ean.notEscape).mkString("")
+        val removed: String = removeEscapeSequences(withEscapes)
+        val original = start + escapes.map(_.notEscape).mkString("")
+        val diffCharString = diffIndex(original, removed)
+        ("Input string    : '" + withEscapes + "'") |:
+          ("Expected        : '" + original + "'") |:
+          ("Escapes removed : '" + removed + "'") |:
+          (diffCharString) |:
+          (original == removed)
+    }
+
+  def diffIndex(expect: String, original: String): String = {
+    var i = 0;
+    while (i < expect.length && i < original.length) {
+      if (expect.charAt(i) != original.charAt(i))
+        return ("Differing character, idx: " + i + ", char: " + original.charAt(i) +
+          ", expected: " + expect.charAt(i))
+      i += 1
+    }
+    if (expect.length != original.length) return s"Strings are different lengths!"
+    "No differences found"
+  }
+
+  final case class EscapeAndNot(escape: EscapeSequence, notEscape: String) {
+    override def toString =
+      s"EscapeAntNot(escape = [$escape], notEscape = [${notEscape.map(_.toInt)}])"
+  }
+
+  // 2.10.5 warns on "implicit numeric widening" but it looks like a bug: https://issues.scala-lang.org/browse/SI-8450
+  final case class EscapeSequence(content: String, terminator: Char) {
+    if (!content.isEmpty) {
+      assert(
+        content.tail.forall(c => !isEscapeTerminator(c)),
+        "Escape sequence content contains an escape terminator: '" + content + "'"
+      )
+      assert(
+        (content.head == '[') || !isEscapeTerminator(content.head),
+        "Escape sequence content contains an escape terminator: '" + content.headOption + "'"
+      )
+    }
+    assert(isEscapeTerminator(terminator))
+    def makeString: String = ESC + content + terminator
+
+    override def toString =
+      if (content.isEmpty) s"ESC (${terminator.toInt})"
+      else s"ESC ($content) (${terminator.toInt})"
+  }
+
+  private[this] def noEscape(s: String): String = s.replace(ESC, ' ')
+
+  lazy val genEscapeSequence: Gen[EscapeSequence] =
+    oneOf(genKnownSequence, genTwoCharacterSequence, genArbitraryEscapeSequence)
+
+  lazy val genEscapePair: Gen[EscapeAndNot] =
+    for (esc <- genEscapeSequence; not <- genWithoutEscape) yield EscapeAndNot(esc, not)
+
+  lazy val genEscapePairs: Gen[List[EscapeAndNot]] = listOf(genEscapePair)
+
+  lazy val genArbitraryEscapeSequence: Gen[EscapeSequence] =
+    for (content <- genWithoutTerminator if !content.isEmpty; term <- genTerminator)
+      yield new EscapeSequence("[" + content, term)
+
+  lazy val genKnownSequence: Gen[EscapeSequence] =
+    oneOf((misc ++ setGraphicsMode ++ setMode ++ resetMode).map(toEscapeSequence))
+
+  def toEscapeSequence(s: String): EscapeSequence = EscapeSequence(s.init, s.last)
+
+  lazy val misc = Seq("14;23H", "5;3f", "2A", "94B", "19C", "85D", "s", "u", "2J", "K")
+
+  lazy val setGraphicsMode: Seq[String] =
+    for (txt <- 0 to 8; fg <- 30 to 37; bg <- 40 to 47)
+      yield txt.toString + ";" + fg.toString + ";" + bg.toString + "m"
+
+  lazy val resetMode = setModeLike('I')
+  lazy val setMode = setModeLike('h')
+  def setModeLike(term: Char): Seq[String] = (0 to 19).map(i => "=" + i.toString + term)
+
+  lazy val genWithoutTerminator =
+    genRawString.map(_.filter(c => !isEscapeTerminator(c) && (c != '[')))
+
+  lazy val genTwoCharacterSequence =
+    // 91 == [ which is the CSI escape sequence.
+    oneOf((64 to 95)) filter (_ != 91) map (c => new EscapeSequence("", c.toChar))
+
+  lazy val genTerminator: Gen[Char] = Gen.choose('@', '~')
+  lazy val genWithoutEscape: Gen[String] = genRawString.map(noEscape)
+
+  def genWithRandomEscapes: Gen[String] =
+    for (ls <- listOf(genRawString); end <- genRawString)
+      yield ls.mkString("", ESC.toString, ESC.toString + end)
+
+  private def genRawString = Arbitrary.arbString.arbitrary
+}
diff --git a/internal/util-logging/src/test/scala/LogExchangeSpec.scala b/internal/util-logging/src/test/scala/LogExchangeSpec.scala
new file mode 100644
index 000000000..3a26b44ab
--- /dev/null
+++ b/internal/util-logging/src/test/scala/LogExchangeSpec.scala
@@ -0,0 +1,42 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import sbt.internal.util._
+
+import org.scalatest._
+
+class LogExchangeSpec extends FlatSpec with Matchers {
+  import LogExchange._
+
+  checkTypeTag("stringTypeTagThrowable", stringTypeTagThrowable, StringTypeTag.fast[Throwable])
+  checkTypeTag(
+    "stringTypeTagTraceEvent",
+    stringTypeTagTraceEvent,
+    StringTypeTag.fast[TraceEvent]
+  )
+  checkTypeTag(
+    "stringTypeTagSuccessEvent",
+    stringTypeTagSuccessEvent,
+    StringTypeTag.fast[SuccessEvent]
+  )
+
+  private def checkTypeTag[A](name: String, inc: StringTypeTag[A], exp: StringTypeTag[A]): Unit =
+    s"LogExchange.$name" should s"match real StringTypeTag[$exp]" in {
+      val StringTypeTag(incomingString) = inc
+      val StringTypeTag(expectedString) = exp
+      if ((incomingString startsWith "scala.") || (expectedString startsWith "scala.")) {
+        // > historically [Scala] has been inconsistent whether `scala.` is included, or not
+        // > would it be hard to make the test accept either result?
+        // https://github.com/scala/community-builds/pull/758#issuecomment-409760633
+        assert((incomingString stripPrefix "scala.") == (expectedString stripPrefix "scala."))
+      } else {
+        assert(incomingString == expectedString)
+      }
+    }
+}
diff --git a/internal/util-logging/src/test/scala/LogWriterTest.scala b/internal/util-logging/src/test/scala/LogWriterTest.scala
new file mode 100644
index 000000000..0fda82264
--- /dev/null
+++ b/internal/util-logging/src/test/scala/LogWriterTest.scala
@@ -0,0 +1,168 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+import org.scalacheck._
+import Arbitrary._
+import Gen.{ listOfN, oneOf }
+import Prop._
+
+import java.io.Writer
+
+object LogWriterTest extends Properties("Log Writer") {
+  final val MaxLines = 100
+  final val MaxSegments = 10
+
+  /* Tests that content written through a LoggerWriter is properly passed to the underlying Logger.
+	* Each line, determined by the specified newline separator, must be logged at the correct logging level. */
+  property("properly logged") = forAll { (output: Output, newLine: NewLine) =>
+    import output.{ lines, level }
+    val log = new RecordingLogger
+    val writer = new LoggerWriter(log, Some(level), newLine.str)
+    logLines(writer, lines, newLine.str)
+    val events = log.getEvents
+    ("Recorded:\n" + events.map(show).mkString("\n")) |:
+      check(toLines(lines), events, level)
+  }
+
+  /**
+   * Displays a LogEvent in a useful format for debugging.  In particular, we are only interested in `Log` types
+   * and non-printable characters should be escaped
+   */
+  def show(event: LogEvent): String =
+    event match {
+      case l: Log => "Log('" + Escape(l.msg) + "', " + l.level + ")"
+      case _      => "Not Log"
+    }
+
+  /**
+   * Writes the given lines to the Writer.  `lines` is taken to be a list of lines, which are
+   * represented as separately written segments (ToLog instances).  ToLog.`byCharacter`
+   * indicates whether to write the segment by character (true) or all at once (false)
+   */
+  def logLines(writer: Writer, lines: List[List[ToLog]], newLine: String): Unit = {
+    for (line <- lines; section <- line) {
+      val content = section.content
+      val normalized = Escape.newline(content, newLine)
+      if (section.byCharacter)
+        normalized.foreach(c => writer.write(c.toInt))
+      else
+        writer.write(normalized)
+    }
+    writer.flush()
+  }
+
+  /** Converts the given lines in segments to lines as Strings for checking the results of the test.*/
+  def toLines(lines: List[List[ToLog]]): List[String] =
+    lines.map(_.map(_.contentOnly).mkString)
+
+  /** Checks that the expected `lines` were recorded as `events` at level `Lvl`.*/
+  def check(lines: List[String], events: List[LogEvent], Lvl: Level.Value): Boolean =
+    (lines zip events) forall {
+      case (line, log: Log) => log.level == Lvl && line == log.msg
+      case _                => false
+    }
+
+  /* The following are implicit generators to build up a write sequence.
+   * ToLog represents a written segment.  NewLine represents one of the possible
+   * newline separators.  A List[ToLog] represents a full line and always includes a
+   * final ToLog with a trailing '\n'.  Newline characters are otherwise not present in
+   * the `content` of a ToLog instance.*/
+
+  implicit lazy val arbOut: Arbitrary[Output] = Arbitrary(genOutput)
+  implicit lazy val arbLog: Arbitrary[ToLog] = Arbitrary(genLog)
+  implicit lazy val arbLine: Arbitrary[List[ToLog]] = Arbitrary(genLine)
+  implicit lazy val arbNewLine: Arbitrary[NewLine] = Arbitrary(genNewLine)
+  implicit lazy val arbLevel: Arbitrary[Level.Value] = Arbitrary(genLevel)
+
+  implicit def genLine(implicit logG: Gen[ToLog]): Gen[List[ToLog]] =
+    for (l <- listOf[ToLog](MaxSegments); last <- logG)
+      yield (addNewline(last) :: l.filter(!_.content.isEmpty)).reverse
+
+  implicit def genLog(implicit content: Arbitrary[String], byChar: Arbitrary[Boolean]): Gen[ToLog] =
+    for (c <- content.arbitrary; by <- byChar.arbitrary) yield {
+      assert(c != null)
+      new ToLog(removeNewlines(c), by)
+    }
+
+  implicit lazy val genNewLine: Gen[NewLine] =
+    for (str <- oneOf("\n", "\r", "\r\n")) yield new NewLine(str)
+
+  implicit lazy val genLevel: Gen[Level.Value] =
+    oneOf(Level.values.toSeq)
+
+  implicit lazy val genOutput: Gen[Output] =
+    for (ls <- listOf[List[ToLog]](MaxLines); lv <- genLevel) yield new Output(ls, lv)
+
+  def removeNewlines(s: String) = s.replaceAll("""[\n\r]+""", "")
+  def addNewline(l: ToLog): ToLog =
+    new ToLog(l.content + "\n", l.byCharacter) // \n will be replaced by a random line terminator for all lines
+
+  def listOf[T](max: Int)(implicit content: Arbitrary[T]): Gen[List[T]] =
+    Gen.choose(0, max) flatMap (sz => listOfN(sz, content.arbitrary))
+}
+
+/* Helper classes*/
+
+final class Output(val lines: List[List[ToLog]], val level: Level.Value) {
+  override def toString =
+    "Level: " + level + "\n" + lines.map(_.mkString).mkString("\n")
+}
+
+final class NewLine(val str: String) {
+  override def toString = Escape(str)
+}
+
+final class ToLog(val content: String, val byCharacter: Boolean) {
+  def contentOnly = Escape.newline(content, "")
+
+  override def toString =
+    if (content.isEmpty) "" else "ToLog('" + Escape(contentOnly) + "', " + byCharacter + ")"
+}
+
+/** Defines some utility methods for escaping unprintable characters.*/
+object Escape {
+
+  /** Escapes characters with code less than 20 by printing them as unicode escapes.*/
+  def apply(s: String): String = {
+    val builder = new StringBuilder(s.length)
+    for (c <- s) {
+      val char = c.toInt
+      def escaped = pad(char.toHexString.toUpperCase, 4, '0')
+      if (c < 20) builder.append("\\u").append(escaped) else builder.append(c)
+    }
+    builder.toString
+  }
+
+  def pad(s: String, minLength: Int, extra: Char) = {
+    val diff = minLength - s.length
+    if (diff <= 0) s else List.fill(diff)(extra).mkString("", "", s)
+  }
+
+  /** Replaces a \n character at the end of a string `s` with `nl`.*/
+  def newline(s: String, nl: String): String =
+    if (s.endsWith("\n")) s.substring(0, s.length - 1) + nl else s
+
+}
+
+/** Records logging events for later retrieval.*/
+final class RecordingLogger extends BasicLogger {
+  private var events: List[LogEvent] = Nil
+
+  def getEvents = events.reverse
+
+  override def ansiCodesSupported = true
+  def trace(t: => Throwable): Unit = { events ::= new Trace(t) }
+  def log(level: Level.Value, message: => String): Unit = { events ::= new Log(level, message) }
+  def success(message: => String): Unit = { events ::= new Success(message) }
+  def logAll(es: Seq[LogEvent]): Unit = { events :::= es.toList }
+
+  def control(event: ControlEvent.Value, message: => String): Unit =
+    events ::= new ControlEvent(event, message)
+}
diff --git a/internal/util-logging/src/test/scala/ManagedLoggerSpec.scala b/internal/util-logging/src/test/scala/ManagedLoggerSpec.scala
new file mode 100644
index 000000000..9d617662f
--- /dev/null
+++ b/internal/util-logging/src/test/scala/ManagedLoggerSpec.scala
@@ -0,0 +1,146 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalatest._
+import sbt.util._
+import java.io.{ File, PrintWriter }
+import sbt.io.Using
+import scala.annotation.nowarn
+
+class ManagedLoggerSpec extends FlatSpec with Matchers {
+  val context = LoggerContext(useLog4J = true)
+  @nowarn
+  val asyncStdout = new ConsoleAppenderFromLog4J("asyncStdout", LogExchange.asyncStdout)
+  def newLogger(name: String): ManagedLogger = context.logger(name, None, None)
+  "ManagedLogger" should "log to console" in {
+    val log = newLogger("foo")
+    context.addAppender("foo", asyncStdout -> Level.Info)
+    log.info("test")
+    log.debug("test")
+  }
+
+  it should "support event logging" in {
+    import sjsonnew.BasicJsonProtocol._
+    val log = newLogger("foo")
+    context.addAppender("foo", asyncStdout -> Level.Info)
+    log.infoEvent(1)
+  }
+
+  it should "validate performance improvement of disabling location calculation for async loggers" in {
+    val log = newLogger("foo")
+    context.addAppender("foo", asyncStdout -> Level.Info)
+    val before = System.currentTimeMillis()
+    1 to 10000 foreach { _ =>
+      log.debug("test")
+    }
+    val after = System.currentTimeMillis()
+
+    log.info(s"Peformance test took: ${after - before}ms")
+  }
+
+  it should "support logging Throwable out of the box" in {
+    import sbt.internal.util.codec.JsonProtocol._
+    val log = newLogger("foo")
+    context.addAppender("foo", asyncStdout -> Level.Info)
+    log.infoEvent(SuccessEvent("yes"))
+  }
+
+  it should "allow registering Show[Int]" in {
+    import sjsonnew.BasicJsonProtocol._
+    val log = newLogger("foo")
+    context.addAppender("foo", asyncStdout -> Level.Info)
+    implicit val intShow: ShowLines[Int] =
+      ShowLines((x: Int) => Vector(s"String representation of $x"))
+    log.registerStringCodec[Int]
+    log.infoEvent(1)
+  }
+
+  it should "allow registering Show[Array[Int]]" in {
+    import sjsonnew.BasicJsonProtocol._
+    val log = newLogger("foo")
+    context.addAppender("foo", asyncStdout -> Level.Info)
+    implicit val intArrayShow: ShowLines[Array[Int]] =
+      ShowLines((x: Array[Int]) => Vector(s"String representation of ${x.mkString}"))
+    log.registerStringCodec[Array[Int]]
+    log.infoEvent(Array(1, 2, 3))
+  }
+
+  it should "allow registering Show[Vector[Vector[Int]]]" in {
+    import sjsonnew.BasicJsonProtocol._
+    val log = newLogger("foo")
+    context.addAppender("foo", asyncStdout -> Level.Info)
+    implicit val intVectorShow: ShowLines[Vector[Vector[Int]]] =
+      ShowLines((xss: Vector[Vector[Int]]) => Vector(s"String representation of $xss"))
+    log.registerStringCodec[Vector[Vector[Int]]]
+    log.infoEvent(Vector(Vector(1, 2, 3)))
+  }
+
+  it should "be thread safe" in {
+    import java.util.concurrent.{ Executors, TimeUnit }
+    val pool = Executors.newFixedThreadPool(100)
+    for {
+      i <- 1 to 10000
+    } {
+      pool.submit(new Runnable {
+        def run(): Unit = {
+          val stringTypeTag = StringTypeTag.fast[List[Int]]
+          val log = newLogger(s"foo$i")
+          context.addAppender(s"foo$i", asyncStdout -> Level.Info)
+          if (i % 100 == 0) {
+            log.info(s"foo$i test $stringTypeTag")
+          }
+          Thread.sleep(1)
+        }
+      })
+    }
+    pool.shutdown
+    pool.awaitTermination(30, TimeUnit.SECONDS)
+  }
+
+  "global logging" should "log immediately after initialization" in {
+    // this is passed into State normally
+    val global0 = initialGlobalLogging
+    val full = global0.full
+    (1 to 3).toList foreach { x =>
+      full.info(s"test$x")
+    }
+  }
+
+  // This is done in Mainloop.scala
+  it should "create a new backing with newAppender" in {
+    val global0 = initialGlobalLogging
+    val logBacking0 = global0.backing
+    val global1 = Using.fileWriter(append = true)(logBacking0.file) { writer =>
+      val out = new PrintWriter(writer)
+      val g = global0.newAppender(global0.full, out, logBacking0, context)
+      val full = g.full
+      (1 to 3).toList foreach (x => full.info(s"newAppender $x"))
+      assert(logBacking0.file.exists)
+      g
+    }
+    val logBacking1 = global1.backing
+    Using.fileWriter(append = true)(logBacking1.file) { writer =>
+      val out = new PrintWriter(writer)
+      val g = global1.newAppender(global1.full, out, logBacking1, context)
+      val full = g.full
+      (1 to 3).toList foreach (x => full.info(s"newAppender $x"))
+      // println(logBacking.file)
+      // print("Press enter to continue. ")
+      // System.console.readLine
+      assert(logBacking1.file.exists)
+    }
+  }
+
+  val console = ConsoleOut.systemOut
+  def initialGlobalLogging: GlobalLogging = GlobalLogging.initial(
+    MainAppender.globalDefault(console),
+    File.createTempFile("sbt", ".log"),
+    console
+  )
+}
diff --git a/internal/util-logging/src/test/scala/TestLogger.scala b/internal/util-logging/src/test/scala/TestLogger.scala
new file mode 100644
index 000000000..45034ab10
--- /dev/null
+++ b/internal/util-logging/src/test/scala/TestLogger.scala
@@ -0,0 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import sbt.util._
+
+object TestLogger {
+  def apply[T](f: Logger => T): T = {
+    val log = new BufferedLogger(ConsoleLogger())
+    log.setLevel(Level.Debug)
+    log.bufferQuietly(f(log))
+  }
+}
diff --git a/internal/util-logging/src/test/scala/sbt/internal/util/CleanStringSpec.scala b/internal/util-logging/src/test/scala/sbt/internal/util/CleanStringSpec.scala
new file mode 100644
index 000000000..f734923a6
--- /dev/null
+++ b/internal/util-logging/src/test/scala/sbt/internal/util/CleanStringSpec.scala
@@ -0,0 +1,99 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalatest.FlatSpec
+
+class CleanStringSpec extends FlatSpec {
+  "EscHelpers" should "not modify normal strings" in {
+    val cleanString = s"1234"
+    assert(EscHelpers.stripColorsAndMoves(cleanString) == cleanString)
+  }
+  it should "remove delete lines" in {
+    val clean = "1234"
+    val string = s"${ConsoleAppender.DeleteLine}$clean"
+    assert(EscHelpers.stripColorsAndMoves(string) == clean)
+  }
+  it should "remove cursor left" in {
+    val clean = "1234"
+    val backspaced = s"1235${ConsoleAppender.cursorLeft(1)}${ConsoleAppender.clearLine(0)}4"
+    assert(EscHelpers.stripColorsAndMoves(backspaced) == clean)
+  }
+  it should "remove colors" in {
+    val clean = "1234"
+    val colored = s"${scala.Console.RED}$clean${scala.Console.RESET}"
+    assert(EscHelpers.stripColorsAndMoves(colored) == clean)
+  }
+  it should "remove backspaces" in {
+    // Taken from an actual failure case. In the scala client, type 'clean', then type backspace
+    // five times to clear 'clean' and then retype 'clean'.
+    val bytes = Array[Byte](27, 91, 50, 75, 27, 91, 48, 74, 27, 91, 50, 75, 27, 91, 49, 48, 48, 48,
+      68, 115, 98, 116, 58, 115, 99, 97, 108, 97, 45, 99, 111, 109, 112, 105, 108, 101, 27, 91, 51,
+      54, 109, 62, 32, 27, 91, 48, 109, 99, 108, 101, 97, 110, 8, 27, 91, 75, 110)
+    val str = new String(bytes)
+    assert(EscHelpers.stripColorsAndMoves(str) == "sbt:scala-compile> clean")
+  }
+  it should "handle cursor left overwrite" in {
+    val clean = "1234"
+    val backspaced = s"1235${8.toChar}4${8.toChar}"
+    assert(EscHelpers.stripColorsAndMoves(backspaced) == clean)
+  }
+  it should "remove moves in string with only moves" in {
+    val original =
+      Array[Byte](27, 91, 50, 75, 27, 91, 51, 65, 27, 91, 49, 48, 48, 48, 68)
+    val (bytes, len) = EscHelpers.strip(original, stripAnsi = true, stripColor = true)
+    assert(len == 0)
+  }
+  it should "remove moves in string with moves and letters" in {
+    val original =
+      Array[Byte](27, 91, 50, 75, 27, 91, 51, 65) ++ "foo".getBytes ++ Array[Byte](27, 91, 49, 48,
+        48, 48, 68)
+    val (bytes, len) = EscHelpers.strip(original, stripAnsi = true, stripColor = true)
+    assert(new String(bytes, 0, len) == "foo")
+  }
+  it should "preserve colors" in {
+    val original =
+      Array[Byte](27, 91, 49, 48, 48, 48, 68, 27, 91, 48, 74, 102, 111, 111, 27, 91, 51, 54, 109,
+        62, 32, 27, 91, 48, 109)
+    // this is taken from an sbt prompt that looks like "foo> " with the > rendered blue
+    val colorArrow = new String(Array[Byte](27, 91, 51, 54, 109, 62))
+    val (bytes, len) = EscHelpers.strip(original, stripAnsi = true, stripColor = false)
+    assert(new String(bytes, 0, len) == "foo" + colorArrow + " " + scala.Console.RESET)
+  }
+  it should "remove unusual escape characters" in {
+    val original = new String(
+      Array[Byte](27, 91, 63, 49, 108, 27, 62, 27, 91, 63, 49, 48, 48, 48, 108, 27, 91, 63, 50, 48,
+        48, 52, 108)
+    )
+    assert(EscHelpers.stripColorsAndMoves(original).isEmpty)
+  }
+  it should "remove bracketed paste csi" in {
+    // taken from a test project prompt
+    val original =
+      Array[Byte](27, 91, 63, 50, 48, 48, 52, 104, 115, 98, 116, 58, 114, 101, 112, 114, 111, 62,
+        32)
+    val (bytes, len) = EscHelpers.strip(original, stripAnsi = true, stripColor = false)
+    assert(new String(bytes, 0, len) == "sbt:repro> ")
+  }
+  it should "strip colors" in {
+    // taken from utest output
+    val original =
+      Array[Byte](91, 105, 110, 102, 111, 93, 32, 27, 91, 51, 50, 109, 43, 27, 91, 51, 57, 109, 32,
+        99, 111, 109, 46, 97, 99, 109, 101, 46, 67, 111, 121, 111, 116, 101, 84, 101, 115, 116, 46,
+        109, 97, 107, 101, 84, 114, 97, 112, 32, 27, 91, 50, 109, 57, 109, 115, 27, 91, 48, 109, 32,
+        32, 27, 91, 48, 74, 10)
+    val (bytes, len) = EscHelpers.strip(original, stripAnsi = false, stripColor = true)
+    val expected = "[info] + com.acme.CoyoteTest.makeTrap 9ms  " +
+      new String(Array[Byte](27, 91, 48, 74, 10))
+    assert(new String(bytes, 0, len) == expected)
+
+    val (bytes2, len2) = EscHelpers.strip(original, stripAnsi = true, stripColor = true)
+    val expected2 = "[info] + com.acme.CoyoteTest.makeTrap 9ms  \n"
+    assert(new String(bytes2, 0, len2) == expected2)
+  }
+}
diff --git a/internal/util-logging/src/test/scala/sbt/internal/util/UTF8DecoderSpec.scala b/internal/util-logging/src/test/scala/sbt/internal/util/UTF8DecoderSpec.scala
new file mode 100644
index 000000000..957a95b4e
--- /dev/null
+++ b/internal/util-logging/src/test/scala/sbt/internal/util/UTF8DecoderSpec.scala
@@ -0,0 +1,41 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.InputStream
+import java.nio.charset.Charset
+import org.scalatest.FlatSpec
+import java.util.concurrent.LinkedBlockingQueue
+
+class UTF8DecoderSpec extends FlatSpec {
+  val decoder = Charset.forName("UTF-8").newDecoder
+  "ascii characters" should "not be modified" in {
+    val inputStream = new InputStream {
+      override def read(): Int = 'c'.toInt
+    }
+    assert(JLine3.decodeInput(decoder, inputStream) == 'c'.toInt)
+  }
+  "swedish characters" should "be handled" in {
+    val bytes = new LinkedBlockingQueue[Int]
+    // these are the utf-8 codes for an umlauted a in swedish
+    Seq(195, 164).foreach(b => bytes.put(b))
+    val inputStream = new InputStream {
+      override def read(): Int = Option(bytes.poll).getOrElse(-1)
+    }
+    assert(JLine3.decodeInput(decoder, inputStream) == 228)
+  }
+  "emoji" should "be handled" in {
+    val bytes = new LinkedBlockingQueue[Int]
+    // laughing and crying emoji in utf8
+    Seq(0xF0, 0x9F, 0x98, 0x82).foreach(b => bytes.put(b))
+    val inputStream = new InputStream {
+      override def read(): Int = Option(bytes.poll).getOrElse(-1)
+    }
+    assert(JLine3.decodeInput(decoder, inputStream) == 128514)
+  }
+}
diff --git a/internal/util-logic/src/main/scala/sbt/internal/util/logic/Logic.scala b/internal/util-logic/src/main/scala/sbt/internal/util/logic/Logic.scala
new file mode 100644
index 000000000..e508022bb
--- /dev/null
+++ b/internal/util-logic/src/main/scala/sbt/internal/util/logic/Logic.scala
@@ -0,0 +1,408 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package logic
+
+import scala.annotation.{ nowarn, tailrec }
+import Formula.{ And, True }
+
+/*
+Defines a propositional logic with negation as failure and only allows stratified rule sets
+(negation must be acyclic) in order to have a unique minimal model.
+
+For example, this is not allowed:
+  + p :- not q
+  + q :- not p
+but this is:
+  + p :- q
+  + q :- p
+as is this:
+  + p :- q
+  + q := not r
+
+
+ Some useful links:
+  + https://en.wikipedia.org/wiki/Nonmonotonic_logic
+  + https://en.wikipedia.org/wiki/Negation_as_failure
+  + https://en.wikipedia.org/wiki/Propositional_logic
+  + https://en.wikipedia.org/wiki/Stable_model_semantics
+  + http://www.w3.org/2005/rules/wg/wiki/negation
+ */
+
+/** Disjunction (or) of the list of clauses. */
+final case class Clauses(clauses: List[Clause]) {
+  assert(clauses.nonEmpty, "At least one clause is required.")
+  override def toString: String =
+    s"Clauses(${clauses.mkString("\n")})"
+}
+
+/** When the `body` Formula succeeds, atoms in `head` are true. */
+final case class Clause(body: Formula, head: Set[Atom])
+
+/** A literal is an [[Atom]] or its negation ([[Negated]]). */
+sealed abstract class Literal extends Formula {
+
+  /** The underlying (positive) atom. */
+  def atom: Atom
+
+  /** Negates this literal.*/
+  def unary_! : Literal
+
+}
+
+/** A variable with name `label`. */
+final case class Atom(label: String) extends Literal {
+  def atom = this
+  def unary_! : Negated = Negated(this)
+}
+
+/**
+ * A negated atom, in the sense of negation as failure, not logical negation.
+ * That is, it is true if `atom` is not known/defined.
+ */
+final case class Negated(atom: Atom) extends Literal {
+  def unary_! : Atom = atom
+}
+
+/**
+ * A formula consists of variables, negation, and conjunction (and).
+ * (Disjunction is not currently included- it is modeled at the level of a sequence of clauses.
+ *  This is less convenient when defining clauses, but is not less powerful.)
+ */
+sealed abstract class Formula {
+
+  /** Constructs a clause that proves `atoms` when this formula is true. */
+  def proves(atom: Atom, atoms: Atom*): Clause = Clause(this, (atom +: atoms).toSet)
+
+  /** Constructs a formula that is true iff this formula and `f` are both true.*/
+  def &&(f: Formula): Formula = (this, f) match {
+    case (True, x)                => x
+    case (x, True)                => x
+    case (And(as), And(bs))       => And(as ++ bs)
+    case (And(as), b: Literal)    => And(as + b)
+    case (a: Literal, And(bs))    => And(bs + a)
+    case (a: Literal, b: Literal) => And(Set(a, b))
+  }
+
+}
+
+object Formula {
+
+  /** A conjunction of literals. */
+  final case class And(literals: Set[Literal]) extends Formula {
+    assert(literals.nonEmpty, "'And' requires at least one literal.")
+  }
+
+  final case object True extends Formula
+
+}
+
+object Logic {
+  def reduceAll(
+      clauses: List[Clause],
+      initialFacts: Set[Literal]
+  ): Either[LogicException, Matched] =
+    reduce(Clauses(clauses), initialFacts)
+
+  /**
+   * Computes the variables in the unique stable model for the program represented by `clauses` and
+   * `initialFacts`.  `clause` may not have any negative feedback (that is, negation is acyclic)
+   * and `initialFacts` cannot be in the head of any clauses in `clause`.
+   * These restrictions ensure that the logic program has a unique minimal model.
+   */
+  def reduce(clauses: Clauses, initialFacts: Set[Literal]): Either[LogicException, Matched] = {
+    val (posSeq, negSeq) = separate(initialFacts.toSeq)
+    val (pos, neg) = (posSeq.toSet, negSeq.toSet)
+
+    val problem =
+      (checkContradictions(pos, neg): Option[LogicException]) orElse
+        (checkOverlap(clauses, pos): Option[LogicException])
+    // orElse
+    // (checkAcyclic(clauses): Option[LogicException])
+    problem.toLeft(
+      reduce0(clauses, initialFacts, Matched.empty)
+    )
+  }
+
+  /**
+   * Verifies `initialFacts` are not in the head of any `clauses`.
+   * This avoids the situation where an atom is proved but no clauses prove it.
+   * This isn't necessarily a problem, but the main sbt use cases expects
+   * a proven atom to have at least one clause satisfied.
+   */
+  private[this] def checkOverlap(
+      clauses: Clauses,
+      initialFacts: Set[Atom]
+  ): Option[InitialOverlap] = {
+    val as = atoms(clauses)
+    val initialOverlap = initialFacts.filter(as.inHead)
+    if (initialOverlap.nonEmpty) Some(new InitialOverlap(initialOverlap)) else None
+  }
+
+  private[this] def checkContradictions(
+      pos: Set[Atom],
+      neg: Set[Atom]
+  ): Option[InitialContradictions] = {
+    val contradictions = pos intersect neg
+    if (contradictions.nonEmpty) Some(new InitialContradictions(contradictions)) else None
+  }
+
+  @nowarn
+  private[this] def checkAcyclic(clauses: Clauses): Option[CyclicNegation] = {
+    val deps = dependencyMap(clauses)
+    // println(s"deps = $deps")
+    // println(s"graph(deps) = ${graph(deps)}")
+    val cycle = Dag.findNegativeCycle(graph(deps))
+    if (cycle.nonEmpty) Some(new CyclicNegation(cycle)) else None
+  }
+
+  private[this] def graph(deps: Map[Atom, Set[Literal]]) = new Dag.DirectedSignedGraph[Atom] {
+    type Arrow = Literal
+    def nodes = deps.keys.toList
+    def dependencies(a: Atom) = deps.getOrElse(a, Set.empty).toList
+
+    def isNegative(b: Literal) = b match {
+      case Negated(_) => true
+      case Atom(_)    => false
+    }
+
+    def head(b: Literal) = b.atom
+    override def toString(): String =
+      nodes
+        .flatMap(n => List(n) ++ dependencies(n).map(d => s"$n -> $d"))
+        .mkString("{\n", "\n", "\n}")
+  }
+
+  private[this] def dependencyMap(clauses: Clauses): Map[Atom, Set[Literal]] =
+    clauses.clauses.foldLeft(Map.empty[Atom, Set[Literal]]) {
+      case (m, Clause(formula, heads)) =>
+        val deps = literals(formula)
+        heads.foldLeft(m) { (n, head) =>
+          n.updated(head, n.getOrElse(head, Set.empty) ++ deps)
+        }
+    }
+
+  sealed abstract class LogicException(override val toString: String)
+
+  final class InitialContradictions(val literals: Set[Atom])
+      extends LogicException(
+        "Initial facts cannot be both true and false:\n\t" + literals.mkString("\n\t")
+      )
+
+  final class InitialOverlap(val literals: Set[Atom])
+      extends LogicException(
+        "Initial positive facts cannot be implied by any clauses:\n\t" + literals.mkString("\n\t")
+      )
+
+  final class CyclicNegation(val cycle: List[Literal])
+      extends LogicException(
+        "Negation may not be involved in a cycle:\n\t" + cycle.mkString("\n\t")
+      )
+
+  /** Tracks proven atoms in the reverse order they were proved. */
+  final class Matched private (val provenSet: Set[Atom], reverseOrdered: List[Atom]) {
+    def add(atoms: Set[Atom]): Matched = add(atoms.toList)
+
+    def add(atoms: List[Atom]): Matched = {
+      val newOnly = atoms.filterNot(provenSet)
+      new Matched(provenSet ++ newOnly.toSet, newOnly ::: reverseOrdered)
+    }
+
+    def ordered: List[Atom] = reverseOrdered.reverse
+    override def toString = ordered.map(_.label).mkString("Matched(", ",", ")")
+  }
+
+  object Matched {
+    val empty = new Matched(Set.empty, Nil)
+  }
+
+  /** Separates a sequence of literals into `(pos, neg)` atom sequences. */
+  private[this] def separate(lits: Seq[Literal]): (Seq[Atom], Seq[Atom]) =
+    Util.separate(lits) {
+      case a: Atom    => Left(a)
+      case Negated(n) => Right(n)
+    }
+
+  /**
+   * Finds clauses that have no body and thus prove their head.
+   * Returns `(<proven atoms>, <remaining unproven clauses>)`.
+   */
+  private[this] def findProven(c: Clauses): (Set[Atom], List[Clause]) = {
+    val (proven, unproven) = c.clauses.partition(_.body == True)
+    (proven.flatMap(_.head).toSet, unproven)
+  }
+
+  private[this] def keepPositive(lits: Set[Literal]): Set[Atom] =
+    lits.collect { case a: Atom => a }.toSet
+
+  // precondition: factsToProcess contains no contradictions
+  @tailrec private[this] def reduce0(
+      clauses: Clauses,
+      factsToProcess: Set[Literal],
+      state: Matched
+  ): Matched =
+    applyAll(clauses, factsToProcess) match {
+      case None => state // all of the remaining clauses failed on the new facts
+      case Some(applied) =>
+        val (proven, unprovenClauses) = findProven(applied)
+        val processedFacts = state add keepPositive(factsToProcess)
+        val newlyProven = proven -- processedFacts.provenSet
+        val newState = processedFacts add newlyProven
+        if (unprovenClauses.isEmpty)
+          newState // no remaining clauses, done.
+        else {
+          val unproven = Clauses(unprovenClauses)
+          val nextFacts: Set[Literal] =
+            if (newlyProven.nonEmpty) newlyProven.toSet[Literal]
+            else inferFailure(unproven)
+          reduce0(unproven, nextFacts, newState)
+        }
+    }
+
+  /**
+   * Finds negated atoms under the negation as failure rule and returns them.
+   * This should be called only after there are no more known atoms to be substituted.
+   */
+  private[this] def inferFailure(clauses: Clauses): Set[Literal] = {
+    /* At this point, there is at least one clause and one of the following is the case as the
+       result of the acyclic negation rule:
+         i. there is at least one variable that occurs in a clause body but not in the head of a
+            clause
+         ii. there is at least one variable that occurs in the head of a clause and does not
+             transitively depend on a negated variable
+
+       In either case, each such variable x cannot be proven true and therefore proves 'not x'
+       (negation as failure, !x in the code).
+     */
+    val allAtoms = atoms(clauses)
+    val newFacts: Set[Literal] = negated(allAtoms.triviallyFalse)
+    if (newFacts.nonEmpty)
+      newFacts
+    else {
+      val possiblyTrue = hasNegatedDependency(clauses.clauses, Relation.empty, Relation.empty)
+      val newlyFalse: Set[Literal] = negated(allAtoms.inHead -- possiblyTrue)
+      if (newlyFalse.nonEmpty)
+        newlyFalse
+      else // should never happen due to the acyclic negation rule
+        sys.error(s"No progress:\n\tclauses: $clauses\n\tpossibly true: $possiblyTrue")
+    }
+  }
+
+  private[this] def negated(atoms: Set[Atom]): Set[Literal] = atoms.map(a => (Negated(a): Literal))
+
+  /**
+   * Computes the set of atoms in `clauses` that directly or transitively take a negated atom as input.
+   * For example, for the following clauses, this method would return `List(a, d)` :
+   *  a :- b, not c
+   *  d :- a
+   */
+  @tailrec
+  def hasNegatedDependency(
+      clauses: Seq[Clause],
+      posDeps: Relation[Atom, Atom],
+      negDeps: Relation[Atom, Atom]
+  ): List[Atom] =
+    clauses match {
+      case Seq() =>
+        // because cycles between positive literals are allowed, this isn't strictly a topological sort
+        Dag.topologicalSortUnchecked(negDeps._1s)(posDeps.reverse)
+
+      case Clause(formula, head) +: tail =>
+        // collect direct positive and negative literals and track them in separate graphs
+        val (pos, neg) = directDeps(formula)
+        val (newPos, newNeg) = head.foldLeft((posDeps, negDeps)) {
+          case ((pdeps, ndeps), d) =>
+            (pdeps.+(d, pos), ndeps.+(d, neg))
+        }
+        hasNegatedDependency(tail, newPos, newNeg)
+    }
+
+  /** Computes the `(positive, negative)` literals in `formula`. */
+  private[this] def directDeps(formula: Formula): (Seq[Atom], Seq[Atom]) =
+    Util.separate(literals(formula).toSeq) {
+      case Negated(a) => Right(a)
+      case a: Atom    => Left(a)
+    }
+
+  private[this] def literals(formula: Formula): Set[Literal] = formula match {
+    case And(lits)  => lits
+    case l: Literal => Set(l)
+    case True       => Set.empty
+  }
+
+  /** Computes the atoms in the heads and bodies of the clauses in `clause`. */
+  def atoms(cs: Clauses): Atoms = cs.clauses.map(c => Atoms(c.head, atoms(c.body))).reduce(_ ++ _)
+
+  /** Computes the set of all atoms in `formula`. */
+  def atoms(formula: Formula): Set[Atom] = formula match {
+    case And(lits)    => lits.map(_.atom)
+    case Negated(lit) => Set(lit)
+    case a: Atom      => Set(a)
+    case True         => Set()
+  }
+
+  /** Represents the set of atoms in the heads of clauses and in the bodies (formulas) of clauses. */
+  final case class Atoms(inHead: Set[Atom], inFormula: Set[Atom]) {
+
+    /** Concatenates this with `as`. */
+    def ++(as: Atoms): Atoms = Atoms(inHead ++ as.inHead, inFormula ++ as.inFormula)
+
+    /** Atoms that cannot be true because they do not occur in a head. */
+    def triviallyFalse: Set[Atom] = inFormula -- inHead
+
+  }
+
+  /**
+   * Applies known facts to `clause`s, deriving a new, possibly empty list of clauses.
+   * 1. If a fact is in the body of a clause, the derived clause has that fact removed from the body.
+   * 2. If the negation of a fact is in a body of a clause, that clause fails and is removed.
+   * 3. If a fact or its negation is in the head of a clause, the derived clause has that fact (or its negation) removed from the head.
+   * 4. If a head is empty, the clause proves nothing and is removed.
+   *
+   * NOTE: empty bodies do not cause a clause to succeed yet.
+   *       All known facts must be applied before this can be done in order to avoid inconsistencies.
+   * Precondition: no contradictions in `facts`
+   * Postcondition: no atom in `facts` is present in the result
+   * Postcondition: No clauses have an empty head
+   */
+  def applyAll(cs: Clauses, facts: Set[Literal]): Option[Clauses] = {
+    val newClauses =
+      if (facts.isEmpty)
+        cs.clauses.filter(_.head.nonEmpty) // still need to drop clauses with an empty head
+      else
+        cs.clauses.map(c => applyAll(c, facts)).flatMap(_.toList)
+    if (newClauses.isEmpty) None else Some(Clauses(newClauses))
+  }
+
+  def applyAll(c: Clause, facts: Set[Literal]): Option[Clause] = {
+    val atoms = facts.map(_.atom)
+    val newHead = c.head -- atoms // 3.
+    if (newHead.isEmpty) // 4. empty head
+      None
+    else
+      substitute(c.body, facts).map(f => Clause(f, newHead)) // 1, 2
+  }
+
+  /** Derives the formula that results from substituting `facts` into `formula`. */
+  @tailrec def substitute(formula: Formula, facts: Set[Literal]): Option[Formula] = formula match {
+    case And(lits) =>
+      def negated(lits: Set[Literal]): Set[Literal] = lits.map(a => !a)
+      if (lits.exists(negated(facts))) // 2.
+        None
+      else {
+        val newLits = lits -- facts
+        val newF =
+          if (newLits.isEmpty) (True: Formula)
+          else (And(newLits): Formula)
+        Some(newF) // 1.
+      }
+    case True => Some(True)
+    case lit: Literal => // define in terms of And
+      substitute(And(Set(lit)), facts)
+  }
+}
diff --git a/internal/util-logic/src/test/scala/sbt/logic/Test.scala b/internal/util-logic/src/test/scala/sbt/logic/Test.scala
new file mode 100644
index 000000000..1a2046381
--- /dev/null
+++ b/internal/util-logic/src/test/scala/sbt/logic/Test.scala
@@ -0,0 +1,128 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+package logic
+
+import org.scalacheck._
+import Prop.secure
+import Logic.{ LogicException, Matched }
+
+object LogicTest extends Properties("Logic") {
+  import TestClauses._
+
+  property("Handles trivial resolution.") = secure(expect(trivial, Set(A)))
+  property("Handles less trivial resolution.") = secure(expect(lessTrivial, Set(B, A, D)))
+  property("Handles cycles without negation") = secure(expect(cycles, Set(F, A, B)))
+  property("Handles basic exclusion.") = secure(expect(excludedPos, Set()))
+  property("Handles exclusion of head proved by negation.") = secure(expect(excludedNeg, Set()))
+  // TODO: actually check ordering, probably as part of a check that dependencies are satisfied
+  property("Properly orders results.") = secure(expect(ordering, Set(B, A, C, E, F)))
+
+  /*
+  property("Detects cyclic negation") = secure(
+    Logic.reduceAll(badClauses, Set()) match {
+      case Right(_)                      => false
+      case Left(_: Logic.CyclicNegation) => true
+      case Left(err)                     => sys.error(s"Expected cyclic error, got: $err")
+    }
+  )
+   */
+
+  def expect(result: Either[LogicException, Matched], expected: Set[Atom]) = result match {
+    case Left(_) => false
+    case Right(res) =>
+      val actual = res.provenSet
+      if (actual != expected)
+        sys.error(s"Expected to prove $expected, but actually proved $actual")
+      else
+        true
+  }
+}
+
+object TestClauses {
+
+  val A = Atom("A")
+  val B = Atom("B")
+  val C = Atom("C")
+  val D = Atom("D")
+  val E = Atom("E")
+  val F = Atom("F")
+  val G = Atom("G")
+
+  val clauses =
+    A.proves(B) ::
+      A.proves(F) ::
+      B.proves(F) ::
+      F.proves(A) ::
+      (!C).proves(F) ::
+      D.proves(C) ::
+      C.proves(D) ::
+      Nil
+
+  val cycles = Logic.reduceAll(clauses, Set())
+
+  val badClauses =
+    A.proves(D) ::
+      clauses
+
+  val excludedNeg = {
+    val cs =
+      (!A).proves(B) ::
+        Nil
+    val init =
+      (!A) ::
+        (!B) ::
+        Nil
+    Logic.reduceAll(cs, init.toSet)
+  }
+
+  val excludedPos = {
+    val cs =
+      A.proves(B) ::
+        Nil
+    val init =
+      A ::
+        (!B) ::
+        Nil
+    Logic.reduceAll(cs, init.toSet)
+  }
+
+  val trivial = {
+    val cs =
+      Formula.True.proves(A) ::
+        Nil
+    Logic.reduceAll(cs, Set.empty)
+  }
+
+  val lessTrivial = {
+    val cs =
+      Formula.True.proves(A) ::
+        Formula.True.proves(B) ::
+        (A && B && (!C)).proves(D) ::
+        Nil
+    Logic.reduceAll(cs, Set())
+  }
+
+  val ordering = {
+    val cs =
+      E.proves(F) ::
+        (C && !D).proves(E) ::
+        (A && B).proves(C) ::
+        Nil
+    Logic.reduceAll(cs, Set(A, B))
+  }
+
+  def all(): Unit = {
+    println(s"Cycles: $cycles")
+    println(s"xNeg: $excludedNeg")
+    println(s"xPos: $excludedPos")
+    println(s"trivial: $trivial")
+    println(s"lessTrivial: $lessTrivial")
+    println(s"ordering: $ordering")
+  }
+}
diff --git a/internal/util-position/src/main/scala/sbt/internal/util/Positions.scala b/internal/util-position/src/main/scala/sbt/internal/util/Positions.scala
new file mode 100644
index 000000000..c3895a4bd
--- /dev/null
+++ b/internal/util-position/src/main/scala/sbt/internal/util/Positions.scala
@@ -0,0 +1,74 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import scala.language.experimental.macros
+
+sealed trait SourcePosition
+
+sealed trait FilePosition extends SourcePosition {
+  def path: String
+  def startLine: Int
+}
+
+case object NoPosition extends SourcePosition
+
+final case class LinePosition(path: String, startLine: Int) extends FilePosition
+
+final case class LineRange(start: Int, end: Int) {
+  def shift(n: Int) = new LineRange(start + n, end + n)
+}
+
+final case class RangePosition(path: String, range: LineRange) extends FilePosition {
+  def startLine = range.start
+}
+
+object SourcePosition {
+
+  /** Creates a SourcePosition by using the enclosing position of the invocation of this method.
+   * @return SourcePosition
+   */
+  def fromEnclosing(): SourcePosition = macro SourcePositionMacro.fromEnclosingImpl
+
+}
+
+import scala.annotation.tailrec
+import scala.reflect.macros.blackbox
+import scala.reflect.internal.util.UndefinedPosition
+
+final class SourcePositionMacro(val c: blackbox.Context) {
+  import c.universe.{ NoPosition => _, _ }
+
+  def fromEnclosingImpl(): Expr[SourcePosition] = {
+    val pos = c.enclosingPosition
+    if (!pos.isInstanceOf[UndefinedPosition] && pos.line >= 0 && pos.source != null) {
+      val f = pos.source.file
+      val name = constant[String](ownerSource(f.path, f.name))
+      val line = constant[Int](pos.line)
+      reify { LinePosition(name.splice, line.splice) }
+    } else
+      reify { NoPosition }
+  }
+
+  private[this] def ownerSource(path: String, name: String): String = {
+    @tailrec def inEmptyPackage(s: Symbol): Boolean =
+      s != NoSymbol && (
+        s.owner == c.mirror.EmptyPackage
+          || s.owner == c.mirror.EmptyPackageClass
+          || inEmptyPackage(s.owner)
+      )
+
+    c.internal.enclosingOwner match {
+      case ec if !ec.isStatic       => name
+      case ec if inEmptyPackage(ec) => path
+      case ec                       => s"(${ec.fullName}) $name"
+    }
+  }
+
+  private[this] def constant[T: WeakTypeTag](t: T): Expr[T] = c.Expr[T](Literal(Constant(t)))
+}
diff --git a/internal/util-position/src/test/scala/sbt/internal/util/SourcePositionSpec.scala b/internal/util-position/src/test/scala/sbt/internal/util/SourcePositionSpec.scala
new file mode 100644
index 000000000..93ed9fb96
--- /dev/null
+++ b/internal/util-position/src/test/scala/sbt/internal/util/SourcePositionSpec.scala
@@ -0,0 +1,25 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalatest._
+
+class SourcePositionSpec extends FlatSpec {
+  "SourcePosition()" should "return a sane SourcePosition" in {
+    val filename = "SourcePositionSpec.scala"
+    val lineNumber = 16
+    SourcePosition.fromEnclosing() match {
+      case LinePosition(path, startLine) => assert(path === filename && startLine === lineNumber)
+      case RangePosition(path, range)    => assert(path === filename && inRange(range, lineNumber))
+      case NoPosition                    => fail("No source position found")
+    }
+  }
+
+  private def inRange(range: LineRange, lineNo: Int) =
+    range.start until range.end contains lineNo
+}
diff --git a/internal/util-relation/src/main/scala/sbt/internal/util/Relation.scala b/internal/util-relation/src/main/scala/sbt/internal/util/Relation.scala
new file mode 100644
index 000000000..befdba41c
--- /dev/null
+++ b/internal/util-relation/src/main/scala/sbt/internal/util/Relation.scala
@@ -0,0 +1,206 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import Relation._
+
+object Relation {
+
+  /** Constructs a new immutable, finite relation that is initially empty. */
+  def empty[A, B]: Relation[A, B] = make(Map.empty, Map.empty)
+
+  /**
+   * Constructs a [[Relation]] from underlying `forward` and `reverse` representations, without checking that they are consistent.
+   * This is a low-level constructor and the alternatives [[empty]] and [[reconstruct]] should be preferred.
+   */
+  def make[A, B](forward: Map[A, Set[B]], reverse: Map[B, Set[A]]): Relation[A, B] =
+    new MRelation(forward, reverse)
+
+  /** Constructs a relation such that for every entry `_1 -> _2s` in `forward` and every `_2` in `_2s`, `(_1, _2)` is in the relation. */
+  def reconstruct[A, B](forward: Map[A, Set[B]]): Relation[A, B] = {
+    val reversePairs = for ((a, bs) <- forward.view; b <- bs.view) yield (b, a)
+    val reverse = reversePairs.foldLeft(Map.empty[B, Set[A]]) {
+      case (m, (b, a)) => add(m, b, a :: Nil)
+    }
+    make(forward filter { case (a, bs) => bs.nonEmpty }, reverse)
+  }
+
+  def merge[A, B](rels: Traversable[Relation[A, B]]): Relation[A, B] =
+    rels.foldLeft(Relation.empty[A, B])(_ ++ _)
+
+  private[sbt] def remove[X, Y](map: M[X, Y], from: X, to: Y): M[X, Y] =
+    map.get(from) match {
+      case Some(tos) =>
+        val newSet = tos - to
+        if (newSet.isEmpty) map - from else map.updated(from, newSet)
+      case None => map
+    }
+
+  private[sbt] def combine[X, Y](a: M[X, Y], b: M[X, Y]): M[X, Y] =
+    b.foldLeft(a)((map, mapping) => add(map, mapping._1, mapping._2))
+
+  private[sbt] def add[X, Y](map: M[X, Y], from: X, to: Traversable[Y]): M[X, Y] =
+    map.updated(from, get(map, from) ++ to)
+
+  private[sbt] def get[X, Y](map: M[X, Y], t: X): Set[Y] = map.getOrElse(t, Set.empty[Y])
+
+  private[sbt] type M[X, Y] = Map[X, Set[Y]]
+}
+
+/** Binary relation between A and B.  It is a set of pairs (_1, _2) for _1 in A, _2 in B.  */
+trait Relation[A, B] {
+
+  /** Returns the set of all `_2`s such that `(_1, _2)` is in this relation. */
+  def forward(_1: A): Set[B]
+
+  /** Returns the set of all `_1`s such that `(_1, _2)` is in this relation. */
+  def reverse(_2: B): Set[A]
+
+  /** Includes `pair` in the relation. */
+  def +(pair: (A, B)): Relation[A, B]
+
+  /** Includes `(a, b)` in the relation. */
+  def +(a: A, b: B): Relation[A, B]
+
+  /** Includes in the relation `(a, b)` for all `b` in `bs`. */
+  def +(a: A, bs: Traversable[B]): Relation[A, B]
+
+  /** Returns the union of the relation `r` with this relation. */
+  def ++(r: Relation[A, B]): Relation[A, B]
+
+  /** Includes the given pairs in this relation. */
+  def ++(rs: Traversable[(A, B)]): Relation[A, B]
+
+  /** Removes all elements `(_1, _2)` for all `_1` in `_1s` from this relation. */
+  def --(_1s: Traversable[A]): Relation[A, B]
+
+  /** Removes all `pairs` from this relation. */
+  def --(pairs: TraversableOnce[(A, B)]): Relation[A, B]
+
+  /** Removes all `relations` from this relation. */
+  def --(relations: Relation[A, B]): Relation[A, B]
+
+  /** Removes all pairs `(_1, _2)` from this relation. */
+  def -(_1: A): Relation[A, B]
+
+  /** Removes `pair` from this relation. */
+  def -(pair: (A, B)): Relation[A, B]
+
+  /** Returns the set of all `_1`s such that `(_1, _2)` is in this relation. */
+  def _1s: collection.Set[A]
+
+  /** Returns the set of all `_2`s such that `(_1, _2)` is in this relation. */
+  def _2s: collection.Set[B]
+
+  /** Returns the number of pairs in this relation */
+  def size: Int
+
+  /** Returns true iff `(a,b)` is in this relation*/
+  def contains(a: A, b: B): Boolean
+
+  /** Returns a relation with only pairs `(a,b)` for which `f(a,b)` is true.*/
+  def filter(f: (A, B) => Boolean): Relation[A, B]
+
+  /**
+   * Returns a pair of relations: the first contains only pairs `(a,b)` for which `f(a,b)` is true and
+   * the other only pairs `(a,b)` for which `f(a,b)` is false.
+   */
+  def partition(f: (A, B) => Boolean): (Relation[A, B], Relation[A, B])
+
+  /** Partitions this relation into a map of relations according to some discriminator function. */
+  def groupBy[K](discriminator: ((A, B)) => K): Map[K, Relation[A, B]]
+
+  /** Returns all pairs in this relation.*/
+  def all: Traversable[(A, B)]
+
+  /**
+   * Represents this relation as a `Map` from a `_1` to the set of `_2`s such that `(_1, _2)` is in this relation.
+   *
+   * Specifically, there is one entry for each `_1` such that `(_1, _2)` is in this relation for some `_2`.
+   * The value associated with a given `_1` is the set of all `_2`s such that `(_1, _2)` is in this relation.
+   */
+  def forwardMap: Map[A, Set[B]]
+
+  /**
+   * Represents this relation as a `Map` from a `_2` to the set of `_1`s such that `(_1, _2)` is in this relation.
+   *
+   * Specifically, there is one entry for each `_2` such that `(_1, _2)` is in this relation for some `_1`.
+   * The value associated with a given `_2` is the set of all `_1`s such that `(_1, _2)` is in this relation.
+   */
+  def reverseMap: Map[B, Set[A]]
+
+}
+
+// Note that we assume without checking that fwd and rev are consistent.
+private final class MRelation[A, B](fwd: Map[A, Set[B]], rev: Map[B, Set[A]])
+    extends Relation[A, B] {
+  def forwardMap = fwd
+  def reverseMap = rev
+
+  def forward(t: A) = get(fwd, t)
+  def reverse(t: B) = get(rev, t)
+
+  def _1s = fwd.keySet
+  def _2s = rev.keySet
+
+  def size = (fwd.valuesIterator map (_.size)).sum
+
+  def all: Traversable[(A, B)] =
+    fwd.iterator.flatMap { case (a, bs) => bs.iterator.map(b => (a, b)) }.toTraversable
+
+  def +(pair: (A, B)) = this + (pair._1, Set(pair._2))
+  def +(from: A, to: B) = this + (from, to :: Nil)
+  def +(from: A, to: Traversable[B]) =
+    if (to.isEmpty) this
+    else new MRelation(add(fwd, from, to), to.foldLeft(rev)((map, t) => add(map, t, from :: Nil)))
+
+  def ++(rs: Traversable[(A, B)]) = rs.foldLeft(this: Relation[A, B]) { _ + _ }
+  def ++(other: Relation[A, B]) =
+    new MRelation[A, B](combine(fwd, other.forwardMap), combine(rev, other.reverseMap))
+
+  def --(ts: Traversable[A]): Relation[A, B] = ts.foldLeft(this: Relation[A, B]) { _ - _ }
+  def --(pairs: TraversableOnce[(A, B)]): Relation[A, B] =
+    pairs.foldLeft(this: Relation[A, B])(_ - _)
+  def --(relations: Relation[A, B]): Relation[A, B] = --(relations.all)
+
+  def -(pair: (A, B)): Relation[A, B] =
+    new MRelation(remove(fwd, pair._1, pair._2), remove(rev, pair._2, pair._1))
+
+  def -(t: A): Relation[A, B] =
+    fwd.get(t) match {
+      case Some(rs) =>
+        val upRev = rs.foldLeft(rev)((map, r) => remove(map, r, t))
+        new MRelation(fwd - t, upRev)
+      case None => this
+    }
+
+  def filter(f: (A, B) => Boolean): Relation[A, B] = Relation.empty[A, B] ++ all.filter(f.tupled)
+
+  def partition(f: (A, B) => Boolean): (Relation[A, B], Relation[A, B]) = {
+    val (y, n) = all.partition(f.tupled)
+    (Relation.empty[A, B] ++ y, Relation.empty[A, B] ++ n)
+  }
+
+  def groupBy[K](discriminator: ((A, B)) => K): Map[K, Relation[A, B]] =
+    (all.groupBy(discriminator) mapValues { Relation.empty[A, B] ++ _ }).toMap
+
+  def contains(a: A, b: B): Boolean = forward(a)(b)
+
+  override def equals(other: Any) = other match {
+    // We assume that the forward and reverse maps are consistent, so we only use the forward map
+    // for equality. Note that key -> Empty is semantically the same as key not existing.
+    case o: MRelation[A, B] =>
+      forwardMap.filterNot(_._2.isEmpty) == o.forwardMap.filterNot(_._2.isEmpty)
+    case _ => false
+  }
+
+  override def hashCode = fwd.filterNot(_._2.isEmpty).hashCode()
+
+  override def toString =
+    all.map { case (a, b) => a + " -> " + b }.mkString("Relation [", ", ", "]")
+}
diff --git a/internal/util-relation/src/test/scala/RelationTest.scala b/internal/util-relation/src/test/scala/RelationTest.scala
new file mode 100644
index 000000000..1ee742d73
--- /dev/null
+++ b/internal/util-relation/src/test/scala/RelationTest.scala
@@ -0,0 +1,87 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import org.scalacheck._
+import Prop._
+
+object RelationTest extends Properties("Relation") {
+  property("Added entry check") = forAll { (pairs: List[(Int, Double)]) =>
+    val r = Relation.empty[Int, Double] ++ pairs
+    check(r, pairs)
+  }
+  def check(r: Relation[Int, Double], pairs: Seq[(Int, Double)]) = {
+    val _1s = pairs.map(_._1).toSet
+    val _2s = pairs.map(_._2).toSet
+
+    r._1s == _1s && r.forwardMap.keySet == _1s &&
+    r._2s == _2s && r.reverseMap.keySet == _2s &&
+    pairs.forall {
+      case (a, b) =>
+        (r.forward(a) contains b) &&
+          (r.reverse(b) contains a) &&
+          (r.forwardMap(a) contains b) &&
+          (r.reverseMap(b) contains a)
+    }
+  }
+
+  property("Does not contain removed entries") = forAll { (pairs: List[(Int, Double, Boolean)]) =>
+    val add = pairs.map { case (a, b, c) => (a, b) }
+    val added = Relation.empty[Int, Double] ++ add
+
+    val removeFine = pairs.collect { case (a, b, true) => (a, b) }
+    val removeCoarse = removeFine.map(_._1)
+    val r = added -- removeCoarse
+
+    def notIn[X, Y](map: Map[X, Set[Y]], a: X, b: Y) = map.get(a).forall(set => !(set contains b))
+
+    all(removeCoarse) { rem =>
+      ("_1s does not contain removed" |: (!r._1s.contains(rem))) &&
+      ("Forward does not contain removed" |: r.forward(rem).isEmpty) &&
+      ("Forward map does not contain removed" |: !r.forwardMap.contains(rem)) &&
+      ("Removed is not a value in reverse map" |: !r.reverseMap.values.toSet.contains(rem))
+    } &&
+    all(removeFine) {
+      case (a, b) =>
+        ("Forward does not contain removed" |: (!r.forward(a).contains(b))) &&
+          ("Reverse does not contain removed" |: (!r.reverse(b).contains(a))) &&
+          ("Forward map does not contain removed" |: (notIn(r.forwardMap, a, b))) &&
+          ("Reverse map does not contain removed" |: (notIn(r.reverseMap, b, a)))
+    }
+  }
+
+  property("Groups correctly") = forAll { (entries: List[(Int, Double)], randomInt: Int) =>
+    val splitInto = math.abs(randomInt) % 10 + 1 // Split into 1-10 groups.
+    val rel = Relation.empty[Int, Double] ++ entries
+    val grouped = rel groupBy (_._1 % splitInto)
+    all(grouped.toSeq) {
+      case (k, rel_k) => rel_k._1s forall { _ % splitInto == k }
+    }
+  }
+
+  property("Computes size correctly") = forAll { (entries: List[(Int, Double)]) =>
+    val rel = Relation.empty[Int, Double] ++ entries
+    val expected = rel.all.size // Note: not entries.length, as entries may have duplicates.
+    val computed = rel.size
+    "Expected size: %d. Computed size: %d.".format(expected, computed) |: expected == computed
+  }
+
+  def all[T](s: Seq[T])(p: T => Prop): Prop =
+    if (s.isEmpty) true else s.map(p).reduceLeft(_ && _)
+}
+
+object EmptyRelationTest extends Properties("Empty relation") {
+  lazy val e = Relation.empty[Int, Double]
+
+  property("Forward empty") = forAll((i: Int) => e.forward(i).isEmpty)
+  property("Reverse empty") = forAll((i: Double) => e.reverse(i).isEmpty)
+  property("Forward map empty") = e.forwardMap.isEmpty
+  property("Reverse map empty") = e.reverseMap.isEmpty
+  property("_1 empty") = e._1s.isEmpty
+  property("_2 empty") = e._2s.isEmpty
+}
diff --git a/internal/util-scripted/src/main/java/sbt/internal/scripted/ScriptConfig.java b/internal/util-scripted/src/main/java/sbt/internal/scripted/ScriptConfig.java
new file mode 100644
index 000000000..39216d3ae
--- /dev/null
+++ b/internal/util-scripted/src/main/java/sbt/internal/scripted/ScriptConfig.java
@@ -0,0 +1,37 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.scripted;
+
+import java.io.File;
+
+import xsbti.Logger;
+
+public class ScriptConfig {
+
+  private String label;
+  private File testDirectory;
+  private Logger logger;
+
+  public ScriptConfig(String label, File testDirectory, Logger logger) {
+    this.label = label;
+    this.testDirectory = testDirectory;
+    this.logger = logger;
+  }
+
+  public String label() {
+    return this.label;
+  }
+
+  public File testDirectory() {
+    return this.testDirectory;
+  }
+
+  public Logger logger() {
+    return this.logger;
+  }
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/CommentHandler.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/CommentHandler.scala
new file mode 100644
index 000000000..7b78f82e3
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/CommentHandler.scala
@@ -0,0 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package scripted
+
+object CommentHandler extends BasicStatementHandler {
+  def apply(command: String, args: List[String]) = ()
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/FileCommands.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FileCommands.scala
new file mode 100644
index 000000000..d9e7a1d42
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FileCommands.scala
@@ -0,0 +1,150 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package scripted
+
+import java.io.File
+import sbt.io.{ IO, Path }
+import sbt.io.syntax._
+import Path._
+import sbt.io.IO
+
+class FileCommands(baseDirectory: File) extends BasicStatementHandler {
+  lazy val commands = commandMap
+  def commandMap =
+    Map(
+      "touch" nonEmpty touch _,
+      "delete" nonEmpty delete _,
+      "exists" nonEmpty exists _,
+      "mkdir" nonEmpty makeDirectories _,
+      "absent" nonEmpty absent _,
+      //			"sync" twoArg("Two directory paths", sync _),
+      "newer" twoArg ("Two paths", newer _),
+      "pause" noArg {
+        println("Pausing in " + baseDirectory)
+        /*readLine("Press enter to continue. ") */
+        print("Press enter to continue. ")
+        System.console.readLine
+        println()
+      },
+      "sleep" oneArg ("Time in milliseconds", time => Thread.sleep(time.toLong)),
+      "exec" nonEmpty (execute _),
+      "copy" copy (to => rebase(baseDirectory, to)),
+      "copy-file" twoArg ("Two paths", copyFile _),
+      "must-mirror" twoArg ("Two paths", diffFiles _),
+      "copy-flat" copy flat
+    )
+
+  def apply(command: String, arguments: List[String]): Unit =
+    commands.get(command).map(_(arguments)) match {
+      case Some(_) => ()
+      case _       => scriptError("Unknown command " + command); ()
+    }
+
+  def scriptError(message: String): Unit = sys.error("Test script error: " + message)
+  def spaced[T](l: Seq[T]) = l.mkString(" ")
+  def fromStrings(paths: List[String]) = paths.map(fromString)
+  def fromString(path: String) = new File(baseDirectory, path)
+  def touch(paths: List[String]): Unit = IO.touch(fromStrings(paths))
+  def delete(paths: List[String]): Unit = IO.delete(fromStrings(paths))
+  /*def sync(from: String, to: String) =
+		IO.sync(fromString(from), fromString(to), log)*/
+  def copyFile(from: String, to: String): Unit =
+    IO.copyFile(fromString(from), fromString(to))
+  def makeDirectories(paths: List[String]) =
+    IO.createDirectories(fromStrings(paths))
+  def diffFiles(file1: String, file2: String): Unit = {
+    val lines1 = IO.readLines(fromString(file1))
+    val lines2 = IO.readLines(fromString(file2))
+    if (lines1 != lines2)
+      scriptError(
+        "File contents are different:\n" + lines1.mkString("\n") +
+          "\nAnd:\n" + lines2.mkString("\n")
+      )
+  }
+
+  def newer(a: String, b: String): Unit = {
+    val pathA = fromString(a)
+    val pathB = fromString(b)
+    val isNewer = pathA.exists &&
+      (!pathB.exists || IO.getModifiedTimeOrZero(pathA) > IO.getModifiedTimeOrZero(pathB))
+    if (!isNewer) {
+      scriptError(s"$pathA is not newer than $pathB")
+    }
+  }
+  def exists(paths: List[String]): Unit = {
+    val notPresent = fromStrings(paths).filter(!_.exists)
+    if (notPresent.nonEmpty)
+      scriptError("File(s) did not exist: " + notPresent.mkString("[ ", " , ", " ]"))
+  }
+  def absent(paths: List[String]): Unit = {
+    val present = fromStrings(paths).filter(_.exists)
+    if (present.nonEmpty)
+      scriptError("File(s) existed: " + present.mkString("[ ", " , ", " ]"))
+  }
+  def execute(command: List[String]): Unit = execute0(command.head, command.tail)
+  def execute0(command: String, args: List[String]): Unit = {
+    if (command.trim.isEmpty)
+      scriptError("Command was empty.")
+    else {
+      val exitValue = sys.process.Process(command :: args, baseDirectory).!
+      if (exitValue != 0)
+        sys.error("Nonzero exit value (" + exitValue + ")")
+    }
+  }
+
+  // these are for readability of the command list
+  implicit def commandBuilder(s: String): CommandBuilder = new CommandBuilder(s)
+  final class CommandBuilder(commandName: String) {
+    type NamedCommand = (String, List[String] => Unit)
+    def nonEmpty(action: List[String] => Unit): NamedCommand =
+      commandName -> { paths =>
+        if (paths.isEmpty)
+          scriptError("No arguments specified for " + commandName + " command.")
+        else
+          action(paths)
+      }
+    def twoArg(requiredArgs: String, action: (String, String) => Unit): NamedCommand =
+      commandName -> {
+        case List(from, to) => action(from, to)
+        case other          => wrongArguments(requiredArgs, other)
+      }
+    def noArg(action: => Unit): NamedCommand =
+      commandName -> {
+        case Nil   => action
+        case other => wrongArguments(other)
+      }
+    def oneArg(requiredArgs: String, action: String => Unit): NamedCommand =
+      commandName -> {
+        case List(single) => action(single)
+        case other        => wrongArguments(requiredArgs, other)
+      }
+    def copy(mapper: File => FileMap): NamedCommand =
+      commandName -> {
+        case Nil         => scriptError("No paths specified for " + commandName + " command.")
+        case path :: Nil => scriptError("No destination specified for " + commandName + " command.")
+        case paths =>
+          val mapped = fromStrings(paths)
+          val map = mapper(mapped.last)
+          IO.copy(mapped.init pair map)
+          ()
+      }
+
+    def wrongArguments(args: List[String]): Unit =
+      scriptError(
+        "Command '" + commandName + "' does not accept arguments (found '" + spaced(args) + "')."
+      )
+
+    def wrongArguments(requiredArgs: String, args: List[String]): Unit =
+      scriptError(
+        "Wrong number of arguments to " + commandName + " command.  " +
+          requiredArgs + " required, found: '" + spaced(args) + "'."
+      )
+  }
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/FilteredLoader.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FilteredLoader.scala
new file mode 100644
index 000000000..8c980eb97
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/FilteredLoader.scala
@@ -0,0 +1,22 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package scripted
+
+final class FilteredLoader(parent: ClassLoader) extends ClassLoader(parent) {
+  @throws(classOf[ClassNotFoundException])
+  override final def loadClass(className: String, resolve: Boolean): Class[_] = {
+    if (className.startsWith("java.") || className.startsWith("javax."))
+      super.loadClass(className, resolve)
+    else
+      throw new ClassNotFoundException(className)
+  }
+  override def getResources(name: String) = null
+  override def getResource(name: String) = null
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/HandlersProvider.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/HandlersProvider.scala
new file mode 100644
index 000000000..f6bfe1c20
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/HandlersProvider.scala
@@ -0,0 +1,12 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.scripted
+
+trait HandlersProvider {
+  def getHandlers(config: ScriptConfig): Map[Char, StatementHandler]
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptRunner.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptRunner.scala
new file mode 100644
index 000000000..9bcbe25ee
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptRunner.scala
@@ -0,0 +1,57 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package scripted
+
+final class TestException(statement: Statement, msg: String, exception: Throwable)
+    extends RuntimeException(statement.linePrefix + " " + msg, exception)
+
+class ScriptRunner {
+  import scala.collection.mutable.HashMap
+  def apply(statements: List[(StatementHandler, Statement)]): Unit = {
+    val states = new HashMap[StatementHandler, Any]
+    def processStatement(handler: StatementHandler, statement: Statement): Unit = {
+      val state = states(handler).asInstanceOf[handler.State]
+      val nextState =
+        try {
+          Right(handler(statement.command, statement.arguments, state))
+        } catch {
+          case e: Exception => Left(e)
+        }
+      nextState match {
+        case Left(err) =>
+          if (statement.successExpected) {
+            err match {
+              case t: TestFailed =>
+                throw new TestException(statement, "Command failed: " + t.getMessage, null)
+              case _ => throw new TestException(statement, "Command failed", err)
+            }
+          } else
+            ()
+        case Right(s) =>
+          if (statement.successExpected)
+            states(handler) = s
+          else
+            throw new TestException(statement, "Command succeeded but failure was expected", null)
+      }
+    }
+    val handlers = Set() ++ statements.map(_._1)
+
+    try {
+      handlers.foreach(handler => states(handler) = handler.initialState)
+      statements foreach (Function.tupled(processStatement))
+    } finally {
+      for (handler <- handlers; state <- states.get(handler)) {
+        try {
+          handler.finish(state.asInstanceOf[handler.State])
+        } catch { case e: Exception => () }
+      }
+    }
+  }
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala
new file mode 100644
index 000000000..ffdd4e685
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala
@@ -0,0 +1,235 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package scripted
+
+import java.io.File
+import sbt.util.{ Logger, LoggerContext, Level }
+import sbt.internal.util.{ Appender, ManagedLogger, ConsoleAppender, BufferedAppender }
+import sbt.io.IO.wrapNull
+import sbt.io.{ DirectoryFilter, HiddenFileFilter }
+import sbt.io.syntax._
+import sbt.internal.io.Resources
+import java.util.concurrent.atomic.AtomicInteger
+
+object ScriptedRunnerImpl {
+  def run(
+      resourceBaseDirectory: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      handlersProvider: HandlersProvider
+  ): Unit = {
+    val context =
+      LoggerContext(useLog4J = System.getProperty("sbt.log.uselog4j", "false") == "true")
+    val runner = new ScriptedTests(resourceBaseDirectory, bufferLog, handlersProvider)
+    val logger = newLogger(context)
+    val allTests = get(tests, resourceBaseDirectory, logger) flatMap {
+      case ScriptedTest(group, name) =>
+        runner.scriptedTest(group, name, logger, context)
+    }
+    runAll(allTests)
+  }
+  def runAll(tests: Seq[() => Option[String]]): Unit = {
+    val errors = for (test <- tests; err <- test()) yield err
+    if (errors.nonEmpty)
+      sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n"))
+  }
+  def get(tests: Seq[String], baseDirectory: File, log: ManagedLogger): Seq[ScriptedTest] =
+    if (tests.isEmpty) listTests(baseDirectory, log) else parseTests(tests)
+  def listTests(baseDirectory: File, log: ManagedLogger): Seq[ScriptedTest] =
+    (new ListTests(baseDirectory, _ => true, log)).listTests
+  def parseTests(in: Seq[String]): Seq[ScriptedTest] =
+    for (testString <- in) yield {
+      val Array(group, name) = testString.split("/").map(_.trim)
+      ScriptedTest(group, name)
+    }
+  private[sbt] val generateId: AtomicInteger = new AtomicInteger
+  private[sbt] def newLogger(context: LoggerContext): ManagedLogger = {
+    val loggerName = "scripted-" + generateId.incrementAndGet
+    context.logger(loggerName, None, None)
+  }
+}
+
+final class ScriptedTests(
+    resourceBaseDirectory: File,
+    bufferLog: Boolean,
+    handlersProvider: HandlersProvider,
+    stripQuotes: Boolean
+) {
+  def this(resourceBaseDirectory: File, bufferLog: Boolean, handlersProvider: HandlersProvider) =
+    this(resourceBaseDirectory, bufferLog, handlersProvider, true)
+  private val testResources = new Resources(resourceBaseDirectory)
+  private val appender: Appender = ConsoleAppender()
+
+  val ScriptFilename = "test"
+  val PendingScriptFilename = "pending"
+
+  def scriptedTest(group: String, name: String, log: xsbti.Logger): Seq[() => Option[String]] =
+    scriptedTest(group, name, Logger.xlog2Log(log))
+
+  @deprecated("Use scriptedTest that takes a LoggerContext", "1.4.0")
+  def scriptedTest(
+      group: String,
+      name: String,
+      log: ManagedLogger,
+  ): Seq[() => Option[String]] =
+    scriptedTest(group, name, (_ => ()), log, LoggerContext.globalContext)
+  def scriptedTest(
+      group: String,
+      name: String,
+      log: ManagedLogger,
+      context: LoggerContext
+  ): Seq[() => Option[String]] =
+    scriptedTest(group, name, (_ => ()), log, context)
+
+  @deprecated("Use scriptedTest that provides LoggerContext", "1.4.0")
+  def scriptedTest(
+      group: String,
+      name: String,
+      prescripted: File => Unit,
+      log: ManagedLogger,
+  ): Seq[() => Option[String]] =
+    scriptedTest(group, name, prescripted, log, LoggerContext.globalContext)
+  def scriptedTest(
+      group: String,
+      name: String,
+      prescripted: File => Unit,
+      log: ManagedLogger,
+      context: LoggerContext,
+  ): Seq[() => Option[String]] = {
+    for (groupDir <- (resourceBaseDirectory * group).get; nme <- (groupDir * name).get) yield {
+      val g = groupDir.getName
+      val n = nme.getName
+      val str = s"$g / $n"
+      () => {
+        println("Running " + str)
+        testResources.readWriteResourceDirectory(g, n) { testDirectory =>
+          val disabled = new File(testDirectory, "disabled").isFile
+          if (disabled) {
+            log.info("D " + str + " [DISABLED]")
+            None
+          } else {
+            try {
+              scriptedTest(str, testDirectory, prescripted, log, context); None
+            } catch {
+              case _: TestException | _: PendingTestSuccessException => Some(str)
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private def scriptedTest(
+      label: String,
+      testDirectory: File,
+      prescripted: File => Unit,
+      log: ManagedLogger,
+      context: LoggerContext,
+  ): Unit = {
+    val buffered = BufferedAppender(appender)
+    context.clearAppenders(log.name)
+    context.addAppender(log.name, (buffered -> Level.Debug))
+    if (bufferLog) {
+      buffered.record()
+    }
+    def createParser() = {
+      // val fileHandler = new FileCommands(testDirectory)
+      // // val sbtHandler = new SbtHandler(testDirectory, launcher, buffered, launchOpts)
+      // new TestScriptParser(Map('$' -> fileHandler, /* '>' -> sbtHandler, */ '#' -> CommentHandler))
+      val scriptConfig = new ScriptConfig(label, testDirectory, log)
+      new TestScriptParser(handlersProvider getHandlers scriptConfig)
+    }
+    val (file, pending) = {
+      val normal = new File(testDirectory, ScriptFilename)
+      val pending = new File(testDirectory, PendingScriptFilename)
+      if (pending.isFile) (pending, true) else (normal, false)
+    }
+    val pendingString = if (pending) " [PENDING]" else ""
+
+    def runTest(): Unit = {
+      val run = new ScriptRunner
+      val parser = createParser()
+      run(parser.parse(file, stripQuotes))
+    }
+    def testFailed(): Unit = {
+      if (pending) buffered.clearBuffer() else buffered.stopBuffer()
+      log.error("x " + label + pendingString)
+    }
+
+    try {
+      prescripted(testDirectory)
+      runTest()
+      log.info("+ " + label + pendingString)
+      if (pending) throw new PendingTestSuccessException(label)
+    } catch {
+      case e: TestException =>
+        testFailed()
+        e.getCause match {
+          case null | _: java.net.SocketException => log.error("   " + e.getMessage)
+          case _                                  => if (!pending) e.printStackTrace
+        }
+        if (!pending) throw e
+      case e: PendingTestSuccessException =>
+        testFailed()
+        log.error("  Mark as passing to remove this failure.")
+        throw e
+      case e: Exception =>
+        testFailed()
+        if (!pending) throw e
+    } finally {
+      buffered.clearBuffer()
+    }
+  }
+}
+
+// object ScriptedTests extends ScriptedRunner {
+//   val emptyCallback: File => Unit = { _ => () }
+// }
+
+final case class ScriptedTest(group: String, name: String) {
+  override def toString = group + "/" + name
+}
+
+object ListTests {
+  def list(directory: File, filter: java.io.FileFilter) = wrapNull(directory.listFiles(filter))
+}
+import ListTests._
+final class ListTests(baseDirectory: File, accept: ScriptedTest => Boolean, log: Logger) {
+  def filter = DirectoryFilter -- HiddenFileFilter
+  def listTests: Seq[ScriptedTest] = {
+    list(baseDirectory, filter) flatMap { group =>
+      val groupName = group.getName
+      listTests(group).map(ScriptedTest(groupName, _))
+    }
+  }
+  private[this] def listTests(group: File): Seq[String] = {
+    val groupName = group.getName
+    val allTests = list(group, filter).sortBy(_.getName)
+    if (allTests.isEmpty) {
+      log.warn("No tests in test group " + groupName)
+      Seq.empty
+    } else {
+      val (included, skipped) =
+        allTests.toList.partition(test => accept(ScriptedTest(groupName, test.getName)))
+      if (included.isEmpty)
+        log.warn("Test group " + groupName + " skipped.")
+      else if (skipped.nonEmpty) {
+        log.warn("Tests skipped in group " + group.getName + ":")
+        skipped.foreach(testName => log.warn(" " + testName.getName))
+      }
+      Seq(included.map(_.getName): _*)
+    }
+  }
+}
+
+class PendingTestSuccessException(label: String) extends Exception {
+  override def getMessage: String =
+    s"The pending test $label succeeded. Mark this test as passing to remove this failure."
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/StatementHandler.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/StatementHandler.scala
new file mode 100644
index 000000000..56a2bfc44
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/StatementHandler.scala
@@ -0,0 +1,33 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package scripted
+
+trait StatementHandler {
+  type State
+  def initialState: State
+  def apply(command: String, arguments: List[String], state: State): State
+  def finish(state: State): Unit
+}
+
+trait BasicStatementHandler extends StatementHandler {
+  final type State = Unit
+  final def initialState = ()
+
+  final def apply(command: String, arguments: List[String], state: Unit): Unit =
+    apply(command, arguments)
+
+  def apply(command: String, arguments: List[String]): Unit
+  def finish(state: Unit) = ()
+}
+
+/** Use when a stack trace is not useful */
+final class TestFailed(msg: String) extends RuntimeException(msg) {
+  override def fillInStackTrace = this
+}
diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/TestScriptParser.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/TestScriptParser.scala
new file mode 100644
index 000000000..9d2548059
--- /dev/null
+++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/TestScriptParser.scala
@@ -0,0 +1,118 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package scripted
+
+import java.io.File
+import scala.util.parsing.combinator._
+import scala.util.parsing.input.Positional
+import Character.isWhitespace
+import sbt.io.IO
+
+/*
+statement*
+statement ::= startChar successChar word+ nl
+startChar ::= <single character>
+successChar ::= '+' | '-'
+word ::= [^ \[\]]+
+comment ::= '#' \S* nl
+nl ::= '\r' \'n' | '\n' | '\r' | eof
+ */
+final case class Statement(
+    command: String,
+    arguments: List[String],
+    successExpected: Boolean,
+    line: Int
+) {
+  def linePrefix = "{line " + line + "} "
+}
+
+private object TestScriptParser {
+  val SuccessLiteral = "success"
+  val FailureLiteral = "failure"
+  val WordRegex = """[^ \[\]\s'\"][^ \[\]\s]*""".r
+}
+
+import TestScriptParser._
+class TestScriptParser(handlers: Map[Char, StatementHandler]) extends RegexParsers {
+  require(handlers.nonEmpty)
+  override def skipWhitespace = false
+
+  import IO.read
+  if (handlers.keys.exists(isWhitespace))
+    sys.error("Start characters cannot be whitespace")
+  if (handlers.keys.exists(key => key == '+' || key == '-'))
+    sys.error("Start characters cannot be '+' or '-'")
+
+  @deprecated("Use variant that specifies whether to strip quotes or not", "1.4.0")
+  def parse(scriptFile: File): List[(StatementHandler, Statement)] =
+    parse(scriptFile, stripQuotes = true)
+  def parse(scriptFile: File, stripQuotes: Boolean): List[(StatementHandler, Statement)] =
+    parse(read(scriptFile), Some(scriptFile.getAbsolutePath), stripQuotes)
+  @deprecated("Use variant that specifies whether to strip quotes or not", "1.4.0")
+  def parse(script: String): List[(StatementHandler, Statement)] =
+    parse(script, None, stripQuotes = true)
+  def parse(script: String, stripQuotes: Boolean): List[(StatementHandler, Statement)] =
+    parse(script, None, stripQuotes)
+  private def parse(
+      script: String,
+      label: Option[String],
+      stripQuotes: Boolean
+  ): List[(StatementHandler, Statement)] = {
+    parseAll(statements(stripQuotes), script) match {
+      case Success(result, next) => result
+      case err: NoSuccess => {
+        val labelString = label.map("'" + _ + "' ").getOrElse("")
+        sys.error("Could not parse test script, " + labelString + err.toString)
+      }
+    }
+  }
+
+  @deprecated("Use variant that specifies whether to strip quotes or not", "1.4.0")
+  lazy val statements = rep1(space ~> statement <~ newline)
+  def statements(stripQuotes: Boolean): Parser[List[(StatementHandler, Statement)]] =
+    rep1(space ~> statement(stripQuotes) <~ newline)
+
+  @deprecated("Use variant that specifies whether to strip quotes or not", "1.4.0")
+  def statement: Parser[(StatementHandler, Statement)] = statement(stripQuotes = true)
+  def statement(stripQuotes: Boolean): Parser[(StatementHandler, Statement)] = {
+    trait PositionalStatement extends Positional {
+      def tuple: (StatementHandler, Statement)
+    }
+    positioned {
+      val w = if (stripQuotes) word else rawWord
+      val command = w | err("expected command")
+      val arguments = rep(space ~> w | failure("expected argument"))
+      (successParser ~ (space ~> startCharacterParser <~ space) ~! command ~! arguments) ^^ {
+        case successExpected ~ start ~ command ~ arguments =>
+          new PositionalStatement {
+            def tuple =
+              (handlers(start), new Statement(command, arguments, successExpected, pos.line))
+          }
+      }
+    } ^^ (_.tuple)
+  }
+
+  def successParser: Parser[Boolean] = ('+' ^^^ true) | ('-' ^^^ false) | success(true)
+  def space: Parser[String] = """[ \t]*""".r
+
+  lazy val word: Parser[String] =
+    ("\'" ~> "[^'\n\r]*".r <~ "\'") | "\"" ~> "[^\"\n\r]*".r <~ "\'" | WordRegex
+  private lazy val rawWord: Parser[String] =
+    ("\'" ~> "[^'\n\r]*".r <~ "\'") | "\"[^\"\n\r]*\"".r | WordRegex
+
+  def startCharacterParser: Parser[Char] =
+    elem("start character", handlers.contains _) |
+      (
+        (newline | err("expected start character " + handlers.keys.mkString("(", "", ")")))
+          ~> failure("end of input")
+      )
+
+  def newline = """\s*([\n\r]|$)""".r
+}
diff --git a/launch/NOTICE b/launch/NOTICE
index d0158f707..8abf4ed53 100644
--- a/launch/NOTICE
+++ b/launch/NOTICE
@@ -1,6 +1,7 @@
-Simple Build Tool Launcher
-Copyright 2008, 2009, 2010  Mark Harrah, David MacIver
-Licensed under BSD-style license (see LICENSE)
+sbt Launcher
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah, David MacIver
+Licensed under BSD-3-Clause license (see LICENSE)
 
 Classes from the Scala library are distributed with the launcher.
 Copyright 2002-2013 EPFL, Lausanne
diff --git a/launch/src/main/input_resources/sbt/sbt.boot.properties b/launch/src/main/input_resources/sbt/sbt.boot.properties
index 0d3a64bb3..f13961dcf 100644
--- a/launch/src/main/input_resources/sbt/sbt.boot.properties
+++ b/launch/src/main/input_resources/sbt/sbt.boot.properties
@@ -12,6 +12,8 @@
 
 [repositories]
   local
+  local-preloaded-ivy: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext]
+  local-preloaded: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}
   maven-central
   sbt-maven-releases: https://repo.scala-sbt.org/scalasbt/maven-releases/, bootOnly
   sbt-maven-snapshots: https://repo.scala-sbt.org/scalasbt/maven-snapshots/, bootOnly
@@ -20,6 +22,7 @@
 
 [boot]
   directory: ${sbt.boot.directory-${sbt.global.base-${user.home}/.sbt}/boot/}
+  lock: ${sbt.boot.lock-true}
 
 [ivy]
   ivy-home: ${sbt.ivy.home-${user.home}/.ivy2/}
diff --git a/main-actions/src/main/scala/sbt/CacheIvy.scala b/main-actions/src/main/scala/sbt/CacheIvy.scala
deleted file mode 100644
index 0e270e192..000000000
--- a/main-actions/src/main/scala/sbt/CacheIvy.scala
+++ /dev/null
@@ -1,231 +0,0 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010  Mark Harrah
- */
-package sbt
-
-import Predef.{ Map, Set, implicitly } // excludes *both 2.10.x conforms and 2.11.x $conforms in source compatible manner.
-
-import sbt.internal.util.{ Cache, HList, HNil, InputCache, LinePosition, LineRange, NoPosition, RangePosition, SourcePosition }
-import sbt.internal.util.FileInfo.{ exists, hash }
-import sbt.internal.util.Types.{ :+:, idFun }
-import java.io.File
-import java.{ util => ju }
-import java.net.URL
-import sbinary.{ DefaultProtocol, Format }
-import sbt.internal.librarymanagement._
-import sbt.librarymanagement._
-import sbt.librarymanagement.RepositoryHelpers._
-import Ordering._
-
-import sbt.io.Hash
-
-/**
- * InputCaches for IvyConfiguration, ModuleSettings, and UpdateConfiguration
- * The InputCaches for a basic data structure is built in two parts.
- * Given the data structure:
- *   Data[A,B,C, ...]
- * 1) Define a conversion from Data to the HList A :+: B :+: C :+: ... :+: HNil,
- *    excluding any members that should not be considered for caching
- * 2) In theory, 1) would be enough and wrapHL would generate InputCache[Data] as long
- *    as all of InputCache[A], InputCache[B], ... exist.  However, if any of these child
- *    InputCaches are constructed using wrapHL, you get a diverging implicit error.  (I
- *    believe scalac is generating this error as specified, but that the implicits would
- *    be valid and not be infinite.  This might take some effort to come up with a new rule
- *    that allows this)
- * 3) So, we need to explicitly define the intermediate implicits.  The general approach is:
- *    {{{
- *      object LN {
- *        ... Data => HList conversions ...
- *      }
- *      import LN._
- *      implicit dataCache: InputCache[Data] = wrapHL
- *
- *      object L(N-1) ...
- *    }}}
- *    Each Data in LN only uses implicits from L(N-1).
- *    This way, higher levels (higher N) cannot see the HList conversions of subcomponents but can
- *    use the explicitly defined subcomponent implicits and there is no divergence.
- * 4) Ideally, diverging implicits could be relaxed so that the ... = wrapIn lines could be removed.
- */
-object CacheIvy {
-  def password(s: Option[String]) = new Array[Byte](0)
-  def names(s: Iterable[Configuration]): Set[String] = s.map(_.name).toSet
-
-  import Cache._
-  implicit def wrapHL[W, H, T <: HList](implicit f: W => H :+: T, cache: InputCache[H :+: T]): InputCache[W] =
-    Cache.wrapIn(f, cache)
-
-  lazy val excludeMap: Format[Map[ModuleID, Set[String]]] = implicitly
-  lazy val updateIC: InputCache[IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil] = implicitly
-  /*	def deliverIC: InputCache[IvyConfiguration :+: ModuleSettings :+: DeliverConfiguration :+: HNil] = implicitly
-	def publishIC: InputCache[IvyConfiguration :+: ModuleSettings :+: PublishConfiguration :+: HNil] = implicitly*/
-  lazy val moduleIDSeqIC: InputCache[Seq[ModuleID]] = implicitly
-  lazy val modulePositionMapFormat: Format[Map[ModuleID, SourcePosition]] = implicitly
-
-  implicit lazy val updateReportFormat: Format[UpdateReport] =
-    {
-      import DefaultProtocol.{ StringFormat, FileFormat }
-      wrap[UpdateReport, (File, Seq[ConfigurationReport], UpdateStats, Map[File, Long])](rep => (rep.cachedDescriptor, rep.configurations, rep.stats, rep.stamps), { case (cd, cs, stats, stamps) => new UpdateReport(cd, cs, stats, stamps) })
-    }
-  implicit def updateStatsFormat: Format[UpdateStats] =
-    wrap[UpdateStats, (Long, Long, Long)](us => (us.resolveTime, us.downloadTime, us.downloadSize), { case (rt, dt, ds) => new UpdateStats(rt, dt, ds, true) })
-  implicit def confReportFormat(implicit m: Format[String], mr: Format[Seq[ModuleReport]], oar: Format[Seq[OrganizationArtifactReport]]): Format[ConfigurationReport] =
-    wrap[ConfigurationReport, (String, Seq[ModuleReport], Seq[OrganizationArtifactReport])](r => (r.configuration, r.modules, r.details), { case (c, m, d) => new ConfigurationReport(c, m, d) })
-  implicit def moduleReportFormat(implicit cf: Format[Seq[Caller]], ff: Format[File]): Format[ModuleReport] = {
-    wrap[ModuleReport, (ModuleID, Seq[(Artifact, File)], Seq[Artifact], Option[String], Option[Long], Option[String], Option[String], Boolean, Option[String], Option[String], Option[String], Option[String], Map[String, String], Option[Boolean], Option[String], Seq[String], Seq[(String, Option[String])], Seq[Caller])](
-      m => (m.module, m.artifacts, m.missingArtifacts, m.status, m.publicationDate map { _.getTime }, m.resolver, m.artifactResolver, m.evicted, m.evictedData, m.evictedReason, m.problem, m.homepage, m.extraAttributes, m.isDefault, m.branch, m.configurations, m.licenses, m.callers),
-      { case (m, as, ms, s, pd, r, a, e, ed, er, p, h, ea, d, b, cs, ls, ks) => new ModuleReport(m, as, ms, s, pd map { new ju.Date(_) }, r, a, e, ed, er, p, h, ea, d, b, cs, ls, ks) })
-  }
-  implicit def artifactFormat(implicit sf: Format[String], uf: Format[Option[URL]]): Format[Artifact] = {
-    wrap[Artifact, (String, String, String, Option[String], Seq[Configuration], Option[URL], Map[String, String])](
-      a => (a.name, a.`type`, a.extension, a.classifier, a.configurations.toSeq, a.url, a.extraAttributes),
-      { case (n, t, x, c, cs, u, e) => Artifact(n, t, x, c, cs, u, e) }
-    )
-  }
-  implicit def organizationArtifactReportFormat(implicit sf: Format[String], bf: Format[Boolean], df: Format[Seq[ModuleReport]]): Format[OrganizationArtifactReport] =
-    wrap[OrganizationArtifactReport, (String, String, Seq[ModuleReport])](m => (m.organization, m.name, m.modules), { case (o, n, r) => OrganizationArtifactReport(o, n, r) })
-  implicit def callerFormat: Format[Caller] =
-    wrap[Caller, (ModuleID, Seq[String], Map[String, String], Boolean, Boolean, Boolean, Boolean)](c => (c.caller, c.callerConfigurations, c.callerExtraAttributes, c.isForceDependency, c.isChangingDependency, c.isTransitiveDependency, c.isDirectlyForceDependency),
-      { case (c, cc, ea, fd, cd, td, df) => new Caller(c, cc, ea, fd, cd, td, df) })
-  implicit def exclusionRuleFormat(implicit sf: Format[String]): Format[InclExclRule] =
-    wrap[InclExclRule, (String, String, String, Seq[String])](e => (e.organization, e.name, e.artifact, e.configurations), { case (o, n, a, cs) => InclExclRule(o, n, a, cs) })
-  implicit def crossVersionFormat: Format[CrossVersion] = wrap(crossToInt, crossFromInt)
-  implicit def sourcePositionFormat: Format[SourcePosition] =
-    wrap[SourcePosition, (Int, String, Int, Int)](
-      {
-        case NoPosition                        => (0, "", 0, 0)
-        case LinePosition(p, s)                => (1, p, s, 0)
-        case RangePosition(p, LineRange(s, e)) => (2, p, s, e)
-      },
-      {
-        case (0, _, _, _) => NoPosition
-        case (1, p, s, _) => LinePosition(p, s)
-        case (2, p, s, e) => RangePosition(p, LineRange(s, e))
-      }
-    )
-  private[this] final val DisabledValue = 0
-  private[this] final val BinaryValue = 1
-  private[this] final val FullValue = 2
-
-  import CrossVersion.{ Binary, Disabled, Full }
-  private[this] val crossFromInt = (i: Int) => i match { case BinaryValue => new Binary(idFun); case FullValue => new Full(idFun); case _ => Disabled }
-  private[this] val crossToInt = (c: CrossVersion) => c match { case Disabled => 0; case b: Binary => BinaryValue; case f: Full => FullValue }
-
-  implicit def moduleIDFormat(implicit sf: Format[String], bf: Format[Boolean]): Format[ModuleID] =
-    wrap[ModuleID, ((String, String, String, Option[String], Option[String]), (Boolean, Boolean, Boolean, Seq[Artifact], Seq[InclusionRule], Seq[ExclusionRule], Map[String, String], CrossVersion))](
-      m => ((m.organization, m.name, m.revision, m.configurations, m.branchName), (m.isChanging, m.isTransitive, m.isForce, m.explicitArtifacts, m.inclusions, m.exclusions, m.extraAttributes, m.crossVersion)),
-      { case ((o, n, r, cs, br), (ch, t, f, as, incl, excl, x, cv)) => ModuleID(o, n, r, cs, ch, t, f, as, incl, excl, x, cv, br) }
-    )
-  // For some reason sbinary seems to detect unserialized instance Set[ModuleID] to be not equal. #1620
-  implicit def moduleSetIC: InputCache[Set[ModuleID]] =
-    {
-      implicit def toSeq(ms: Set[ModuleID]): Seq[ModuleID] = ms.toSeq.sortBy { _.toString }
-      wrapIn
-    }
-
-  implicit def configurationFormat(implicit sf: Format[String]): Format[Configuration] =
-    wrap[Configuration, String](_.name, s => new Configuration(s))
-
-  implicit def classpathFormat =
-    {
-      import DefaultProtocol.FileFormat
-      implicitly[Format[Map[String, Seq[File]]]]
-    }
-
-  object L5 {
-    implicit def inlineIvyToHL = (i: InlineIvyConfiguration) => i.paths :+: i.resolvers :+: i.otherResolvers :+: i.moduleConfigurations :+: i.localOnly :+: i.checksums :+: HNil
-  }
-  import L5._
-
-  implicit def moduleSettingsIC: InputCache[ModuleSettings] =
-    unionInputCache[ModuleSettings, PomConfiguration :+: InlineConfiguration :+: IvyFileConfiguration :+: HNil]
-
-  implicit def ivyConfigurationIC: InputCache[IvyConfiguration] =
-    unionInputCache[IvyConfiguration, InlineIvyConfiguration :+: ExternalIvyConfiguration :+: HNil]
-
-  object L4 {
-    implicit val inlineToHL = (c: InlineConfiguration) =>
-      c.module :+: c.dependencies :+: c.ivyXML :+: c.configurations :+: c.defaultConfiguration.map(_.name) :+:
-        c.ivyScala :+: c.validate :+: c.overrides :+: c.excludes :+: HNil
-    implicit def moduleConfToHL = (m: ModuleConfiguration) => m.organization :+: m.name :+: m.revision :+: m.resolver :+: HNil
-    // implicit def inlineToHL = (c: InlineConfiguration) => c.module :+: c.dependencies :+: c.ivyXML :+: c.configurations :+: c.defaultConfiguration.map(_.name) :+: c.ivyScala :+: c.validate :+: c.overrides :+: HNil
-  }
-  import L4._
-
-  implicit def inlineIC: InputCache[InlineConfiguration] = wrapIn
-  implicit def moduleConfIC: InputCache[ModuleConfiguration] = wrapIn
-
-  object L3 {
-    implicit def mavenCacheToHL = (m: MavenCache) => m.name :+: m.rootFile.getAbsolutePath :+: HNil
-    implicit def mavenRToHL = (m: MavenRepository) => m.name :+: m.root :+: HNil
-    implicit def fileRToHL = (r: FileRepository) => r.name :+: r.configuration :+: r.patterns :+: HNil
-    implicit def urlRToHL = (u: URLRepository) => u.name :+: u.patterns :+: HNil
-    implicit def sshRToHL = (s: SshRepository) => s.name :+: s.connection :+: s.patterns :+: s.publishPermissions :+: HNil
-    implicit def sftpRToHL = (s: SftpRepository) => s.name :+: s.connection :+: s.patterns :+: HNil
-    implicit def rawRToHL = (r: RawRepository) => r.name :+: r.resolver.getClass.getName :+: HNil
-    implicit def chainRToHL = (c: ChainedResolver) => c.name :+: c.resolvers :+: HNil
-    implicit def moduleToHL = (m: ModuleID) => m.organization :+: m.name :+: m.revision :+: m.configurations :+: m.isChanging :+: m.isTransitive :+: m.explicitArtifacts :+: m.exclusions :+: m.inclusions :+: m.extraAttributes :+: m.crossVersion :+: HNil
-  }
-  import L3._
-
-  implicit lazy val chainedIC: InputCache[ChainedResolver] = InputCache.lzy(wrapIn)
-  implicit lazy val resolverIC: InputCache[Resolver] =
-    unionInputCache[Resolver, ChainedResolver :+: MavenRepository :+: MavenCache :+: FileRepository :+: URLRepository :+: SshRepository :+: SftpRepository :+: RawRepository :+: HNil]
-  implicit def moduleIC: InputCache[ModuleID] = wrapIn
-  implicitly[InputCache[Seq[Configuration]]]
-
-  object L2 {
-    implicit def updateConfToHL = (u: UpdateConfiguration) => u.retrieve :+: u.missingOk :+: HNil
-    implicit def pomConfigurationHL = (c: PomConfiguration) => hash(c.file) :+: c.ivyScala :+: c.validate :+: HNil
-    implicit def ivyFileConfigurationHL = (c: IvyFileConfiguration) => hash(c.file) :+: c.ivyScala :+: c.validate :+: HNil
-    implicit def sshConnectionToHL = (s: SshConnection) => s.authentication :+: s.hostname :+: s.port :+: HNil
-
-    implicit def artifactToHL = (a: Artifact) => a.name :+: a.`type` :+: a.extension :+: a.classifier :+: names(a.configurations) :+: a.url :+: a.extraAttributes :+: HNil
-    implicit def inclExclToHL = (e: InclExclRule) => e.organization :+: e.name :+: e.artifact :+: e.configurations :+: HNil
-    implicit def sbtExclusionToHL = (e: SbtExclusionRule) => e.organization :+: e.name :+: e.artifact :+: e.configurations :+: e.crossVersion :+: HNil
-    implicit def crossToHL = (c: CrossVersion) => crossToInt(c) :+: HNil
-
-    /*		implicit def deliverConfToHL = (p: DeliverConfiguration) => p.deliverIvyPattern :+: p.status :+: p.configurations :+: HNil
-		implicit def publishConfToHL = (p: PublishConfiguration) => p.ivyFile :+: p.resolverName :+: p.artifacts :+: HNil*/
-  }
-  import L2._
-
-  implicit def updateConfIC: InputCache[UpdateConfiguration] = wrapIn
-  implicit def pomIC: InputCache[PomConfiguration] = wrapIn
-  implicit def ivyFileIC: InputCache[IvyFileConfiguration] = wrapIn
-  implicit def connectionIC: InputCache[SshConnection] = wrapIn
-  implicit def artifactIC: InputCache[Artifact] = wrapIn
-  implicit def exclusionIC: InputCache[InclExclRule] = wrapIn
-  implicit def sbtExclusionIC: InputCache[SbtExclusionRule] = wrapIn
-  implicit def crossVersionIC: InputCache[CrossVersion] = wrapIn
-  /*	implicit def publishConfIC: InputCache[PublishConfiguration] = wrapIn
-	implicit def deliverConfIC: InputCache[DeliverConfiguration] = wrapIn*/
-
-  object L1 {
-    implicit def retrieveToHL = (r: RetrieveConfiguration) => exists(r.retrieveDirectory) :+: r.outputPattern :+: HNil
-    implicit def ivyPathsToHL = (p: IvyPaths) => exists(p.baseDirectory) :+: p.ivyHome.map(exists.apply) :+: HNil
-    implicit def ivyScalaHL = (i: IvyScala) => i.scalaFullVersion :+: i.scalaBinaryVersion :+: names(i.configurations) :+: i.checkExplicit :+: i.filterImplicit :+: HNil
-    implicit def configurationToHL = (c: Configuration) => c.name :+: c.description :+: c.isPublic :+: names(c.extendsConfigs) :+: c.transitive :+: HNil
-
-    implicit def passwordToHL = (s: PasswordAuthentication) => Hash(s.user) :+: password(s.password) :+: HNil
-    implicit def keyFileToHL = (s: KeyFileAuthentication) => Hash(s.user) :+: hash(s.keyfile) :+: password(s.password) :+: HNil
-
-    implicit def patternsToHL = (p: Patterns) => p.ivyPatterns :+: p.artifactPatterns :+: p.isMavenCompatible :+: HNil
-    implicit def fileConfToHL = (f: FileConfiguration) => f.isLocal :+: f.isTransactional :+: HNil
-
-    implicit def externalIvyConfigurationToHL = (e: ExternalIvyConfiguration) =>
-      exists(e.baseDirectory) :+: Hash.contentsIfLocal(e.uri) :+: HNil
-  }
-  import L1._
-
-  implicit def ivyScalaIC: InputCache[IvyScala] = wrapIn
-  implicit def ivyPathsIC: InputCache[IvyPaths] = wrapIn
-  implicit def retrieveIC: InputCache[RetrieveConfiguration] = wrapIn
-  implicit def patternsIC: InputCache[Patterns] = wrapIn
-  implicit def fileConfIC: InputCache[FileConfiguration] = wrapIn
-  implicit def extIvyIC: InputCache[ExternalIvyConfiguration] = wrapIn
-  implicit def confIC: InputCache[Configuration] = wrapIn
-
-  implicit def authIC: InputCache[SshAuthentication] =
-    unionInputCache[SshAuthentication, PasswordAuthentication :+: KeyFileAuthentication :+: HNil]
-}
diff --git a/main-actions/src/main/scala/sbt/Compiler.scala b/main-actions/src/main/scala/sbt/Compiler.scala
deleted file mode 100644
index ca69ca5bc..000000000
--- a/main-actions/src/main/scala/sbt/Compiler.scala
+++ /dev/null
@@ -1,156 +0,0 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010  Mark Harrah
- */
-package sbt
-
-import sbt.internal.inc.javac.JavaTools
-import sbt.internal.inc.{ AnalyzingCompiler, ComponentCompiler, ScalaInstance }
-import xsbti.{ Logger => _, _ }
-import xsbti.compile.{ ClasspathOptions, Compilers, CompileResult, Inputs }
-import java.io.File
-
-import sbt.internal.librarymanagement.{ ComponentManager, IvyConfiguration }
-import sbt.librarymanagement.{ ModuleID, VersionNumber }
-import sbt.util.Logger
-
-object Compiler {
-  val DefaultMaxErrors = 100
-  private[sbt] def defaultCompilerBridgeSource(sv: String): ModuleID =
-    VersionNumber(sv) match {
-      case VersionNumber(ns, _, _) if (ns.size == 3) && (ns(0) == 2) && (ns(1) <= 10) => scalaCompilerBridgeSource2_10
-      case _ => scalaCompilerBridgeSource2_11
-    }
-  private[sbt] def scalaCompilerBridgeSource2_10: ModuleID =
-    ModuleID(xsbti.ArtifactInfo.SbtOrganization, "compiler-bridge_2.10",
-      ComponentCompiler.incrementalVersion, Some("component")).sources()
-  private[sbt] def scalaCompilerBridgeSource2_11: ModuleID =
-    ModuleID(xsbti.ArtifactInfo.SbtOrganization, "compiler-bridge_2.11",
-      ComponentCompiler.incrementalVersion, Some("component")).sources()
-
-  /** Inputs necessary to run the incremental compiler. */
-  // final case class Inputs(compilers: Compilers, config: Options, incSetup: IncSetup)
-  // /** The inputs for the copiler *and* the previous analysis of source dependecnies. */
-  // final case class InputsWithPrevious(inputs: Inputs, previousAnalysis: PreviousAnalysis)
-  // final case class Options(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String], javacOptions: Seq[String], maxErrors: Int, sourcePositionMapper: Position => Position, order: CompileOrder)
-  // final case class IncSetup(analysisMap: File => Option[Analysis], definesClass: DefinesClass, skip: Boolean, cacheFile: File, cache: GlobalsCache, incOptions: IncOptions)
-
-  // private[sbt] trait JavaToolWithNewInterface extends JavaTool {
-  //   def newJavac: IncrementalCompilerJavaTools
-  // }
-  /** The instances of Scalac/Javac used to compile the current project. */
-  // final case class Compilers(scalac: AnalyzingCompiler, javac: IncrementalCompilerJavaTools)
-
-  /** The previous source dependency analysis result from compilation. */
-  // final case class PreviousAnalysis(analysis: Analysis, setup: Option[MiniSetup])
-
-  // def inputs(classpath: Seq[File], sources: Seq[File], classesDirectory: File, options: Seq[String],
-  //   javacOptions: Seq[String], maxErrors: Int, sourcePositionMappers: Seq[Position => Option[Position]],
-  //   order: CompileOrder)(implicit compilers: Compilers, incSetup: IncSetup, log: Logger): Inputs =
-  //   new Inputs(
-  //     compilers,
-  //     new Options(classpath, sources, classesDirectory, options, javacOptions, maxErrors, foldMappers(sourcePositionMappers), order),
-  //     incSetup
-  //   )
-
-  // @deprecated("Use `compilers(ScalaInstance, ClasspathOptions, Option[File], IvyConfiguration)`.", "0.13.10")
-  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File])(implicit app: AppConfiguration, log: Logger): Compilers =
-  //   {
-  //     val javac =
-  //       AggressiveCompile.directOrFork(instance, cpOptions, javaHome)
-  //     val javac2 =
-  //       JavaTools.directOrFork(instance, cpOptions, javaHome)
-  //     // Hackery to enable both the new and deprecated APIs to coexist peacefully.
-  //     case class CheaterJavaTool(newJavac: IncrementalCompilerJavaTools, delegate: JavaTool) extends JavaTool with JavaToolWithNewInterface {
-  //       def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger): Unit =
-  //         javac.compile(contract, sources, classpath, outputDirectory, options)(log)
-  //       def onArgs(f: Seq[String] => Unit): JavaTool = CheaterJavaTool(newJavac, delegate.onArgs(f))
-  //     }
-  //     compilers(instance, cpOptions, CheaterJavaTool(javac2, javac))
-  //   }
-  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration)(implicit app: AppConfiguration, log: Logger): Compilers =
-  //   {
-  //     val javac =
-  //       AggressiveCompile.directOrFork(instance, cpOptions, javaHome)
-  //     val javac2 =
-  //       JavaTools.directOrFork(instance, cpOptions, javaHome)
-  //     // Hackery to enable both the new and deprecated APIs to coexist peacefully.
-  //     case class CheaterJavaTool(newJavac: IncrementalCompilerJavaTools, delegate: JavaTool) extends JavaTool with JavaToolWithNewInterface {
-  //       def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger): Unit =
-  //         javac.compile(contract, sources, classpath, outputDirectory, options)(log)
-  //       def onArgs(f: Seq[String] => Unit): JavaTool = CheaterJavaTool(newJavac, delegate.onArgs(f))
-  //     }
-  //     val scalac = scalaCompiler(instance, cpOptions, ivyConfiguration)
-  //     new Compilers(scalac, CheaterJavaTool(javac2, javac))
-  //   }
-  // @deprecated("Deprecated in favor of new sbt.compiler.javac package.", "0.13.8")
-  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: sbt.compiler.JavaCompiler.Fork)(implicit app: AppConfiguration, log: Logger): Compilers =
-  //   {
-  //     val javaCompiler = sbt.compiler.JavaCompiler.fork(cpOptions, instance)(javac)
-  //     compilers(instance, cpOptions, javaCompiler)
-  //   }
-  // @deprecated("Deprecated in favor of new sbt.compiler.javac package.", "0.13.8")
-  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: JavaTool)(implicit app: AppConfiguration, log: Logger): Compilers =
-  //   {
-  //     val scalac = scalaCompiler(instance, cpOptions)
-  //     new Compilers(scalac, javac)
-  //   }
-  // @deprecated("Use `scalaCompiler(ScalaInstance, ClasspathOptions, IvyConfiguration)`.", "0.13.10")
-  // def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler =
-  //   {
-  //     val launcher = app.provider.scalaProvider.launcher
-  //     val componentManager = new ComponentManager(launcher.globalLock, app.provider.components, Option(launcher.ivyHome), log)
-  //     val provider = ComponentCompiler.interfaceProvider(componentManager)
-  //     new AnalyzingCompiler(instance, provider, cpOptions)
-  //   }
-
-  def compilers(cpOptions: ClasspathOptions, ivyConfiguration: IvyConfiguration)(implicit app: AppConfiguration, log: Logger): Compilers =
-    {
-      val scalaProvider = app.provider.scalaProvider
-      val instance = ScalaInstance(scalaProvider.version, scalaProvider.launcher)
-      val sourceModule = scalaCompilerBridgeSource2_11
-      compilers(instance, cpOptions, None, ivyConfiguration, sourceModule)
-    }
-
-  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): Compilers =
-  //   compilers(instance, cpOptions, None)
-
-  // TODO: Get java compiler
-  def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File],
-    ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): Compilers = {
-    val scalac = scalaCompiler(instance, cpOptions, javaHome, ivyConfiguration, sourcesModule)
-    val javac = JavaTools.directOrFork(instance, cpOptions, javaHome)
-    new Compilers(scalac, javac)
-  }
-  def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler =
-    {
-      val launcher = app.provider.scalaProvider.launcher
-      val componentManager = new ComponentManager(launcher.globalLock, app.provider.components, Option(launcher.ivyHome), log)
-      val provider = ComponentCompiler.interfaceProvider(componentManager, ivyConfiguration, sourcesModule)
-      new AnalyzingCompiler(instance, provider, cpOptions)
-    }
-
-  def compile(in: Inputs, log: Logger): CompileResult =
-    {
-      sbt.inc.IncrementalCompilerUtil.defaultIncrementalCompiler.compile(in, log)
-      // import in.inputs.config._
-      // compile(in, log, new LoggerReporter(maxErrors, log, sourcePositionMapper))
-    }
-  // def compile(in: Inputs, log: Logger, reporter: xsbti.Reporter): CompileResult =
-  //   {
-  //     import in.inputs.compilers._
-  //     import in.inputs.config._
-  //     import in.inputs.incSetup._
-  //     // Here is some trickery to choose the more recent (reporter-using) java compiler rather
-  //     // than the previously defined versions.
-  //     // TODO - Remove this hackery in sbt 1.0.
-  //     val javacChosen: xsbti.compile.JavaCompiler =
-  //       in.inputs.compilers.javac.xsbtiCompiler // ).getOrElse(in.inputs.compilers.javac)
-  //     // TODO - Why are we not using the IC interface???
-  //     val compiler = new IncrementalCompilerImpl
-  //     compiler.incrementalCompile(scalac, javacChosen, sources, classpath, CompileOutput(classesDirectory), cache, None, options, javacOptions,
-  //       in.previousAnalysis.analysis, in.previousAnalysis.setup, analysisMap, definesClass, reporter, order, skip, incOptions)(log)
-  //   }
-
-  private[sbt] def foldMappers[A](mappers: Seq[A => Option[A]]) =
-    mappers.foldRight({ p: A => p }) { (mapper, mappers) => { p: A => mapper(p).getOrElse(mappers(p)) } }
-}
diff --git a/main-actions/src/main/scala/sbt/Console.scala b/main-actions/src/main/scala/sbt/Console.scala
index b9a721ef8..a40c12a27 100644
--- a/main-actions/src/main/scala/sbt/Console.scala
+++ b/main-actions/src/main/scala/sbt/Console.scala
@@ -1,33 +1,85 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
-import sbt.internal.inc.AnalyzingCompiler
+import java.nio.channels.ClosedChannelException
+import sbt.internal.inc.{ AnalyzingCompiler, MappedFileConverter, PlainVirtualFile }
+import sbt.internal.util.{ DeprecatedJLine, Terminal }
 import sbt.util.Logger
+import xsbti.compile.{ Compilers, Inputs }
 
-import xsbti.compile.{ Inputs, Compilers }
+import scala.util.Try
 
 final class Console(compiler: AnalyzingCompiler) {
+
   /** Starts an interactive scala interpreter session with the given classpath.*/
-  def apply(classpath: Seq[File], log: Logger): Option[String] =
+  def apply(classpath: Seq[File], log: Logger): Try[Unit] =
     apply(classpath, Nil, "", "", log)
 
-  def apply(classpath: Seq[File], options: Seq[String], initialCommands: String, cleanupCommands: String, log: Logger): Option[String] =
+  def apply(
+      classpath: Seq[File],
+      options: Seq[String],
+      initialCommands: String,
+      cleanupCommands: String,
+      log: Logger
+  ): Try[Unit] =
     apply(classpath, options, initialCommands, cleanupCommands)(None, Nil)(log)
 
-  def apply(classpath: Seq[File], options: Seq[String], loader: ClassLoader, initialCommands: String, cleanupCommands: String)(bindings: (String, Any)*)(implicit log: Logger): Option[String] =
+  def apply(
+      classpath: Seq[File],
+      options: Seq[String],
+      loader: ClassLoader,
+      initialCommands: String,
+      cleanupCommands: String
+  )(bindings: (String, Any)*)(implicit log: Logger): Try[Unit] =
     apply(classpath, options, initialCommands, cleanupCommands)(Some(loader), bindings)
 
-  def apply(classpath: Seq[File], options: Seq[String], initialCommands: String, cleanupCommands: String)(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(implicit log: Logger): Option[String] =
-    {
-      def console0() = compiler.console(classpath, options, initialCommands, cleanupCommands, log)(loader, bindings)
-      // TODO: Fix JLine
-      //JLine.withJLine(Run.executeTrapExit(console0, log))
-      Run.executeTrapExit(console0, log)
+  def apply(
+      classpath: Seq[File],
+      options: Seq[String],
+      initialCommands: String,
+      cleanupCommands: String
+  )(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(implicit log: Logger): Try[Unit] = {
+    apply(classpath, options, initialCommands, cleanupCommands, Terminal.get)(loader, bindings)
+  }
+  def apply(
+      classpath: Seq[File],
+      options: Seq[String],
+      initialCommands: String,
+      cleanupCommands: String,
+      terminal: Terminal
+  )(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(implicit log: Logger): Try[Unit] = {
+    def console0(): Unit =
+      try {
+        compiler.console(classpath map { x =>
+          PlainVirtualFile(x.toPath)
+        }, MappedFileConverter.empty, options, initialCommands, cleanupCommands, log)(
+          loader,
+          bindings
+        )
+      } catch { case _: InterruptedException | _: ClosedChannelException => }
+    val previous = sys.props.get("scala.color").getOrElse("auto")
+    val jline3term = sbt.internal.util.JLine3(terminal)
+    try {
+      sys.props("scala.color") = if (terminal.isColorEnabled) "true" else "false"
+      terminal.withRawOutput {
+        jline.TerminalFactory.set(terminal.toJLine)
+        DeprecatedJLine.setTerminalOverride(jline3term)
+        terminal.withRawInput(Run.executeTrapExit(console0, log))
+      }
+    } finally {
+      sys.props("scala.color") = previous
+      jline3term.close()
     }
+  }
 }
+
 object Console {
   def apply(conf: Inputs): Console =
     conf.compilers match {
diff --git a/main-actions/src/main/scala/sbt/Doc.scala b/main-actions/src/main/scala/sbt/Doc.scala
index f21d5eff1..798e0b8d4 100644
--- a/main-actions/src/main/scala/sbt/Doc.scala
+++ b/main-actions/src/main/scala/sbt/Doc.scala
@@ -1,88 +1,85 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010, 2011  Mark Harrah, Indrajit Raychaudhuri
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
-import sbt.internal.inc.AnalyzingCompiler
-
-import Predef.{ conforms => _, _ }
-import sbt.io.syntax._
-import sbt.io.IO
-
+import sbt.internal.inc.{ AnalyzingCompiler, PlainVirtualFile }
+import sbt.internal.util.ManagedLogger
+import sbt.util.CacheStoreFactory
+import sbt.util.Logger
 import xsbti.Reporter
 import xsbti.compile.JavaTools
-
-import sbt.util.Logger
+import sbt.internal.inc.MappedFileConverter
 
 object Doc {
   import RawCompileLike._
-  def scaladoc(label: String, cache: File, compiler: AnalyzingCompiler): Gen =
-    scaladoc(label, cache, compiler, Seq())
-  def scaladoc(label: String, cache: File, compiler: AnalyzingCompiler, fileInputOptions: Seq[String]): Gen =
-    cached(cache, fileInputOptions, prepare(label + " Scala API documentation", compiler.doc))
-  def javadoc(label: String, cache: File, doc: JavaTools, log: Logger, reporter: Reporter): Gen =
-    javadoc(label, cache, doc, log, reporter, Seq())
-  def javadoc(label: String, cache: File, doc: JavaTools, log: Logger, reporter: Reporter, fileInputOptions: Seq[String]): Gen =
-    cached(cache, fileInputOptions, prepare(label + " Java API documentation", filterSources(javaSourcesOnly,
-      (sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maxErrors: Int, log: Logger) => {
-        // doc.doc
-        ???
-      })))
 
+  def scaladoc(
+      label: String,
+      cacheStoreFactory: CacheStoreFactory,
+      compiler: AnalyzingCompiler
+  ): Gen =
+    scaladoc(label, cacheStoreFactory, compiler, Seq())
+
+  def scaladoc(
+      label: String,
+      cacheStoreFactory: CacheStoreFactory,
+      compiler: AnalyzingCompiler,
+      fileInputOptions: Seq[String]
+  ): Gen =
+    cached(
+      cacheStoreFactory,
+      fileInputOptions,
+      prepare(
+        label + " Scala API documentation",
+        (sources, classpath, outputDirectory, options, maxErrors, log) => {
+          compiler.doc(
+            sources map { x =>
+              PlainVirtualFile(x.toPath)
+            },
+            classpath map { x =>
+              PlainVirtualFile(x.toPath)
+            },
+            MappedFileConverter.empty,
+            outputDirectory.toPath,
+            options,
+            maxErrors,
+            log
+          )
+        }
+      )
+    )
+
+  @deprecated("Going away", "1.1.1")
+  def javadoc(
+      label: String,
+      cacheStoreFactory: CacheStoreFactory,
+      doc: JavaTools,
+      log: Logger,
+      reporter: Reporter,
+  ): Gen = ???
+
+  @deprecated("Going away", "1.1.1")
+  def javadoc(
+      label: String,
+      cacheStoreFactory: CacheStoreFactory,
+      doc: JavaTools,
+      log: Logger,
+      reporter: Reporter,
+      fileInputOptions: Seq[String],
+  ): Gen = ???
+
+  @deprecated("Going away", "1.1.1")
   val javaSourcesOnly: File => Boolean = _.getName.endsWith(".java")
-
-  // @deprecated("Use `scaladoc`", "0.13.0")
-  // def apply(maximumErrors: Int, compiler: AnalyzingCompiler) = new Scaladoc(maximumErrors, compiler)
-
-  // @deprecated("Use `javadoc`", "0.13.0")
-  // def apply(maximumErrors: Int, compiler: sbt.compiler.Javadoc) = new Javadoc(maximumErrors, compiler)
-
-  private[sbt] final class Scaladoc(maximumErrors: Int, compiler: AnalyzingCompiler) extends Doc {
-    def apply(label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger): Unit = {
-      generate("Scala", label, compiler.doc, sources, classpath, outputDirectory, options, maximumErrors, log)
-    }
-  }
-
-  // private[sbt] final class Javadoc(maximumErrors: Int, doc: sbt.internal.inc.Javadoc) extends Doc {
-  //   def apply(label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger) {
-  //     // javadoc doesn't handle *.scala properly, so we evict them from javadoc sources list.
-  //     generate("Java", label, doc.doc, sources.filterNot(_.name.endsWith(".scala")), classpath, outputDirectory, options, maximumErrors, log)
-  //   }
-  // }
 }
-// @deprecated("No longer used.  See `Doc.javadoc` or `Doc.scaladoc`", "0.13.0")
+
+@deprecated("Going away", "1.1.1")
 sealed trait Doc {
-  type Gen = (Seq[File], Seq[File], File, Seq[String], Int, Logger) => Unit
-
-  //   def apply(label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger): Unit
-
-  private[sbt] final def generate(variant: String, label: String, docf: Gen, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maxErrors: Int, log: Logger): Unit = {
-    val logSnip = variant + " API documentation"
-    if (sources.isEmpty)
-      log.info("No sources available, skipping " + logSnip + "...")
-    else {
-      log.info("Generating " + logSnip + " for " + label + " sources to " + outputDirectory.absolutePath + "...")
-      IO.delete(outputDirectory)
-      IO.createDirectory(outputDirectory)
-      docf(sources, classpath, outputDirectory, options, maxErrors, log)
-      log.info(logSnip + " generation successful.")
-    }
-  }
-
-  //   def cached(cache: File, label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger) {
-  //     type Inputs = FilesInfo[HashFileInfo] :+: FilesInfo[ModifiedFileInfo] :+: String :+: File :+: Seq[String] :+: HNil
-  //     val inputs: Inputs = hash(sources.toSet) :+: lastModified(classpath.toSet) :+: classpath.absString :+: outputDirectory :+: options :+: HNil
-  //     implicit val stringEquiv: Equiv[String] = defaultEquiv
-  //     implicit val fileEquiv: Equiv[File] = defaultEquiv
-  //     val cachedDoc = inputChanged(cache / "inputs") { (inChanged, in: Inputs) =>
-  //       outputChanged(cache / "output") { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
-  //         if (inChanged || outChanged)
-  //           apply(label, sources, classpath, outputDirectory, options, log)
-  //         else
-  //           log.debug("Doc uptodate: " + outputDirectory.getAbsolutePath)
-  //       }
-  //     }
-  //     cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
-  //   }
+  @deprecated("Going away", "1.1.1")
+  type Gen = (Seq[File], Seq[File], File, Seq[String], Int, ManagedLogger) => Unit
 }
diff --git a/main-actions/src/main/scala/sbt/DotGraph.scala b/main-actions/src/main/scala/sbt/DotGraph.scala
index 46d33503a..6d39109a3 100644
--- a/main-actions/src/main/scala/sbt/DotGraph.scala
+++ b/main-actions/src/main/scala/sbt/DotGraph.scala
@@ -1,41 +1,38 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
 import sbt.internal.inc.Relations
-
 import sbt.internal.util.Relation
 
 import sbt.io.IO
 
 object DotGraph {
-  private def fToString(roots: Iterable[File]): (File => String) =
-    (x: File) => sourceToString(roots, x)
-  def sources(relations: Relations, outputDirectory: File, sourceRoots: Iterable[File]): Unit = {
-    val toString = fToString(sourceRoots)
-    apply(relations, outputDirectory, toString, toString)
-  }
-  def packages(relations: Relations, outputDirectory: File, sourceRoots: Iterable[File]): Unit = {
-    val packageOnly = (path: String) =>
-      {
-        val last = path.lastIndexOf(File.separatorChar.toInt)
-        val packagePath = (if (last > 0) path.substring(0, last) else path).trim
-        if (packagePath.isEmpty) "" else packagePath.replace(File.separatorChar, '.')
-      }
-    val toString = packageOnly compose fToString(sourceRoots)
-    apply(relations, outputDirectory, toString, toString)
-  }
-  def apply(relations: Relations, outputDir: File, sourceToString: File => String, externalToString: File => String): Unit = {
-    def file(name: String) = new File(outputDir, name)
-    IO.createDirectory(outputDir)
-    generateGraph(file("int-class-deps"), "dependencies", relations.internalClassDep, identity[String], identity[String])
-    generateGraph(file("binary-dependencies"), "externalDependencies", relations.binaryDep, externalToString, sourceToString)
-  }
+  @deprecated("not used", "1.4.0")
+  def sources(relations: Relations, outputDirectory: File, sourceRoots: Iterable[File]): Unit = ???
+  @deprecated("not used", "1.4.0")
+  def packages(relations: Relations, outputDirectory: File, sourceRoots: Iterable[File]): Unit = ???
+  @deprecated("not used", "1.4.0")
+  def apply(
+      relations: Relations,
+      outputDir: File,
+      sourceToString: File => String,
+      externalToString: File => String
+  ): Unit = ???
 
-  def generateGraph[K, V](file: File, graphName: String, relation: Relation[K, V],
-    keyToString: K => String, valueToString: V => String): Unit = {
+  def generateGraph[K, V](
+      file: File,
+      graphName: String,
+      relation: Relation[K, V],
+      keyToString: K => String,
+      valueToString: V => String
+  ): Unit = {
     import scala.collection.mutable.{ HashMap, HashSet }
     val mappedGraph = new HashMap[String, HashSet[String]]
     for ((key, values) <- relation.forwardMap; keyString = keyToString(key); value <- values)
@@ -58,10 +55,9 @@ object DotGraph {
   def sourceToString(roots: Iterable[File], source: File) =
     relativized(roots, source).trim.stripSuffix(".scala").stripSuffix(".java")
 
-  private def relativized(roots: Iterable[File], path: File): String =
-    {
-      val relativized = roots.flatMap(root => IO.relativize(root, path))
-      val shortest = (Int.MaxValue /: relativized)(_ min _.length)
-      relativized.find(_.length == shortest).getOrElse(path.getName)
-    }
+  private def relativized(roots: Iterable[File], path: File): String = {
+    val relativized = roots.flatMap(root => IO.relativize(root, path))
+    val shortest = relativized.foldLeft(Int.MaxValue)(_ min _.length)
+    relativized.find(_.length == shortest).getOrElse(path.getName)
+  }
 }
diff --git a/main-actions/src/main/scala/sbt/ForkTests.scala b/main-actions/src/main/scala/sbt/ForkTests.scala
index 6f6cb97a3..ddc01a850 100755
--- a/main-actions/src/main/scala/sbt/ForkTests.scala
+++ b/main-actions/src/main/scala/sbt/ForkTests.scala
@@ -1,20 +1,35 @@
-/* sbt -- Simple Build Tool
- * Copyright 2012 Eugene Vigdorchik
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import scala.collection.mutable
-import testing.{ Logger => _, _ }
+import testing.{ Logger => _, Task => _, _ }
+import scala.util.control.NonFatal
 import java.net.ServerSocket
 import java.io._
 import Tests.{ Output => TestOutput, _ }
 import sbt.io.IO
 import sbt.util.Logger
+import sbt.ConcurrentRestrictions.Tag
+import sbt.protocol.testing._
+import sbt.internal.util.Util.{ AnyOps, none }
+import sbt.internal.util.{ RunningProcesses, Terminal => UTerminal }
 
 private[sbt] object ForkTests {
-  def apply(runners: Map[TestFramework, Runner], tests: List[TestDefinition], config: Execution, classpath: Seq[File], fork: ForkOptions, log: Logger): Task[TestOutput] = {
-    val opts = processOptions(config, tests, log)
-
+  def apply(
+      runners: Map[TestFramework, Runner],
+      opts: ProcessedOptions,
+      config: Execution,
+      classpath: Seq[File],
+      fork: ForkOptions,
+      log: Logger,
+      tags: (Tag, Int)*
+  ): Task[TestOutput] = {
     import std.TaskExtra._
     val dummyLoader = this.getClass.getClassLoader // can't provide the loader for test classes, which is in another jvm
     def all(work: Seq[ClassLoader => Unit]) = work.fork(f => f(dummyLoader))
@@ -24,22 +39,55 @@ private[sbt] object ForkTests {
         constant(TestOutput(TestResult.Passed, Map.empty[String, SuiteResult], Iterable.empty))
       else
         mainTestTask(runners, opts, classpath, fork, log, config.parallel).tagw(config.tags: _*)
-    main.dependsOn(all(opts.setup): _*) flatMap { results =>
+    main.tagw(tags: _*).dependsOn(all(opts.setup): _*) flatMap { results =>
       all(opts.cleanup).join.map(_ => results)
     }
   }
 
-  private[this] def mainTestTask(runners: Map[TestFramework, Runner], opts: ProcessedOptions, classpath: Seq[File], fork: ForkOptions, log: Logger, parallel: Boolean): Task[TestOutput] =
+  def apply(
+      runners: Map[TestFramework, Runner],
+      tests: Vector[TestDefinition],
+      config: Execution,
+      classpath: Seq[File],
+      fork: ForkOptions,
+      log: Logger,
+      tags: (Tag, Int)*
+  ): Task[TestOutput] = {
+    val opts = processOptions(config, tests, log)
+    apply(runners, opts, config, classpath, fork, log, tags: _*)
+  }
+
+  def apply(
+      runners: Map[TestFramework, Runner],
+      tests: Vector[TestDefinition],
+      config: Execution,
+      classpath: Seq[File],
+      fork: ForkOptions,
+      log: Logger,
+      tag: Tag
+  ): Task[TestOutput] = {
+    apply(runners, tests, config, classpath, fork, log, tag -> 1)
+  }
+
+  private[this] def mainTestTask(
+      runners: Map[TestFramework, Runner],
+      opts: ProcessedOptions,
+      classpath: Seq[File],
+      fork: ForkOptions,
+      log: Logger,
+      parallel: Boolean
+  ): Task[TestOutput] =
     std.TaskExtra.task {
       val server = new ServerSocket(0)
       val testListeners = opts.testListeners flatMap {
-        case tl: TestsListener => Some(tl)
-        case _                 => None
+        case tl: TestsListener => tl.some
+        case _                 => none[TestsListener]
       }
 
       object Acceptor extends Runnable {
         val resultsAcc = mutable.Map.empty[String, SuiteResult]
-        lazy val result = TestOutput(overall(resultsAcc.values.map(_.result)), resultsAcc.toMap, Iterable.empty)
+        lazy val result =
+          TestOutput(overall(resultsAcc.values.map(_.result)), resultsAcc.toMap, Iterable.empty)
 
         def run(): Unit = {
           val socket =
@@ -47,7 +95,9 @@ private[sbt] object ForkTests {
               server.accept()
             } catch {
               case e: java.net.SocketException =>
-                log.error("Could not accept connection from test agent: " + e.getClass + ": " + e.getMessage)
+                log.error(
+                  "Could not accept connection from test agent: " + e.getClass + ": " + e.getMessage
+                )
                 log.trace(e)
                 server.close()
                 return
@@ -58,10 +108,17 @@ private[sbt] object ForkTests {
           val is = new ObjectInputStream(socket.getInputStream)
 
           try {
-            val config = new ForkConfiguration(log.ansiCodesSupported, parallel)
+            val config = new ForkConfiguration(UTerminal.isAnsiSupported, parallel)
             os.writeObject(config)
 
-            val taskdefs = opts.tests.map(t => new TaskDef(t.name, forkFingerprint(t.fingerprint), t.explicitlySpecified, t.selectors))
+            val taskdefs = opts.tests.map { t =>
+              new TaskDef(
+                t.name,
+                forkFingerprint(t.fingerprint),
+                t.explicitlySpecified,
+                t.selectors
+              )
+            }
             os.writeObject(taskdefs.toArray)
 
             os.writeInt(runners.size)
@@ -73,6 +130,13 @@ private[sbt] object ForkTests {
             os.flush()
 
             new React(is, os, log, opts.testListeners, resultsAcc).react()
+          } catch {
+            case NonFatal(e) =>
+              def throwableToString(t: Throwable) = {
+                import java.io._; val sw = new StringWriter; t.printStackTrace(new PrintWriter(sw));
+                sw.toString
+              }
+              resultsAcc("Forked test harness failed: " + throwableToString(e)) = SuiteResult.Error
           } finally {
             is.close(); os.close(); socket.close()
           }
@@ -84,12 +148,33 @@ private[sbt] object ForkTests {
         val acceptorThread = new Thread(Acceptor)
         acceptorThread.start()
 
-        val fullCp = classpath ++: Seq(IO.classLocationFile[ForkMain], IO.classLocationFile[Framework])
-        val options = Seq("-classpath", fullCp mkString File.pathSeparator, classOf[ForkMain].getCanonicalName, server.getLocalPort.toString)
-        val ec = Fork.java(fork, options)
+        val fullCp = classpath ++ Seq(
+          IO.classLocationPath[ForkMain].toFile,
+          IO.classLocationPath[Framework].toFile
+        )
+        val options = Seq(
+          "-classpath",
+          fullCp mkString File.pathSeparator,
+          classOf[ForkMain].getCanonicalName,
+          server.getLocalPort.toString
+        )
+        val p = Fork.java.fork(fork, options)
+        RunningProcesses.add(p)
+        val ec = try p.exitValue()
+        finally {
+          if (p.isAlive) p.destroy()
+          RunningProcesses.remove(p)
+        }
         val result =
           if (ec != 0)
-            TestOutput(TestResult.Error, Map("Running java with options " + options.mkString(" ") + " failed with exit code " + ec -> SuiteResult.Error), Iterable.empty)
+            TestOutput(
+              TestResult.Error,
+              Map(
+                "Running java with options " + options
+                  .mkString(" ") + " failed with exit code " + ec -> SuiteResult.Error
+              ),
+              Iterable.empty
+            )
           else {
             // Need to wait acceptor thread to finish its business
             acceptorThread.join()
@@ -110,9 +195,16 @@ private[sbt] object ForkTests {
       case _                       => sys.error("Unknown fingerprint type: " + f.getClass)
     }
 }
-private final class React(is: ObjectInputStream, os: ObjectOutputStream, log: Logger, listeners: Seq[TestReportListener], results: mutable.Map[String, SuiteResult]) {
+private final class React(
+    is: ObjectInputStream,
+    os: ObjectOutputStream,
+    log: Logger,
+    listeners: Seq[TestReportListener],
+    results: mutable.Map[String, SuiteResult]
+) {
   import ForkTags._
-  @annotation.tailrec def react(): Unit = is.readObject match {
+  @annotation.tailrec
+  def react(): Unit = is.readObject match {
     case `Done` =>
       os.writeObject(Done); os.flush()
     case Array(`Error`, s: String) =>
diff --git a/main-actions/src/main/scala/sbt/Package.scala b/main-actions/src/main/scala/sbt/Package.scala
index 63f2fa395..e083cc494 100644
--- a/main-actions/src/main/scala/sbt/Package.scala
+++ b/main-actions/src/main/scala/sbt/Package.scala
@@ -1,37 +1,83 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import Predef.{ conforms => _, _ }
 import java.io.File
+import java.time.OffsetDateTime
 import java.util.jar.{ Attributes, Manifest }
-import collection.JavaConverters._
+import scala.collection.JavaConverters._
 import sbt.internal.util.Types.:+:
-import sbt.io.syntax._
 import sbt.io.IO
 
-import sbinary.{ DefaultProtocol, Format }
-import DefaultProtocol.{ FileFormat, immutableMapFormat, StringFormat }
-import sbt.internal.util.{ Cache, FileInfo, FilesInfo, HNil, ModifiedFileInfo, PlainFileInfo, Tracked }
-import Cache.{ defaultEquiv, hConsCache, hNilCache, streamFormat }
-import Tracked.{ inputChanged, outputChanged }
-import FileInfo.exists
-import FilesInfo.lastModified
+import sjsonnew.JsonFormat
 
 import sbt.util.Logger
 
+import sbt.util.{ CacheStoreFactory, FilesInfo, ModifiedFileInfo, PlainFileInfo }
+import sbt.internal.util.HNil
+import sbt.internal.util.HListFormats._
+import sbt.util.FileInfo.{ exists, lastModified }
+import sbt.util.CacheImplicits._
+import sbt.util.Tracked.{ inputChanged, outputChanged }
+import scala.sys.process.Process
+
 sealed trait PackageOption
+
+/**
+ * == Package ==
+ *
+ * This module provides an API to package jar files.
+ *
+ * @see [[https://docs.oracle.com/javase/tutorial/deployment/jar/index.html]]
+ */
 object Package {
   final case class JarManifest(m: Manifest) extends PackageOption {
     assert(m != null)
   }
   final case class MainClass(mainClassName: String) extends PackageOption
   final case class ManifestAttributes(attributes: (Attributes.Name, String)*) extends PackageOption
-  def ManifestAttributes(attributes: (String, String)*): ManifestAttributes =
-    {
-      val converted = for ((name, value) <- attributes) yield (new Attributes.Name(name), value)
-      new ManifestAttributes(converted: _*)
+  def ManifestAttributes(attributes: (String, String)*): ManifestAttributes = {
+    val converted = for ((name, value) <- attributes) yield (new Attributes.Name(name), value)
+    new ManifestAttributes(converted: _*)
+  }
+  // 2010-01-01
+  private val default2010Timestamp: Long = 1262304000000L
+  final case class FixedTimestamp(value: Option[Long]) extends PackageOption
+  val keepTimestamps: Option[Long] = None
+  val fixed2010Timestamp: Option[Long] = Some(default2010Timestamp)
+  def gitCommitDateTimestamp: Option[Long] =
+    try {
+      Some(
+        OffsetDateTime
+          .parse(Process("git show -s --format=%cI").!!.trim)
+          .toInstant()
+          .toEpochMilli()
+      )
+    } catch {
+      case e: Exception if e.getMessage.startsWith("Nonzero") =>
+        sys.error(
+          s"git repository was expected for package timestamp; use Package.fixed2010Timestamp or Package.keepTimestamps instead"
+        )
+    }
+  def setFixedTimestamp(value: Option[Long]): PackageOption =
+    FixedTimestamp(value)
+
+  /** by default we overwrite all timestamps in JAR to epoch time 2010-01-01 for repeatable build */
+  lazy val defaultTimestamp: Option[Long] =
+    sys.env
+      .get("SOURCE_DATE_EPOCH")
+      .map(_.toLong * 1000)
+      .orElse(Some(default2010Timestamp))
+
+  def timeFromConfiguration(config: Configuration): Option[Long] =
+    (config.options.collect { case t: FixedTimestamp => t }).headOption match {
+      case Some(FixedTimestamp(value)) => value
+      case _                           => defaultTimestamp
     }
 
   def mergeAttributes(a1: Attributes, a2: Attributes) = a1.asScala ++= a2.asScala
@@ -41,71 +87,156 @@ object Package {
     val entryMap = manifest.getEntries.asScala
     for ((key, value) <- mergeManifest.getEntries.asScala) {
       entryMap.get(key) match {
-        case Some(attributes) => mergeAttributes(attributes, value)
-        case None             => entryMap put (key, value)
+        case Some(attributes) => mergeAttributes(attributes, value); ()
+        case None             => entryMap put (key, value); ()
       }
     }
   }
 
-  final class Configuration(val sources: Seq[(File, String)], val jar: File, val options: Seq[PackageOption])
-  def apply(conf: Configuration, cacheFile: File, log: Logger): Unit = {
+  /**
+   * The jar package configuration. Contains all relevant information to create a jar file.
+   *
+   * @param sources the jar contents
+   * @param jar the destination jar file
+   * @param options additional package information, e.g. jar manifest, main class or manifest attributes
+   */
+  final class Configuration(
+      val sources: Seq[(File, String)],
+      val jar: File,
+      val options: Seq[PackageOption]
+  )
+
+  /**
+   *
+   * @param conf the package configuration that should be build
+   * @param cacheStoreFactory used for jar caching. We try to avoid rebuilds as much as possible
+   * @param log feedback for the user
+   */
+  def apply(conf: Configuration, cacheStoreFactory: CacheStoreFactory, log: Logger): Unit =
+    apply(conf, cacheStoreFactory, log, timeFromConfiguration(conf))
+
+  /**
+   *
+   * @param conf the package configuration that should be build
+   * @param cacheStoreFactory used for jar caching. We try to avoid rebuilds as much as possible
+   * @param log feedback for the user
+   * @param time static timestamp to use for all entries, if any.
+   */
+  def apply(
+      conf: Configuration,
+      cacheStoreFactory: CacheStoreFactory,
+      log: Logger,
+      time: Option[Long]
+  ): Unit = {
     val manifest = new Manifest
     val main = manifest.getMainAttributes
     for (option <- conf.options) {
       option match {
-        case JarManifest(mergeManifest)          => mergeManifests(manifest, mergeManifest)
-        case MainClass(mainClassName)            => main.put(Attributes.Name.MAIN_CLASS, mainClassName)
-        case ManifestAttributes(attributes @ _*) => main.asScala ++= attributes
+        case JarManifest(mergeManifest)          => mergeManifests(manifest, mergeManifest); ()
+        case MainClass(mainClassName)            => main.put(Attributes.Name.MAIN_CLASS, mainClassName); ()
+        case ManifestAttributes(attributes @ _*) => main.asScala ++= attributes; ()
+        case FixedTimestamp(value)               => ()
         case _                                   => log.warn("Ignored unknown package option " + option)
       }
     }
     setVersion(main)
 
-    val cachedMakeJar = inputChanged(cacheFile / "inputs") { (inChanged, inputs: Map[File, String] :+: FilesInfo[ModifiedFileInfo] :+: Manifest :+: HNil) =>
-      val sources :+: _ :+: manifest :+: HNil = inputs
-      outputChanged(cacheFile / "output") { (outChanged, jar: PlainFileInfo) =>
-        if (inChanged || outChanged)
-          makeJar(sources.toSeq, jar.file, manifest, log)
-        else
-          log.debug("Jar uptodate: " + jar.file)
-      }
+    type Inputs = Seq[(File, String)] :+: FilesInfo[ModifiedFileInfo] :+: Manifest :+: HNil
+    val cachedMakeJar = inputChanged(cacheStoreFactory make "inputs") {
+      (inChanged, inputs: Inputs) =>
+        import exists.format
+        val sources :+: _ :+: manifest :+: HNil = inputs
+        outputChanged(cacheStoreFactory make "output") { (outChanged, jar: PlainFileInfo) =>
+          if (inChanged || outChanged) {
+            makeJar(sources, jar.file, manifest, log, time)
+            jar.file
+            ()
+          } else
+            log.debug("Jar uptodate: " + jar.file)
+        }
     }
 
-    val map = conf.sources.toMap
-    val inputs = map :+: lastModified(map.keySet) :+: manifest :+: HNil
+    val inputFiles = conf.sources.map(_._1).toSet
+    val inputs = conf.sources.distinct :+: lastModified(inputFiles) :+: manifest :+: HNil
     cachedMakeJar(inputs)(() => exists(conf.jar))
+    ()
   }
+
+  /**
+   * updates the manifest version is there is none present.
+   *
+   * @param main the current jar attributes
+   */
   def setVersion(main: Attributes): Unit = {
     val version = Attributes.Name.MANIFEST_VERSION
-    if (main.getValue(version) eq null)
+    if (main.getValue(version) eq null) {
       main.put(version, "1.0")
+      ()
+    }
   }
-  def addSpecManifestAttributes(name: String, version: String, orgName: String): PackageOption =
-    {
-      import Attributes.Name._
-      val attribKeys = Seq(SPECIFICATION_TITLE, SPECIFICATION_VERSION, SPECIFICATION_VENDOR)
-      val attribVals = Seq(name, version, orgName)
-      ManifestAttributes(attribKeys zip attribVals: _*)
-    }
-  def addImplManifestAttributes(name: String, version: String, homepage: Option[java.net.URL], org: String, orgName: String): PackageOption =
-    {
-      import Attributes.Name._
-      val attribKeys = Seq(IMPLEMENTATION_TITLE, IMPLEMENTATION_VERSION, IMPLEMENTATION_VENDOR, IMPLEMENTATION_VENDOR_ID)
-      val attribVals = Seq(name, version, orgName, org)
-      ManifestAttributes((attribKeys zip attribVals) ++ { homepage map (h => (IMPLEMENTATION_URL, h.toString)) }: _*)
-    }
-  def makeJar(sources: Seq[(File, String)], jar: File, manifest: Manifest, log: Logger): Unit = {
-    log.info("Packaging " + jar.getAbsolutePath + " ...")
-    IO.delete(jar)
+  def addSpecManifestAttributes(name: String, version: String, orgName: String): PackageOption = {
+    import Attributes.Name._
+    val attribKeys = Seq(SPECIFICATION_TITLE, SPECIFICATION_VERSION, SPECIFICATION_VENDOR)
+    val attribVals = Seq(name, version, orgName)
+    ManifestAttributes(attribKeys zip attribVals: _*)
+  }
+  def addImplManifestAttributes(
+      name: String,
+      version: String,
+      homepage: Option[java.net.URL],
+      org: String,
+      orgName: String
+  ): PackageOption = {
+    import Attributes.Name._
+
+    // The ones in Attributes.Name are deprecated saying:
+    //   "Extension mechanism will be removed in a future release. Use class path instead."
+    val IMPLEMENTATION_VENDOR_ID = new Attributes.Name("Implementation-Vendor-Id")
+    val IMPLEMENTATION_URL = new Attributes.Name("Implementation-URL")
+
+    val attribKeys = Seq(
+      IMPLEMENTATION_TITLE,
+      IMPLEMENTATION_VERSION,
+      IMPLEMENTATION_VENDOR,
+      IMPLEMENTATION_VENDOR_ID,
+    )
+    val attribVals = Seq(name, version, orgName, org)
+    ManifestAttributes((attribKeys zip attribVals) ++ {
+      homepage map (h => (IMPLEMENTATION_URL, h.toString))
+    }: _*)
+  }
+
+  @deprecated("Specify whether to use a static timestamp", "1.4.0")
+  def makeJar(sources: Seq[(File, String)], jar: File, manifest: Manifest, log: Logger): Unit =
+    makeJar(sources, jar, manifest, log, None)
+
+  def makeJar(
+      sources: Seq[(File, String)],
+      jar: File,
+      manifest: Manifest,
+      log: Logger,
+      time: Option[Long]
+  ): Unit = {
+    val path = jar.getAbsolutePath
+    log.debug("Packaging " + path + " ...")
+    if (jar.exists)
+      if (jar.isFile)
+        IO.delete(jar)
+      else
+        sys.error(path + " exists, but is not a regular file")
     log.debug(sourcesDebugString(sources))
-    IO.jar(sources, jar, manifest)
-    log.info("Done packaging.")
+    IO.jar(sources, jar, manifest, time)
+    log.debug("Done packaging.")
   }
   def sourcesDebugString(sources: Seq[(File, String)]): String =
     "Input file mappings:\n\t" + (sources map { case (f, s) => s + "\n\t  " + f } mkString ("\n\t"))
 
-  implicit def manifestEquiv: Equiv[Manifest] = defaultEquiv
-  implicit def manifestFormat: Format[Manifest] = streamFormat(_ write _, in => new Manifest(in))
-
-  implicit def stringMapEquiv: Equiv[Map[File, String]] = defaultEquiv
+  implicit def manifestFormat: JsonFormat[Manifest] = projectFormat[Manifest, Array[Byte]](
+    m => {
+      val bos = new java.io.ByteArrayOutputStream()
+      m write bos
+      bos.toByteArray
+    },
+    bs => new Manifest(new java.io.ByteArrayInputStream(bs))
+  )
 }
diff --git a/main-actions/src/main/scala/sbt/RawCompileLike.scala b/main-actions/src/main/scala/sbt/RawCompileLike.scala
index 48f591e72..7ac1a12cc 100644
--- a/main-actions/src/main/scala/sbt/RawCompileLike.scala
+++ b/main-actions/src/main/scala/sbt/RawCompileLike.scala
@@ -1,65 +1,75 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010, 2011  Mark Harrah, Indrajit Raychaudhuri
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
+import scala.annotation.tailrec
 import java.io.File
-import sbt.internal.inc.{ RawCompiler, ScalaInstance }
-
-import Predef.{ conforms => _, _ }
 import sbt.io.syntax._
 import sbt.io.IO
-
-import sbinary.DefaultProtocol.FileFormat
+import sbt.internal.inc.{ RawCompiler, ScalaInstance }
 import sbt.internal.util.Types.:+:
-import sbt.internal.util.Cache.{ defaultEquiv, hConsCache, hNilCache, IntFormat, seqCache, StringFormat }
-import sbt.internal.util.Tracked.{ inputChanged, outputChanged }
-import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo }
-import sbt.internal.util.FilesInfo.{ exists, hash, lastModified }
+import sbt.internal.util.HListFormats._
+import sbt.internal.util.HNil
+import sbt.internal.util.HListFormats._
+import sbt.util.CacheImplicits._
+import sbt.util.Tracked.inputChanged
+import sbt.util.{ CacheStoreFactory, FilesInfo, HashFileInfo, ModifiedFileInfo, PlainFileInfo }
+import sbt.util.FileInfo.{ exists, hash, lastModified }
+import sbt.internal.util.ManagedLogger
 import xsbti.compile.ClasspathOptions
 
-import sbt.util.Logger
-
 object RawCompileLike {
-  type Gen = (Seq[File], Seq[File], File, Seq[String], Int, Logger) => Unit
+  type Gen = (Seq[File], Seq[File], File, Seq[String], Int, ManagedLogger) => Unit
 
-  private def optionFiles(options: Seq[String], fileInputOpts: Seq[String]): List[File] =
-    {
-      @annotation.tailrec
-      def loop(opt: List[String], result: List[File]): List[File] = {
-        opt.dropWhile(!fileInputOpts.contains(_)) match {
-          case List(_, fileOpt, tail @ _*) =>
-            {
-              val file = new File(fileOpt)
-              if (file.isFile) loop(tail.toList, file :: result)
-              else loop(tail.toList, result)
-            }
-          case Nil | List(_) => result
+  private def optionFiles(options: Seq[String], fileInputOpts: Seq[String]): List[File] = {
+    @tailrec
+    def loop(opt: List[String], result: List[File]): List[File] = {
+      opt.dropWhile(!fileInputOpts.contains(_)) match {
+        case List(_, fileOpt, tail @ _*) => {
+          val file = new File(fileOpt)
+          if (file.isFile) loop(tail.toList, file :: result)
+          else loop(tail.toList, result)
+        }
+        case Nil | List(_) => result
+      }
+    }
+    loop(options.toList, Nil)
+  }
+
+  def cached(cacheStoreFactory: CacheStoreFactory, doCompile: Gen): Gen =
+    cached(cacheStoreFactory, Seq(), doCompile)
+
+  def cached(
+      cacheStoreFactory: CacheStoreFactory,
+      fileInputOpts: Seq[String],
+      doCompile: Gen
+  ): Gen =
+    (sources, classpath, outputDirectory, options, maxErrors, log) => {
+      type Inputs =
+        FilesInfo[HashFileInfo] :+: FilesInfo[ModifiedFileInfo] :+: Seq[File] :+: File :+:
+          Seq[String] :+: Int :+: HNil
+      val inputs: Inputs = hash(sources.toSet ++ optionFiles(options, fileInputOpts)) :+:
+        FilesInfo(classpath.toSet.map(lastModified.fileOrDirectoryMax)) :+: classpath :+:
+        outputDirectory :+: options :+: maxErrors :+: HNil
+      val cachedComp = inputChanged(cacheStoreFactory make "inputs") { (inChanged, in: Inputs) =>
+        inputChanged(cacheStoreFactory make "output") {
+          (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+            if (inChanged || outChanged)
+              doCompile(sources, classpath, outputDirectory, options, maxErrors, log)
+            else
+              log.debug("Uptodate: " + outputDirectory.getAbsolutePath)
         }
       }
-      loop(options.toList, Nil)
+      cachedComp(inputs)(exists(outputDirectory.allPaths.get.toSet))
     }
 
-  def cached(cache: File, doCompile: Gen): Gen = cached(cache, Seq(), doCompile)
-  def cached(cache: File, fileInputOpts: Seq[String], doCompile: Gen): Gen = (sources, classpath, outputDirectory, options, maxErrors, log) =>
-    {
-      type Inputs = FilesInfo[HashFileInfo] :+: FilesInfo[ModifiedFileInfo] :+: Seq[File] :+: File :+: Seq[String] :+: Int :+: HNil
-      val inputs: Inputs = hash(sources.toSet ++ optionFiles(options, fileInputOpts)) :+: lastModified(classpath.toSet) :+: classpath :+: outputDirectory :+: options :+: maxErrors :+: HNil
-      implicit val stringEquiv: Equiv[String] = defaultEquiv
-      implicit val fileEquiv: Equiv[File] = defaultEquiv
-      implicit val intEquiv: Equiv[Int] = defaultEquiv
-      val cachedComp = inputChanged(cache / "inputs") { (inChanged, in: Inputs) =>
-        outputChanged(cache / "output") { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
-          if (inChanged || outChanged)
-            doCompile(sources, classpath, outputDirectory, options, maxErrors, log)
-          else
-            log.debug("Uptodate: " + outputDirectory.getAbsolutePath)
-        }
-      }
-      cachedComp(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
-    }
-  def prepare(description: String, doCompile: Gen): Gen = (sources, classpath, outputDirectory, options, maxErrors, log) =>
-    {
+  def prepare(description: String, doCompile: Gen): Gen =
+    (sources, classpath, outputDirectory, options, maxErrors, log) => {
       if (sources.isEmpty)
         log.info("No sources available, skipping " + description + "...")
       else {
@@ -70,16 +80,24 @@ object RawCompileLike {
         log.info(description.capitalize + " successful.")
       }
     }
-  def filterSources(f: File => Boolean, doCompile: Gen): Gen = (sources, classpath, outputDirectory, options, maxErrors, log) =>
-    doCompile(sources filter f, classpath, outputDirectory, options, maxErrors, log)
 
-  def rawCompile(instance: ScalaInstance, cpOptions: ClasspathOptions): Gen = (sources, classpath, outputDirectory, options, maxErrors, log) =>
-    {
+  def filterSources(f: File => Boolean, doCompile: Gen): Gen =
+    (sources, classpath, outputDirectory, options, maxErrors, log) =>
+      doCompile(sources filter f, classpath, outputDirectory, options, maxErrors, log)
+
+  def rawCompile(instance: ScalaInstance, cpOptions: ClasspathOptions): Gen =
+    (sources, classpath, outputDirectory, options, _, log) => {
       val compiler = new RawCompiler(instance, cpOptions, log)
-      compiler(sources, classpath, outputDirectory, options)
+      compiler(sources.map(_.toPath), classpath.map(_.toPath), outputDirectory.toPath, options)
     }
-  def compile(label: String, cache: File, instance: ScalaInstance, cpOptions: ClasspathOptions): Gen =
-    cached(cache, prepare(label + " sources", rawCompile(instance, cpOptions)))
 
-  val nop: Gen = (sources, classpath, outputDirectory, options, maxErrors, log) => ()
+  def compile(
+      label: String,
+      cacheStoreFactory: CacheStoreFactory,
+      instance: ScalaInstance,
+      cpOptions: ClasspathOptions
+  ): Gen =
+    cached(cacheStoreFactory, prepare(label + " sources", rawCompile(instance, cpOptions)))
+
+  val nop: Gen = (_, _, _, _, _, _) => ()
 }
diff --git a/main-actions/src/main/scala/sbt/Sync.scala b/main-actions/src/main/scala/sbt/Sync.scala
index df23912ad..b0a3f3b46 100644
--- a/main-actions/src/main/scala/sbt/Sync.scala
+++ b/main-actions/src/main/scala/sbt/Sync.scala
@@ -1,14 +1,22 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import java.io.File
-
-import sbt.internal.util.{ FileInfo, Relation }
-
+import java.io.{ File, IOException }
+import java.util.zip.ZipException
+import sbt.internal.util.Relation
+import sbt.internal.io.TranslatedException
+import sbt.util.CacheImplicits._
+import sbt.util.{ FileInfo, CacheStore }
 import sbt.io.IO
 
+import sjsonnew.{ Builder, JsonFormat, Unbuilder, deserializationError }
+
 /**
  * Maintains a set of mappings so that they are uptodate.
  * Specifically, 'apply' applies the mappings by creating target directories and copying source files to their destination.
@@ -22,77 +30,113 @@ import sbt.io.IO
  * It is safe to use for its intended purpose: copying resources to a class output directory.
  */
 object Sync {
-  def apply(cacheFile: File, inStyle: FileInfo.Style = FileInfo.lastModified, outStyle: FileInfo.Style = FileInfo.exists): Traversable[(File, File)] => Relation[File, File] =
-    mappings =>
-      {
-        val relation = Relation.empty ++ mappings
-        noDuplicateTargets(relation)
-        val currentInfo = relation._1s.map(s => (s, inStyle(s))).toMap
+  @deprecated("Use sync, which doesn't take the unused outStyle param", "1.1.1")
+  def apply(
+      store: CacheStore,
+      inStyle: FileInfo.Style = FileInfo.lastModified,
+      outStyle: FileInfo.Style = FileInfo.exists,
+  ): Traversable[(File, File)] => Relation[File, File] =
+    sync(store, inStyle)
 
-        val (previousRelation, previousInfo) = readInfo(cacheFile)(inStyle.format)
-        val removeTargets = previousRelation._2s -- relation._2s
+  def sync(
+      store: CacheStore,
+      inStyle: FileInfo.Style = FileInfo.lastModified,
+  ): Traversable[(File, File)] => Relation[File, File] =
+    mappings => {
+      val relation = Relation.empty ++ mappings
+      noDuplicateTargets(relation)
+      val currentInfo = relation._1s.map(s => (s, inStyle(s))).toMap
 
-        def outofdate(source: File, target: File): Boolean =
-          !previousRelation.contains(source, target) ||
-            (previousInfo get source) != (currentInfo get source) ||
-            !target.exists ||
-            target.isDirectory != source.isDirectory
+      val (previousRelation, previousInfo) = readInfo(store)(inStyle.format)
+      val removeTargets = previousRelation._2s -- relation._2s
 
-        val updates = relation filter outofdate
+      def outofdate(source: File, target: File): Boolean =
+        !previousRelation.contains(source, target) ||
+          (previousInfo get source) != (currentInfo get source) ||
+          !target.exists ||
+          target.isDirectory != source.isDirectory
 
-        val (cleanDirs, cleanFiles) = (updates._2s ++ removeTargets).partition(_.isDirectory)
+      val updates = relation filter outofdate
 
-        IO.delete(cleanFiles)
-        IO.deleteIfEmpty(cleanDirs)
-        updates.all.foreach((copy _).tupled)
+      val (cleanDirs, cleanFiles) = (updates._2s ++ removeTargets).partition(_.isDirectory)
 
-        writeInfo(cacheFile, relation, currentInfo)(inStyle.format)
-        relation
-      }
+      IO.delete(cleanFiles)
+      IO.deleteIfEmpty(cleanDirs)
+      updates.all.foreach((copy _).tupled)
+
+      writeInfo(store, relation, currentInfo)(inStyle.format)
+      relation
+    }
 
   def copy(source: File, target: File): Unit =
     if (source.isFile)
       IO.copyFile(source, target, true)
-    else if (!target.exists) // we don't want to update the last modified time of an existing directory
-    {
+    else if (!target.exists) { // we don't want to update the last modified time of an existing directory
       IO.createDirectory(target)
       IO.copyLastModified(source, target)
+      ()
     }
 
   def noDuplicateTargets(relation: Relation[File, File]): Unit = {
-    val dups = relation.reverseMap.filter {
-      case (target, srcs) =>
-        srcs.size >= 2 && srcs.exists(!_.isDirectory)
-    } map {
-      case (target, srcs) =>
-        "\n\t" + target + "\nfrom\n\t" + srcs.mkString("\n\t\t")
-    }
+    val dups = relation.reverseMap
+      .filter { case (_, srcs) => srcs.size >= 2 && srcs.exists(!_.isDirectory) }
+      .map { case (target, srcs) => "\n\t" + target + "\nfrom\n\t" + srcs.mkString("\n\t\t") }
     if (dups.nonEmpty)
       sys.error("Duplicate mappings:" + dups.mkString)
   }
 
-  import java.io.{ File, IOException }
-  import sbinary._
-  import Operations.{ read, write }
-  import DefaultProtocol.{ FileFormat => _, _ }
-  //import sbt.inc.AnalysisFormats.{ fileFormat, relationFormat }
-  implicit def fileFormat: Format[File] = wrap[File, String](_.getAbsolutePath, s => new File(s))
-  implicit def relationFormat[A, B](implicit af: Format[Map[A, Set[B]]], bf: Format[Map[B, Set[A]]]): Format[Relation[A, B]] =
-    asProduct2[Relation[A, B], Map[A, Set[B]], Map[B, Set[A]]](Relation.make _)(r => (r.forwardMap, r.reverseMap))(af, bf)
+  implicit def relationFormat[A, B](
+      implicit af: JsonFormat[Map[A, Set[B]]],
+      bf: JsonFormat[Map[B, Set[A]]]
+  ): JsonFormat[Relation[A, B]] =
+    new JsonFormat[Relation[A, B]] {
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Relation[A, B] =
+        jsOpt match {
+          case Some(js) =>
+            unbuilder.beginArray(js)
+            val jForward = unbuilder.nextElement
+            val jReverse = unbuilder.nextElement
+            unbuilder.endArray()
+            Relation.make(af.read(Some(jForward), unbuilder), bf.read(Some(jReverse), unbuilder))
+          case None =>
+            deserializationError("Expected JsArray but found None")
+        }
+
+      def write[J](obj: Relation[A, B], builder: Builder[J]): Unit = {
+        builder.beginArray()
+        af.write(obj.forwardMap, builder)
+        bf.write(obj.reverseMap, builder)
+        builder.endArray()
+      }
 
-  def writeInfo[F <: FileInfo](file: File, relation: Relation[File, File], info: Map[File, F])(implicit infoFormat: Format[F]): Unit =
-    IO.gzipFileOut(file) { out =>
-      write(out, (relation, info))
     }
 
+  def writeInfo[F <: FileInfo](
+      store: CacheStore,
+      relation: Relation[File, File],
+      info: Map[File, F]
+  )(implicit infoFormat: JsonFormat[F]): Unit =
+    store.write((relation, info))
+
   type RelationInfo[F] = (Relation[File, File], Map[File, F])
 
-  def readInfo[F <: FileInfo](file: File)(implicit infoFormat: Format[F]): RelationInfo[F] =
-    try { readUncaught(file)(infoFormat) }
-    catch { case e: IOException => (Relation.empty, Map.empty) }
-
-  def readUncaught[F <: FileInfo](file: File)(implicit infoFormat: Format[F]): RelationInfo[F] =
-    IO.gzipFileIn(file) { in =>
-      read[RelationInfo[F]](in)
+  def readInfo[F <: FileInfo](
+      store: CacheStore
+  )(implicit infoFormat: JsonFormat[F]): RelationInfo[F] =
+    try {
+      readUncaught[F](store)(infoFormat)
+    } catch {
+      case _: IOException  => (Relation.empty[File, File], Map.empty[File, F])
+      case _: ZipException => (Relation.empty[File, File], Map.empty[File, F])
+      case e: TranslatedException =>
+        e.getCause match {
+          case _: ZipException => (Relation.empty[File, File], Map.empty[File, F])
+          case _               => throw e
+        }
     }
+
+  private def readUncaught[F <: FileInfo](
+      store: CacheStore
+  )(implicit infoFormat: JsonFormat[F]): RelationInfo[F] =
+    store.read(default = (Relation.empty[File, File], Map.empty[File, F]))
 }
diff --git a/main-actions/src/main/scala/sbt/TestResultLogger.scala b/main-actions/src/main/scala/sbt/TestResultLogger.scala
index 708e9c781..d7675fb34 100644
--- a/main-actions/src/main/scala/sbt/TestResultLogger.scala
+++ b/main-actions/src/main/scala/sbt/TestResultLogger.scala
@@ -1,6 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import sbt.Tests.{ Output, Summary }
+import sbt.protocol.testing.TestResult
 import sbt.util.{ Level, Logger }
 
 /**
@@ -23,11 +31,17 @@ trait TestResultLogger {
   def run(log: Logger, results: Output, taskName: String): Unit
 
   /** Only allow invocation if certain criteria is met, else use another `TestResultLogger` (defaulting to nothing) . */
-  final def onlyIf(f: (Output, String) => Boolean, otherwise: TestResultLogger = TestResultLogger.Null) =
+  final def onlyIf(
+      f: (Output, String) => Boolean,
+      otherwise: TestResultLogger = TestResultLogger.Null
+  ) =
     TestResultLogger.choose(f, this, otherwise)
 
   /** Allow invocation unless a certain predicate passes, in which case use another `TestResultLogger` (defaulting to nothing) . */
-  final def unless(f: (Output, String) => Boolean, otherwise: TestResultLogger = TestResultLogger.Null) =
+  final def unless(
+      f: (Output, String) => Boolean,
+      otherwise: TestResultLogger = TestResultLogger.Null
+  ) =
     TestResultLogger.choose(f, otherwise, this)
 }
 
@@ -36,7 +50,7 @@ object TestResultLogger {
   /** A `TestResultLogger` that does nothing. */
   val Null = const(_ => ())
 
-  /** SBT's default `TestResultLogger`. Use `copy()` to change selective portions. */
+  /** sbt's default `TestResultLogger`. Use `copy()` to change selective portions. */
   val Default = Defaults.Main()
 
   /** Twist on the default which is completely silent when the subject module doesn't contain any tests. */
@@ -44,10 +58,7 @@ object TestResultLogger {
 
   /** Creates a `TestResultLogger` using a given function. */
   def apply(f: (Logger, Output, String) => Unit): TestResultLogger =
-    new TestResultLogger {
-      override def run(log: Logger, results: Output, taskName: String) =
-        f(log, results, taskName)
-    }
+    (log, results, taskName) => f(log, results, taskName)
 
   /** Creates a `TestResultLogger` that ignores its input and always performs the same logging. */
   def const(f: Logger => Unit) = apply((l, _, _) => f(l))
@@ -59,8 +70,10 @@ object TestResultLogger {
    * @param f The `TestResultLogger` to choose if the predicate fails.
    */
   def choose(cond: (Output, String) => Boolean, t: TestResultLogger, f: TestResultLogger) =
-    TestResultLogger((log, results, taskName) =>
-      (if (cond(results, taskName)) t else f).run(log, results, taskName))
+    TestResultLogger(
+      (log, results, taskName) =>
+        (if (cond(results, taskName)) t else f).run(log, results, taskName)
+    )
 
   /** Transforms the input to be completely silent when the subject module doesn't contain any tests. */
   def silenceWhenNoTests(d: Defaults.Main) =
@@ -71,13 +84,14 @@ object TestResultLogger {
 
   object Defaults {
 
-    /** SBT's default `TestResultLogger`. Use `copy()` to change selective portions. */
+    /** sbt's default `TestResultLogger`. Use `copy()` to change selective portions. */
     case class Main(
         printStandard_? : Output => Boolean = Defaults.printStandard_?,
         printSummary: TestResultLogger = Defaults.printSummary,
         printStandard: TestResultLogger = Defaults.printStandard,
         printFailures: TestResultLogger = Defaults.printFailures,
-        printNoTests: TestResultLogger = Defaults.printNoTests) extends TestResultLogger {
+        printNoTests: TestResultLogger = Defaults.printNoTests
+    ) extends TestResultLogger {
 
       override def run(log: Logger, results: Output, taskName: String): Unit = {
         def run(r: TestResultLogger): Unit = r.run(log, results, taskName)
@@ -116,16 +130,39 @@ object TestResultLogger {
         results.summaries.size > 1 || results.summaries.headOption.forall(_.summaryText.isEmpty)
 
     val printStandard = TestResultLogger((log, results, _) => {
-      val (skippedCount, errorsCount, passedCount, failuresCount, ignoredCount, canceledCount, pendingCount) =
+      val (
+        skippedCount,
+        errorsCount,
+        passedCount,
+        failuresCount,
+        ignoredCount,
+        canceledCount,
+        pendingCount,
+      ) =
         results.events.foldLeft((0, 0, 0, 0, 0, 0, 0)) {
-          case ((skippedAcc, errorAcc, passedAcc, failureAcc, ignoredAcc, canceledAcc, pendingAcc), (name, testEvent)) =>
-            (skippedAcc + testEvent.skippedCount, errorAcc + testEvent.errorCount, passedAcc + testEvent.passedCount, failureAcc + testEvent.failureCount,
-              ignoredAcc + testEvent.ignoredCount, canceledAcc + testEvent.canceledCount, pendingAcc + testEvent.pendingCount)
+          case (acc, (_, testEvent)) =>
+            val (skippedAcc, errorAcc, passedAcc, failureAcc, ignoredAcc, canceledAcc, pendingAcc) =
+              acc
+            (
+              skippedAcc + testEvent.skippedCount,
+              errorAcc + testEvent.errorCount,
+              passedAcc + testEvent.passedCount,
+              failureAcc + testEvent.failureCount,
+              ignoredAcc + testEvent.ignoredCount,
+              canceledAcc + testEvent.canceledCount,
+              pendingAcc + testEvent.pendingCount,
+            )
         }
       val totalCount = failuresCount + errorsCount + skippedCount + passedCount
-      val base = s"Total $totalCount, Failed $failuresCount, Errors $errorsCount, Passed $passedCount"
+      val base =
+        s"Total $totalCount, Failed $failuresCount, Errors $errorsCount, Passed $passedCount"
 
-      val otherCounts = Seq("Skipped" -> skippedCount, "Ignored" -> ignoredCount, "Canceled" -> canceledCount, "Pending" -> pendingCount)
+      val otherCounts = Seq(
+        "Skipped" -> skippedCount,
+        "Ignored" -> ignoredCount,
+        "Canceled" -> canceledCount,
+        "Pending" -> pendingCount
+      )
       val extra = otherCounts.filter(_._2 > 0).map { case (label, count) => s", $label $count" }
 
       val postfix = base + extra.mkString
@@ -137,7 +174,7 @@ object TestResultLogger {
     })
 
     val printFailures = TestResultLogger((log, results, _) => {
-      def select(resultTpe: TestResult.Value) = results.events collect {
+      def select(resultTpe: TestResult) = results.events collect {
         case (name, tpe) if tpe.result == resultTpe =>
           scala.reflect.NameTransformer.decode(name)
       }
@@ -153,8 +190,8 @@ object TestResultLogger {
       show("Error during tests:", Level.Error, select(TestResult.Error))
     })
 
-    val printNoTests = TestResultLogger((log, results, taskName) =>
-      log.info("No tests to run for " + taskName)
+    val printNoTests = TestResultLogger(
+      (log, results, taskName) => log.info("No tests to run for " + taskName)
     )
   }
 }
diff --git a/main-actions/src/main/scala/sbt/Tests.scala b/main-actions/src/main/scala/sbt/Tests.scala
index 5148a3db4..90f64b29e 100644
--- a/main-actions/src/main/scala/sbt/Tests.scala
+++ b/main-actions/src/main/scala/sbt/Tests.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import std._
@@ -9,16 +13,32 @@ import sbt.internal.inc.Analysis
 import TaskExtra._
 import sbt.internal.util.FeedbackProvidedException
 import xsbti.api.Definition
+import xsbti.api.ClassLike
 import xsbti.compile.CompileAnalysis
 import ConcurrentRestrictions.Tag
+import testing.{
+  AnnotatedFingerprint,
+  Fingerprint,
+  Framework,
+  Runner,
+  Selector,
+  SubclassFingerprint,
+  SuiteSelector,
+  TaskDef,
+  Task => TestTask
+}
 
-import testing.{ AnnotatedFingerprint, Fingerprint, Framework, SubclassFingerprint, Runner, TaskDef, SuiteSelector, Task => TestTask }
 import scala.annotation.tailrec
-
+import sbt.internal.util.ManagedLogger
 import sbt.util.Logger
+import sbt.protocol.testing.TestResult
+
+import scala.runtime.AbstractFunction3
 
 sealed trait TestOption
+
 object Tests {
+
   /**
    * The result of a test run.
    *
@@ -26,7 +46,11 @@ object Tests {
    * @param events The result of each test group (suite) executed during this test run.
    * @param summaries Explicit summaries directly provided by test frameworks.  This may be empty, in which case a default summary will be generated.
    */
-  final case class Output(overall: TestResult.Value, events: Map[String, SuiteResult], summaries: Iterable[Summary])
+  final case class Output(
+      overall: TestResult,
+      events: Map[String, SuiteResult],
+      summaries: Iterable[Summary]
+  )
 
   /**
    * Summarizes a test run.
@@ -108,113 +132,308 @@ object Tests {
 
   /** Configures a group of tests to be forked in a new JVM with forking options specified by `config`. */
   final case class SubProcess(config: ForkOptions) extends TestRunPolicy
-  object SubProcess {
-    @deprecated("Construct SubProcess with a ForkOptions argument.", "0.13.0")
-    def apply(javaOptions: Seq[String]): SubProcess = SubProcess(ForkOptions(runJVMOptions = javaOptions))
-  }
 
   /** A named group of tests configured to run in the same JVM or be forked. */
-  final case class Group(name: String, tests: Seq[TestDefinition], runPolicy: TestRunPolicy)
+  final class Group(
+      val name: String,
+      val tests: Seq[TestDefinition],
+      val runPolicy: TestRunPolicy,
+      val tags: Seq[(Tag, Int)]
+  ) extends Product
+      with Serializable {
+
+    def this(name: String, tests: Seq[TestDefinition], runPolicy: TestRunPolicy) = {
+      this(name, tests, runPolicy, Seq.empty)
+    }
+
+    def withName(name: String): Group = {
+      new Group(name, tests, runPolicy, tags)
+    }
+
+    def withTests(tests: Seq[TestDefinition]): Group = {
+      new Group(name, tests, runPolicy, tags)
+    }
+
+    def withRunPolicy(runPolicy: TestRunPolicy): Group = {
+      new Group(name, tests, runPolicy, tags)
+    }
+
+    def withTags(tags: Seq[(Tag, Int)]): Group = {
+      new Group(name, tests, runPolicy, tags)
+    }
+
+    //- EXPANDED CASE CLASS METHOD BEGIN -//
+    @deprecated("Methods generated for case class will be removed in the future.", "1.4.0")
+    def copy(
+        name: String = this.name,
+        tests: Seq[TestDefinition] = this.tests,
+        runPolicy: TestRunPolicy = this.runPolicy
+    ): Group = {
+      new Group(name, tests, runPolicy, this.tags)
+    }
+
+    @deprecated("Methods generated for case class will be removed in the future.", "1.4.0")
+    override def productElement(x$1: Int): Any = x$1 match {
+      case 0 => Group.this.name
+      case 1 => Group.this.tests
+      case 2 => Group.this.runPolicy
+      case 3 => Group.this.tags
+    }
+
+    @deprecated("Methods generated for case class will be removed in the future.", "1.4.0")
+    override def productArity: Int = 4
+
+    @deprecated("Methods generated for case class will be removed in the future.", "1.4.0")
+    def canEqual(x$1: Any): Boolean = x$1.isInstanceOf[Group]
+
+    override def hashCode(): Int = {
+      scala.runtime.ScalaRunTime._hashCode(Group.this)
+    }
+
+    override def toString(): String = scala.runtime.ScalaRunTime._toString(Group.this)
+
+    override def equals(x$1: Any): Boolean = {
+      this.eq(x$1.asInstanceOf[Object]) || (x$1.isInstanceOf[Group] && ({
+        val Group$1: Group = x$1.asInstanceOf[Group]
+        name == Group$1.name && tests == Group$1.tests &&
+        runPolicy == Group$1.runPolicy && tags == Group$1.tags
+      }))
+    }
+    //- EXPANDED CASE CLASS METHOD END -//
+  }
+
+  object Group
+      extends AbstractFunction3[String, Seq[TestDefinition], TestRunPolicy, Group]
+      with Serializable {
+    //- EXPANDED CASE CLASS METHOD BEGIN -//
+    final override def toString(): String = "Group"
+    def apply(
+        name: String,
+        tests: Seq[TestDefinition],
+        runPolicy: TestRunPolicy
+    ): Group = {
+      new Group(name, tests, runPolicy, Seq.empty)
+    }
+
+    def apply(
+        name: String,
+        tests: Seq[TestDefinition],
+        runPolicy: TestRunPolicy,
+        tags: Seq[(Tag, Int)]
+    ): Group = {
+      new Group(name, tests, runPolicy, tags)
+    }
+
+    @deprecated("Methods generated for case class will be removed in the future.", "1.4.0")
+    def unapply(
+        x$0: Group
+    ): Option[(String, Seq[TestDefinition], TestRunPolicy)] = {
+      if (x$0 == null) None
+      else
+        Some.apply[(String, Seq[TestDefinition], TestRunPolicy)](
+          Tuple3.apply[String, Seq[TestDefinition], TestRunPolicy](
+            x$0.name,
+            x$0.tests,
+            x$0.runPolicy
+          )
+        )
+    }
+    private def readResolve(): Object = Group
+    //- EXPANDED CASE CLASS METHOD END -//
+  }
 
   private[sbt] final class ProcessedOptions(
-    val tests: Seq[TestDefinition],
-    val setup: Seq[ClassLoader => Unit],
-    val cleanup: Seq[ClassLoader => Unit],
-    val testListeners: Seq[TestReportListener])
-  private[sbt] def processOptions(config: Execution, discovered: Seq[TestDefinition], log: Logger): ProcessedOptions =
-    {
-      import collection.mutable.{ HashSet, ListBuffer }
-      val testFilters = new ListBuffer[String => Boolean]
-      var orderedFilters = Seq[String => Boolean]()
-      val excludeTestsSet = new HashSet[String]
-      val setup, cleanup = new ListBuffer[ClassLoader => Unit]
-      val testListeners = new ListBuffer[TestReportListener]
-      val undefinedFrameworks = new ListBuffer[String]
+      val tests: Vector[TestDefinition],
+      val setup: Vector[ClassLoader => Unit],
+      val cleanup: Vector[ClassLoader => Unit],
+      val testListeners: Vector[TestReportListener]
+  )
+  private[sbt] def processOptions(
+      config: Execution,
+      discovered: Vector[TestDefinition],
+      log: Logger
+  ): ProcessedOptions = {
+    import collection.mutable.{ HashSet, ListBuffer }
+    val testFilters = new ListBuffer[String => Boolean]
+    var orderedFilters = Seq[String => Boolean]()
+    val excludeTestsSet = new HashSet[String]
+    val setup, cleanup = new ListBuffer[ClassLoader => Unit]
+    val testListeners = new ListBuffer[TestReportListener]
+    val undefinedFrameworks = new ListBuffer[String]
 
-      for (option <- config.options) {
-        option match {
-          case Filter(include)          => testFilters += include
-          case Filters(includes)        => if (orderedFilters.nonEmpty) sys.error("Cannot define multiple ordered test filters.") else orderedFilters = includes
-          case Exclude(exclude)         => excludeTestsSet ++= exclude
-          case Listeners(listeners)     => testListeners ++= listeners
-          case Setup(setupFunction)     => setup += setupFunction
-          case Cleanup(cleanupFunction) => cleanup += cleanupFunction
-          case a: Argument              => // now handled by whatever constructs `runners`
+    for (option <- config.options) {
+      option match {
+        case Filter(include) => testFilters += include; ()
+        case Filters(includes) =>
+          if (orderedFilters.nonEmpty) sys.error("Cannot define multiple ordered test filters.")
+          else orderedFilters = includes
+          ()
+        case Exclude(exclude)         => excludeTestsSet ++= exclude; ()
+        case Listeners(listeners)     => testListeners ++= listeners; ()
+        case Setup(setupFunction)     => setup += setupFunction; ()
+        case Cleanup(cleanupFunction) => cleanup += cleanupFunction; ()
+        case _: Argument              => // now handled by whatever constructs `runners`
+      }
+    }
+
+    if (excludeTestsSet.nonEmpty)
+      log.debug(excludeTestsSet.mkString("Excluding tests: \n\t", "\n\t", ""))
+    if (undefinedFrameworks.nonEmpty)
+      log.warn(
+        "Arguments defined for test frameworks that are not present:\n\t" + undefinedFrameworks
+          .mkString("\n\t")
+      )
+
+    def includeTest(test: TestDefinition) =
+      !excludeTestsSet.contains(test.name) && testFilters.forall(filter => filter(test.name))
+    val filtered0 = discovered.filter(includeTest).toList.distinct
+    val tests =
+      if (orderedFilters.isEmpty) filtered0
+      else orderedFilters.flatMap(f => filtered0.filter(d => f(d.name))).toList.distinct
+    val uniqueTests = distinctBy(tests)(_.name)
+    new ProcessedOptions(
+      uniqueTests.toVector,
+      setup.toVector,
+      cleanup.toVector,
+      testListeners.toVector
+    )
+  }
+
+  private[this] def distinctBy[T, K](in: Seq[T])(f: T => K): Seq[T] = {
+    val seen = new collection.mutable.HashSet[K]
+    in.filter(t => seen.add(f(t)))
+  }
+
+  def apply(
+      frameworks: Map[TestFramework, Framework],
+      testLoader: ClassLoader,
+      runners: Map[TestFramework, Runner],
+      o: ProcessedOptions,
+      config: Execution,
+      log: ManagedLogger
+  ): Task[Output] = {
+    testTask(
+      testLoader,
+      frameworks,
+      runners,
+      o.tests,
+      o.setup,
+      o.cleanup,
+      log,
+      o.testListeners,
+      config
+    )
+  }
+
+  def apply(
+      frameworks: Map[TestFramework, Framework],
+      testLoader: ClassLoader,
+      runners: Map[TestFramework, Runner],
+      discovered: Vector[TestDefinition],
+      config: Execution,
+      log: ManagedLogger
+  ): Task[Output] = {
+    val o = processOptions(config, discovered, log)
+    apply(frameworks, testLoader, runners, o, config, log)
+  }
+
+  def testTask(
+      loader: ClassLoader,
+      frameworks: Map[TestFramework, Framework],
+      runners: Map[TestFramework, Runner],
+      tests: Vector[TestDefinition],
+      userSetup: Iterable[ClassLoader => Unit],
+      userCleanup: Iterable[ClassLoader => Unit],
+      log: ManagedLogger,
+      testListeners: Vector[TestReportListener],
+      config: Execution
+  ): Task[Output] = {
+    def fj(actions: Iterable[() => Unit]): Task[Unit] = nop.dependsOn(actions.toSeq.fork(_()): _*)
+    def partApp(actions: Iterable[ClassLoader => Unit]) = actions.toSeq map { a => () =>
+      a(loader)
+    }
+
+    val (frameworkSetup, runnables, frameworkCleanup) =
+      TestFramework.testTasks(frameworks, runners, loader, tests, log, testListeners)
+
+    val setupTasks = fj(partApp(userSetup) :+ frameworkSetup)
+    val mainTasks =
+      if (config.parallel)
+        makeParallel(loader, runnables, setupTasks, config.tags).map(_.toList)
+      else
+        makeSerial(loader, runnables, setupTasks)
+    val taggedMainTasks = mainTasks.tagw(config.tags: _*)
+    taggedMainTasks
+      .map(processResults)
+      .flatMap { results =>
+        val cleanupTasks = fj(partApp(userCleanup) :+ frameworkCleanup(results.overall))
+        cleanupTasks map { _ =>
+          results
         }
       }
-
-      if (excludeTestsSet.nonEmpty)
-        log.debug(excludeTestsSet.mkString("Excluding tests: \n\t", "\n\t", ""))
-      if (undefinedFrameworks.nonEmpty)
-        log.warn("Arguments defined for test frameworks that are not present:\n\t" + undefinedFrameworks.mkString("\n\t"))
-
-      def includeTest(test: TestDefinition) = !excludeTestsSet.contains(test.name) && testFilters.forall(filter => filter(test.name))
-      val filtered0 = discovered.filter(includeTest).toList.distinct
-      val tests = if (orderedFilters.isEmpty) filtered0 else orderedFilters.flatMap(f => filtered0.filter(d => f(d.name))).toList.distinct
-      val uniqueTests = distinctBy(tests)(_.name)
-      new ProcessedOptions(uniqueTests, setup.toList, cleanup.toList, testListeners.toList)
-    }
-
-  private[this] def distinctBy[T, K](in: Seq[T])(f: T => K): Seq[T] =
-    {
-      val seen = new collection.mutable.HashSet[K]
-      in.filter(t => seen.add(f(t)))
-    }
-
-  def apply(frameworks: Map[TestFramework, Framework], testLoader: ClassLoader, runners: Map[TestFramework, Runner], discovered: Seq[TestDefinition], config: Execution, log: Logger): Task[Output] =
-    {
-      val o = processOptions(config, discovered, log)
-      testTask(testLoader, frameworks, runners, o.tests, o.setup, o.cleanup, log, o.testListeners, config)
-    }
-
-  def testTask(loader: ClassLoader, frameworks: Map[TestFramework, Framework], runners: Map[TestFramework, Runner], tests: Seq[TestDefinition],
-    userSetup: Iterable[ClassLoader => Unit], userCleanup: Iterable[ClassLoader => Unit],
-    log: Logger, testListeners: Seq[TestReportListener], config: Execution): Task[Output] =
-    {
-      def fj(actions: Iterable[() => Unit]): Task[Unit] = nop.dependsOn(actions.toSeq.fork(_()): _*)
-      def partApp(actions: Iterable[ClassLoader => Unit]) = actions.toSeq map { a => () => a(loader) }
-
-      val (frameworkSetup, runnables, frameworkCleanup) =
-        TestFramework.testTasks(frameworks, runners, loader, tests, log, testListeners)
-
-      val setupTasks = fj(partApp(userSetup) :+ frameworkSetup)
-      val mainTasks =
-        if (config.parallel)
-          makeParallel(loader, runnables, setupTasks, config.tags) //.toSeq.join
-        else
-          makeSerial(loader, runnables, setupTasks, config.tags)
-      val taggedMainTasks = mainTasks.tagw(config.tags: _*)
-      taggedMainTasks map processResults flatMap { results =>
-        val cleanupTasks = fj(partApp(userCleanup) :+ frameworkCleanup(results.overall))
-        cleanupTasks map { _ => results }
-      }
-    }
+  }
   type TestRunnable = (String, TestFunction)
 
-  private def createNestedRunnables(loader: ClassLoader, testFun: TestFunction, nestedTasks: Seq[TestTask]): Seq[(String, TestFunction)] =
-    nestedTasks.view.zipWithIndex map {
+  private def createNestedRunnables(
+      loader: ClassLoader,
+      testFun: TestFunction,
+      nestedTasks: Seq[TestTask]
+  ): Seq[(String, TestFunction)] =
+    (nestedTasks.view.zipWithIndex map {
       case (nt, idx) =>
         val testFunDef = testFun.taskDef
-        (testFunDef.fullyQualifiedName, TestFramework.createTestFunction(loader, new TaskDef(testFunDef.fullyQualifiedName + "-" + idx, testFunDef.fingerprint, testFunDef.explicitlySpecified, testFunDef.selectors), testFun.runner, nt))
-    }
+        (
+          testFunDef.fullyQualifiedName,
+          TestFramework.createTestFunction(
+            loader,
+            new TaskDef(
+              testFunDef.fullyQualifiedName + "-" + idx,
+              testFunDef.fingerprint,
+              testFunDef.explicitlySpecified,
+              testFunDef.selectors
+            ),
+            testFun.runner,
+            nt
+          )
+        )
+    }).toSeq
 
-  def makeParallel(loader: ClassLoader, runnables: Iterable[TestRunnable], setupTasks: Task[Unit], tags: Seq[(Tag, Int)]): Task[Map[String, SuiteResult]] =
+  def makeParallel(
+      loader: ClassLoader,
+      runnables: Iterable[TestRunnable],
+      setupTasks: Task[Unit],
+      tags: Seq[(Tag, Int)]
+  ): Task[Map[String, SuiteResult]] =
     toTasks(loader, runnables.toSeq, tags).dependsOn(setupTasks)
 
-  def toTasks(loader: ClassLoader, runnables: Seq[TestRunnable], tags: Seq[(Tag, Int)]): Task[Map[String, SuiteResult]] = {
+  def toTasks(
+      loader: ClassLoader,
+      runnables: Seq[TestRunnable],
+      tags: Seq[(Tag, Int)]
+  ): Task[Map[String, SuiteResult]] = {
     val tasks = runnables.map { case (name, test) => toTask(loader, name, test, tags) }
     tasks.join.map(_.foldLeft(Map.empty[String, SuiteResult]) {
       case (sum, e) =>
         val merged = sum.toSeq ++ e.toSeq
         val grouped = merged.groupBy(_._1)
-        grouped.mapValues(_.map(_._2).foldLeft(SuiteResult.Empty) {
-          case (resultSum, result) => resultSum + result
-        })
+        grouped
+          .mapValues(_.map(_._2).foldLeft(SuiteResult.Empty) {
+            case (resultSum, result) => resultSum + result
+          })
+          .toMap
     })
   }
 
-  def toTask(loader: ClassLoader, name: String, fun: TestFunction, tags: Seq[(Tag, Int)]): Task[Map[String, SuiteResult]] = {
-    val base = task { (name, fun.apply()) }
+  def toTask(
+      loader: ClassLoader,
+      name: String,
+      fun: TestFunction,
+      tags: Seq[(Tag, Int)]
+  ): Task[Map[String, SuiteResult]] = {
+    val base = Task[(String, (SuiteResult, Seq[TestTask]))](
+      Info[(String, (SuiteResult, Seq[TestTask]))]().setName(name),
+      Pure(() => (name, fun.apply()), `inline` = false)
+    )
     val taggedBase = base.tagw(tags: _*).tag(fun.tags.map(ConcurrentRestrictions.Tag(_)): _*)
     taggedBase flatMap {
       case (name, (result, nested)) =>
@@ -230,44 +449,89 @@ object Tests {
     }
   }
 
-  def makeSerial(loader: ClassLoader, runnables: Seq[TestRunnable], setupTasks: Task[Unit], tags: Seq[(Tag, Int)]): Task[List[(String, SuiteResult)]] =
-    {
-      @tailrec
-      def processRunnable(runnableList: List[TestRunnable], acc: List[(String, SuiteResult)]): List[(String, SuiteResult)] =
-        runnableList match {
-          case hd :: rst =>
-            val testFun = hd._2
-            val (result, nestedTasks) = testFun.apply()
-            val nestedRunnables = createNestedRunnables(loader, testFun, nestedTasks)
-            processRunnable(nestedRunnables.toList ::: rst, (hd._1, result) :: acc)
-          case Nil => acc
-        }
+  @deprecated("Use the variant without tags", "1.1.1")
+  def makeSerial(
+      loader: ClassLoader,
+      runnables: Seq[TestRunnable],
+      setupTasks: Task[Unit],
+      tags: Seq[(Tag, Int)],
+  ): Task[List[(String, SuiteResult)]] =
+    makeSerial(loader, runnables, setupTasks)
 
-      task { processRunnable(runnables.toList, List.empty) } dependsOn (setupTasks)
-    }
+  def makeSerial(
+      loader: ClassLoader,
+      runnables: Seq[TestRunnable],
+      setupTasks: Task[Unit],
+  ): Task[List[(String, SuiteResult)]] = {
+    @tailrec
+    def processRunnable(
+        runnableList: List[TestRunnable],
+        acc: List[(String, SuiteResult)]
+    ): List[(String, SuiteResult)] =
+      runnableList match {
+        case hd :: rst =>
+          val testFun = hd._2
+          val (result, nestedTasks) = testFun.apply()
+          val nestedRunnables = createNestedRunnables(loader, testFun, nestedTasks)
+          processRunnable(nestedRunnables.toList ::: rst, (hd._1, result) :: acc)
+        case Nil => acc
+      }
+
+    task { processRunnable(runnables.toList, List.empty) } dependsOn (setupTasks)
+  }
 
   def processResults(results: Iterable[(String, SuiteResult)]): Output =
     Output(overall(results.map(_._2.result)), results.toMap, Iterable.empty)
+
+  private def severity(r: TestResult): Int =
+    r match {
+      case TestResult.Passed => 0
+      case TestResult.Failed => 1
+      case TestResult.Error  => 2
+    }
+
   def foldTasks(results: Seq[Task[Output]], parallel: Boolean): Task[Output] =
-    if (results.isEmpty)
+    if (results.isEmpty) {
       task { Output(TestResult.Passed, Map.empty, Nil) }
-    else if (parallel)
-      reduced(results.toIndexedSeq, {
-        case (Output(v1, m1, _), Output(v2, m2, _)) => Output(if (v1.id < v2.id) v2 else v1, m1 ++ m2, Iterable.empty)
-      })
-    else {
-      def sequence(tasks: List[Task[Output]], acc: List[Output]): Task[List[Output]] = tasks match {
-        case Nil      => task(acc.reverse)
-        case hd :: tl => hd flatMap { out => sequence(tl, out :: acc) }
-      }
+    } else if (parallel) {
+      reduced[Output](
+        results.toIndexedSeq, {
+          case (Output(v1, m1, _), Output(v2, m2, _)) =>
+            Output(
+              (if (severity(v1) < severity(v2)) v2 else v1): TestResult,
+              Map((m1.toSeq ++ m2.toSeq): _*),
+              Iterable.empty[Summary]
+            )
+        }
+      )
+    } else {
+      def sequence(tasks: List[Task[Output]], acc: List[Output]): Task[List[Output]] =
+        tasks match {
+          case Nil => task(acc.reverse)
+          case hd :: tl =>
+            hd flatMap { out =>
+              sequence(tl, out :: acc)
+            }
+        }
       sequence(results.toList, List()) map { ress =>
-        val (rs, ms) = ress.unzip { e => (e.overall, e.events) }
-        Output(overall(rs), ms reduce (_ ++ _), Iterable.empty)
+        val (rs, ms) = ress.unzip { e =>
+          (e.overall, e.events)
+        }
+        val m = ms reduce { (m1: Map[String, SuiteResult], m2: Map[String, SuiteResult]) =>
+          Map((m1.toSeq ++ m2.toSeq): _*)
+        }
+        Output(overall(rs), m, Iterable.empty)
       }
     }
-  def overall(results: Iterable[TestResult.Value]): TestResult.Value =
-    (TestResult.Passed /: results) { (acc, result) => if (acc.id < result.id) result else acc }
-  def discover(frameworks: Seq[Framework], analysis: CompileAnalysis, log: Logger): (Seq[TestDefinition], Set[String]) =
+  def overall(results: Iterable[TestResult]): TestResult =
+    results.foldLeft(TestResult.Passed: TestResult) { (acc, result) =>
+      if (severity(acc) < severity(result)) result else acc
+    }
+  def discover(
+      frameworks: Seq[Framework],
+      analysis: CompileAnalysis,
+      log: Logger
+  ): (Seq[TestDefinition], Set[String]) =
     discover(frameworks flatMap TestFramework.getFingerprints, allDefs(analysis), log)
 
   def allDefs(analysis: CompileAnalysis) = analysis match {
@@ -276,39 +540,57 @@ object Tests {
       acs.flatMap { ac =>
         val companions = ac.api
         val all =
-          Seq(companions.classApi, companions.objectApi) ++
-            companions.classApi.structure.declared ++ companions.classApi.structure.inherited ++
-            companions.objectApi.structure.declared ++ companions.objectApi.structure.inherited
+          Seq(companions.classApi: Definition, companions.objectApi: Definition) ++
+            (companions.classApi.structure.declared.toSeq: Seq[Definition]) ++
+            (companions.classApi.structure.inherited.toSeq: Seq[Definition]) ++
+            (companions.objectApi.structure.declared.toSeq: Seq[Definition]) ++
+            (companions.objectApi.structure.inherited.toSeq: Seq[Definition])
 
         all
       }.toSeq
   }
-  def discover(fingerprints: Seq[Fingerprint], definitions: Seq[Definition], log: Logger): (Seq[TestDefinition], Set[String]) =
-    {
-      val subclasses = fingerprints collect { case sub: SubclassFingerprint => (sub.superclassName, sub.isModule, sub) };
-      val annotations = fingerprints collect { case ann: AnnotatedFingerprint => (ann.annotationName, ann.isModule, ann) };
-      log.debug("Subclass fingerprints: " + subclasses)
-      log.debug("Annotation fingerprints: " + annotations)
+  def discover(
+      fingerprints: Seq[Fingerprint],
+      definitions: Seq[Definition],
+      log: Logger
+  ): (Seq[TestDefinition], Set[String]) = {
+    val subclasses = fingerprints collect {
+      case sub: SubclassFingerprint => (sub.superclassName, sub.isModule, sub)
+    };
+    val annotations = fingerprints collect {
+      case ann: AnnotatedFingerprint => (ann.annotationName, ann.isModule, ann)
+    };
+    log.debug("Subclass fingerprints: " + subclasses)
+    log.debug("Annotation fingerprints: " + annotations)
 
-      def firsts[A, B, C](s: Seq[(A, B, C)]): Set[A] = s.map(_._1).toSet
-      def defined(in: Seq[(String, Boolean, Fingerprint)], names: Set[String], IsModule: Boolean): Seq[Fingerprint] =
-        in collect { case (name, IsModule, print) if names(name) => print }
+    def firsts[A, B, C](s: Seq[(A, B, C)]): Set[A] = s.map(_._1).toSet
+    def defined(
+        in: Seq[(String, Boolean, Fingerprint)],
+        names: Set[String],
+        IsModule: Boolean
+    ): Seq[Fingerprint] =
+      in collect { case (name, IsModule, print) if names(name) => print }
 
-      def toFingerprints(d: Discovered): Seq[Fingerprint] =
-        defined(subclasses, d.baseClasses, d.isModule) ++
-          defined(annotations, d.annotations, d.isModule)
+    def toFingerprints(d: Discovered): Seq[Fingerprint] =
+      defined(subclasses, d.baseClasses, d.isModule) ++
+        defined(annotations, d.annotations, d.isModule)
 
-      val discovered = Discovery(firsts(subclasses), firsts(annotations))(definitions)
-      // TODO: To pass in correct explicitlySpecified and selectors
-      val tests = for ((df, di) <- discovered; fingerprint <- toFingerprints(di)) yield new TestDefinition(df.name, fingerprint, false, Array(new SuiteSelector))
-      val mains = discovered collect { case (df, di) if di.hasMain => df.name }
-      (tests, mains.toSet)
-    }
-
-  @deprecated("Tests.showResults() has been superseded with TestResultLogger and setting 'testResultLogger'.", "0.13.5")
-  def showResults(log: Logger, results: Output, noTestsMessage: => String): Unit =
-    TestResultLogger.Default.copy(printNoTests = TestResultLogger.const(_ info noTestsMessage))
-      .run(log, results, "")
+    val discovered = Discovery(firsts(subclasses), firsts(annotations))(definitions.filter {
+      case c: ClassLike =>
+        c.topLevel
+      case _ => false
+    })
+    // TODO: To pass in correct explicitlySpecified and selectors
+    val tests =
+      for {
+        (df, di) <- discovered
+        fingerprint <- toFingerprints(di)
+      } yield new TestDefinition(df.name, fingerprint, false, Array(new SuiteSelector: Selector))
+    val mains = discovered collect { case (df, di) if di.hasMain => df.name }
+    (tests, mains.toSet)
+  }
 }
 
-final class TestsFailedException extends RuntimeException("Tests unsuccessful") with FeedbackProvidedException
+final class TestsFailedException
+    extends RuntimeException("Tests unsuccessful")
+    with FeedbackProvidedException
diff --git a/main-actions/src/main/scala/sbt/compiler/Eval.scala b/main-actions/src/main/scala/sbt/compiler/Eval.scala
index 65bb9ad10..461a8c727 100644
--- a/main-actions/src/main/scala/sbt/compiler/Eval.scala
+++ b/main-actions/src/main/scala/sbt/compiler/Eval.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package compiler
 
@@ -8,9 +15,10 @@ import ast.parser.Tokens
 import reporters.{ ConsoleReporter, Reporter }
 import scala.reflect.internal.util.{ AbstractFileClassLoader, BatchSourceFile }
 import Tokens.{ EOF, NEWLINE, NEWLINES, SEMI }
-import java.io.File
+import java.io.{ File, FileNotFoundException }
 import java.nio.ByteBuffer
 import java.net.URLClassLoader
+import java.security.MessageDigest
 import Eval.{ getModule, getValue, WrapValName }
 
 import sbt.io.{ DirectoryFilter, FileFilter, GlobFilter, Hash, IO, Path }
@@ -26,7 +34,12 @@ final class EvalImports(val strings: Seq[(String, Int)], val srcName: String)
  * the module from that class loader.  `generated` contains the compiled classes and cache files related
  * to the expression.  The name of the auto-generated module wrapping the expression is `enclosingModule`.
  */
-final class EvalResult(val tpe: String, val getValue: ClassLoader => Any, val generated: Seq[File], val enclosingModule: String)
+final class EvalResult(
+    val tpe: String,
+    val getValue: ClassLoader => Any,
+    val generated: Seq[File],
+    val enclosingModule: String
+)
 
 /**
  * The result of evaluating a group of Scala definitions.  The definitions are wrapped in an auto-generated,
@@ -35,7 +48,12 @@ final class EvalResult(val tpe: String, val getValue: ClassLoader => Any, val ge
  * from the classpath that the definitions were compiled against.  The list of vals with the requested types is `valNames`.
  * The values for these may be obtained by providing the parent class loader to `values` as is done with `loader`.
  */
-final class EvalDefinitions(val loader: ClassLoader => ClassLoader, val generated: Seq[File], val enclosingModule: String, val valNames: Seq[String]) {
+final class EvalDefinitions(
+    val loader: ClassLoader => ClassLoader,
+    val generated: Seq[File],
+    val enclosingModule: String,
+    val valNames: Seq[String]
+) {
   def values(parent: ClassLoader): Seq[Any] = {
     val module = getModule(enclosingModule, loader(parent))
     for (n <- valNames) yield module.getClass.getMethod(n).invoke(module)
@@ -44,27 +62,37 @@ final class EvalDefinitions(val loader: ClassLoader => ClassLoader, val generate
 
 final class EvalException(msg: String) extends RuntimeException(msg)
 // not thread safe, since it reuses a Global instance
-final class Eval(optionsNoncp: Seq[String], classpath: Seq[File], mkReporter: Settings => Reporter, backing: Option[File]) {
-  def this(mkReporter: Settings => Reporter, backing: Option[File]) = this(Nil, IO.classLocationFile[Product] :: Nil, mkReporter, backing)
+final class Eval(
+    optionsNoncp: Seq[String],
+    classpath: Seq[File],
+    mkReporter: Settings => Reporter,
+    backing: Option[File]
+) {
+  def this(mkReporter: Settings => Reporter, backing: Option[File]) =
+    this(Nil, IO.classLocationPath[Product].toFile :: Nil, mkReporter, backing)
   def this() = this(s => new ConsoleReporter(s), None)
 
   backing.foreach(IO.createDirectory)
   val classpathString = Path.makeString(classpath ++ backing.toList)
   val options = "-cp" +: classpathString +: optionsNoncp
 
-  lazy val settings =
-    {
-      val s = new Settings(println)
-      new CompilerCommand(options.toList, s) // this side-effects on Settings..
-      s
-    }
+  lazy val settings = {
+    val s = new Settings(println)
+    new CompilerCommand(options.toList, s) // this side-effects on Settings..
+    s
+  }
   lazy val reporter = mkReporter(settings)
+
   /**
    * Subclass of Global which allows us to mutate currentRun from outside.
    * See for rationale https://issues.scala-lang.org/browse/SI-8794
    */
-  final class EvalGlobal(settings: Settings, reporter: Reporter) extends Global(settings, reporter) {
-    override def currentRun: Run = curRun
+  final class EvalGlobal(settings: Settings, reporter: Reporter)
+      extends Global(settings, reporter) {
+    override def currentRun: Run = curRun match {
+      case null => super.currentRun // https://github.com/scala/bug/issues/11381
+      case r    => r
+    }
     var curRun: Run = null
   }
   lazy val global: EvalGlobal = new EvalGlobal(settings, reporter)
@@ -78,116 +106,167 @@ final class Eval(optionsNoncp: Seq[String], classpath: Seq[File], mkReporter: Se
   private[this] var toUnlinkLater = List[Symbol]()
   private[this] def unlink(sym: Symbol) = sym.owner.info.decls.unlink(sym)
 
-  def eval(expression: String, imports: EvalImports = noImports, tpeName: Option[String] = None, srcName: String = "<setting>", line: Int = DefaultStartLine): EvalResult =
-    {
-      val ev = new EvalType[String] {
-        def makeUnit = mkUnit(srcName, line, expression)
-        def unlink = true
-        def unitBody(unit: CompilationUnit, importTrees: Seq[Tree], moduleName: String): Tree = {
-          val (parser, tree) = parse(unit, settingErrorStrings, _.expr())
-          val tpt: Tree = expectedType(tpeName)
-          augment(parser, importTrees, tree, tpt, moduleName)
-        }
-        def extra(run: Run, unit: CompilationUnit) = enteringPhase(run.typerPhase.next) { (new TypeExtractor).getType(unit.body) }
-        def read(file: File) = IO.read(file)
-        def write(value: String, f: File) = IO.write(f, value)
-        def extraHash = ""
+  def eval(
+      expression: String,
+      imports: EvalImports = noImports,
+      tpeName: Option[String] = None,
+      srcName: String = "<setting>",
+      line: Int = DefaultStartLine
+  ): EvalResult = {
+    val ev = new EvalType[String] {
+      def makeUnit = mkUnit(srcName, line, expression)
+      def unlink = true
+      def unitBody(unit: CompilationUnit, importTrees: Seq[Tree], moduleName: String): Tree = {
+        val (parser, tree) = parse(unit, settingErrorStrings, _.expr())
+        val tpt: Tree = expectedType(tpeName)
+        augment(parser, importTrees, tree, tpt, moduleName)
       }
-      val i = evalCommon(expression :: Nil, imports, tpeName, ev)
-      val value = (cl: ClassLoader) => getValue[Any](i.enclosingModule, i.loader(cl))
-      new EvalResult(i.extra, value, i.generated, i.enclosingModule)
+      def extra(run: Run, unit: CompilationUnit) = enteringPhase(run.typerPhase.next) {
+        (new TypeExtractor).getType(unit.body)
+      }
+      def read(file: File) = IO.read(file)
+      def write(value: String, f: File) = IO.write(f, value)
+      def extraHash = ""
     }
-  def evalDefinitions(definitions: Seq[(String, scala.Range)], imports: EvalImports, srcName: String, file: Option[File], valTypes: Seq[String]): EvalDefinitions =
-    {
-      require(definitions.nonEmpty, "Definitions to evaluate cannot be empty.")
-      val ev = new EvalType[Seq[String]] {
-        lazy val (fullUnit, defUnits) = mkDefsUnit(srcName, definitions)
-        def makeUnit = fullUnit
-        def unlink = false
-        def unitBody(unit: CompilationUnit, importTrees: Seq[Tree], moduleName: String): Tree = {
-          val fullParser = new syntaxAnalyzer.UnitParser(unit)
-          val trees = defUnits flatMap parseDefinitions
-          syntheticModule(fullParser, importTrees, trees.toList, moduleName)
-        }
-        def extra(run: Run, unit: CompilationUnit) = {
-          enteringPhase(run.typerPhase.next) { (new ValExtractor(valTypes.toSet)).getVals(unit.body) }
-        }
-        def read(file: File) = IO.readLines(file)
-        def write(value: Seq[String], file: File) = IO.writeLines(file, value)
-        def extraHash = file match {
-          case Some(f) => f.getAbsolutePath
-          case None    => ""
+    val i = evalCommon(expression :: Nil, imports, tpeName, ev)
+    val value = (cl: ClassLoader) => getValue[Any](i.enclosingModule, i.loader(cl))
+    new EvalResult(i.extra, value, i.generated, i.enclosingModule)
+  }
+  def evalDefinitions(
+      definitions: Seq[(String, scala.Range)],
+      imports: EvalImports,
+      srcName: String,
+      file: Option[File],
+      valTypes: Seq[String]
+  ): EvalDefinitions = {
+    require(definitions.nonEmpty, "Definitions to evaluate cannot be empty.")
+    val ev = new EvalType[Seq[String]] {
+      lazy val (fullUnit, defUnits) = mkDefsUnit(srcName, definitions)
+      def makeUnit = fullUnit
+      def unlink = false
+      def unitBody(unit: CompilationUnit, importTrees: Seq[Tree], moduleName: String): Tree = {
+        val fullParser = new syntaxAnalyzer.UnitParser(unit)
+        val trees = defUnits flatMap parseDefinitions
+        syntheticModule(fullParser, importTrees, trees.toList, moduleName)
+      }
+      def extra(run: Run, unit: CompilationUnit) = {
+        enteringPhase(run.typerPhase.next) {
+          (new ValExtractor(valTypes.toSet)).getVals(unit.body)
         }
       }
-      val i = evalCommon(definitions.map(_._1), imports, Some(""), ev)
-      new EvalDefinitions(i.loader, i.generated, i.enclosingModule, i.extra)
+      def read(file: File) = IO.readLines(file)
+      def write(value: Seq[String], file: File) = IO.writeLines(file, value)
+      def extraHash = file match {
+        case Some(f) => f.getAbsolutePath
+        case None    => ""
+      }
+    }
+    val i: EvalIntermediate[Seq[String]] = evalCommon(definitions.map(_._1), imports, Some(""), ev)
+    new EvalDefinitions(i.loader, i.generated, i.enclosingModule, i.extra.reverse)
+  }
+
+  private[this] def evalCommon[T](
+      content: Seq[String],
+      imports: EvalImports,
+      tpeName: Option[String],
+      ev: EvalType[T]
+  ): EvalIntermediate[T] = {
+    import Eval._
+    // TODO - We also encode the source of the setting into the hash to avoid conflicts where the exact SAME setting
+    // is defined in multiple evaluated instances with a backing.  This leads to issues with finding a previous
+    // value on the classpath when compiling.
+
+    // This is a hot path.
+    val digester = MessageDigest.getInstance("SHA")
+    content foreach { c =>
+      digester.update(bytes(c))
+    }
+    backing foreach { x =>
+      digester.update(fileExistsBytes(x))
+    }
+    options foreach { o =>
+      digester.update(bytes(o))
+    }
+    classpath foreach { f =>
+      fileModifiedHash(f, digester)
+    }
+    imports.strings.map(_._1) foreach { x =>
+      digester.update(bytes(x))
+    }
+    tpeName foreach { x =>
+      digester.update(bytes(x))
+    }
+    digester.update(bytes(ev.extraHash))
+    val d = digester.digest()
+
+    val hash = Hash.toHex(d)
+    val moduleName = makeModuleName(hash)
+
+    lazy val unit = {
+      reporter.reset
+      ev.makeUnit
+    }
+    lazy val run = new Run {
+      override def units = (unit :: Nil).iterator
+    }
+    def unlinkAll(): Unit =
+      for ((sym, _) <- run.symSource) if (ev.unlink) unlink(sym) else toUnlinkLater ::= sym
+
+    val (extra, loader) = backing match {
+      case Some(back) if classExists(back, moduleName) =>
+        val loader = (parent: ClassLoader) =>
+          (new URLClassLoader(Array(back.toURI.toURL), parent): ClassLoader)
+        val extra = ev.read(cacheFile(back, moduleName))
+        (extra, loader)
+      case _ =>
+        try {
+          compileAndLoad(run, unit, imports, backing, moduleName, ev)
+        } finally {
+          unlinkAll()
+        }
     }
 
-  private[this] def evalCommon[T](content: Seq[String], imports: EvalImports, tpeName: Option[String], ev: EvalType[T]): EvalIntermediate[T] =
-    {
-      import Eval._
-      // TODO - We also encode the source of the setting into the hash to avoid conflicts where the exact SAME setting
-      // is defined in multiple evaluated instances with a backing.  This leads to issues with finding a previous
-      // value on the classpath when compiling.
-      val hash = Hash.toHex(Hash(bytes(stringSeqBytes(content) :: optBytes(backing)(fileExistsBytes) :: stringSeqBytes(options) ::
-        seqBytes(classpath)(fileModifiedBytes) :: stringSeqBytes(imports.strings.map(_._1)) :: optBytes(tpeName)(bytes) ::
-        bytes(ev.extraHash) :: Nil)))
-      val moduleName = makeModuleName(hash)
-
-      lazy val unit = {
-        reporter.reset
-        ev.makeUnit
-      }
-      lazy val run = new Run {
-        override def units = (unit :: Nil).iterator
-      }
-      def unlinkAll(): Unit = for ((sym, _) <- run.symSource) if (ev.unlink) unlink(sym) else toUnlinkLater ::= sym
-
-      val (extra, loader) = backing match {
-        case Some(back) if classExists(back, moduleName) =>
-          val loader = (parent: ClassLoader) => new URLClassLoader(Array(back.toURI.toURL), parent)
-          val extra = ev.read(cacheFile(back, moduleName))
-          (extra, loader)
-        case _ =>
-          try { compileAndLoad(run, unit, imports, backing, moduleName, ev) }
-          finally { unlinkAll() }
-      }
-
-      val generatedFiles = getGeneratedFiles(backing, moduleName)
-      new EvalIntermediate(extra, loader, generatedFiles, moduleName)
-    }
+    val generatedFiles = getGeneratedFiles(backing, moduleName)
+    new EvalIntermediate(extra, loader, generatedFiles, moduleName)
+  }
   // location of the cached type or definition information
-  private[this] def cacheFile(base: File, moduleName: String): File = new File(base, moduleName + ".cache")
-  private[this] def compileAndLoad[T](run: Run, unit: CompilationUnit, imports: EvalImports, backing: Option[File], moduleName: String, ev: EvalType[T]): (T, ClassLoader => ClassLoader) =
-    {
-      global.curRun = run
-      run.currentUnit = unit
-      val dir = outputDirectory(backing)
-      settings.outputDirs setSingleOutput dir
+  private[this] def cacheFile(base: File, moduleName: String): File =
+    new File(base, moduleName + ".cache")
+  private[this] def compileAndLoad[T](
+      run: Run,
+      unit: CompilationUnit,
+      imports: EvalImports,
+      backing: Option[File],
+      moduleName: String,
+      ev: EvalType[T]
+  ): (T, ClassLoader => ClassLoader) = {
+    global.curRun = run
+    run.currentUnit = unit
+    val dir = outputDirectory(backing)
+    settings.outputDirs setSingleOutput dir
 
-      val importTrees = parseImports(imports)
-      unit.body = ev.unitBody(unit, importTrees, moduleName)
+    val importTrees = parseImports(imports)
+    unit.body = ev.unitBody(unit, importTrees, moduleName)
 
-      def compile(phase: Phase): Unit =
-        {
-          globalPhase = phase
-          if (phase == null || phase == phase.next || reporter.hasErrors)
-            ()
-          else {
-            enteringPhase(phase) { phase.run }
-            compile(phase.next)
-          }
-        }
-
-      compile(run.namerPhase)
-      checkError("Type error in expression")
-
-      val extra = ev.extra(run, unit)
-      for (f <- backing) ev.write(extra, cacheFile(f, moduleName))
-      val loader = (parent: ClassLoader) => new AbstractFileClassLoader(dir, parent)
-      (extra, loader)
+    def compile(phase: Phase): Unit = {
+      globalPhase = phase
+      if (phase == null || phase == phase.next || reporter.hasErrors)
+        ()
+      else {
+        enteringPhase(phase) { phase.run }
+        compile(phase.next)
+      }
     }
 
+    compile(run.namerPhase)
+    checkError("Type error in expression")
+
+    val extra = ev.extra(run, unit)
+    for (f <- backing) ev.write(extra, cacheFile(f, moduleName))
+    val loader = (parent: ClassLoader) => new AbstractFileClassLoader(dir, parent)
+    (extra, loader)
+  }
+
   private[this] def expectedType(tpeName: Option[String]): Tree =
     tpeName match {
       case Some(tpe) => parseType(tpe)
@@ -195,43 +274,62 @@ final class Eval(optionsNoncp: Seq[String], classpath: Seq[File], mkReporter: Se
     }
 
   private[this] def outputDirectory(backing: Option[File]): AbstractFile =
-    backing match { case None => new VirtualDirectory("<virtual>", None); case Some(dir) => new PlainFile(dir) }
+    backing match {
+      case None => new VirtualDirectory("<virtual>", None); case Some(dir) => new PlainFile(dir)
+    }
 
-  def load(dir: AbstractFile, moduleName: String): ClassLoader => Any = parent => getValue[Any](moduleName, new AbstractFileClassLoader(dir, parent))
-  def loadPlain(dir: File, moduleName: String): ClassLoader => Any = parent => getValue[Any](moduleName, new URLClassLoader(Array(dir.toURI.toURL), parent))
+  def load(dir: AbstractFile, moduleName: String): ClassLoader => Any =
+    parent => getValue[Any](moduleName, new AbstractFileClassLoader(dir, parent))
+  def loadPlain(dir: File, moduleName: String): ClassLoader => Any =
+    parent => getValue[Any](moduleName, new URLClassLoader(Array(dir.toURI.toURL), parent))
 
   //wrap tree in object objectName { def WrapValName = <tree> }
-  def augment(parser: global.syntaxAnalyzer.UnitParser, imports: Seq[Tree], tree: Tree, tpt: Tree, objectName: String): Tree =
-    {
-      val method = DefDef(NoMods, newTermName(WrapValName), Nil, Nil, tpt, tree)
-      syntheticModule(parser, imports, method :: Nil, objectName)
-    }
-  private[this] def syntheticModule(parser: global.syntaxAnalyzer.UnitParser, imports: Seq[Tree], definitions: List[Tree], objectName: String): Tree =
-    {
-      val emptyTypeName = nme.EMPTY.toTypeName
-      def emptyPkg = parser.atPos(0, 0, 0) { Ident(nme.EMPTY_PACKAGE_NAME) }
-      def emptyInit = DefDef(
-        NoMods,
-        nme.CONSTRUCTOR,
-        Nil,
-        List(Nil),
-        TypeTree(),
-        Block(List(Apply(Select(Super(This(emptyTypeName), emptyTypeName), nme.CONSTRUCTOR), Nil)), Literal(Constant(())))
+  def augment(
+      parser: global.syntaxAnalyzer.UnitParser,
+      imports: Seq[Tree],
+      tree: Tree,
+      tpt: Tree,
+      objectName: String
+  ): Tree = {
+    val method = DefDef(NoMods, newTermName(WrapValName), Nil, Nil, tpt, tree)
+    syntheticModule(parser, imports, method :: Nil, objectName)
+  }
+  private[this] def syntheticModule(
+      parser: global.syntaxAnalyzer.UnitParser,
+      imports: Seq[Tree],
+      definitions: List[Tree],
+      objectName: String
+  ): Tree = {
+    val emptyTypeName = nme.EMPTY.toTypeName
+    def emptyPkg = parser.atPos(0, 0, 0) { Ident(nme.EMPTY_PACKAGE_NAME) }
+    def emptyInit = DefDef(
+      NoMods,
+      nme.CONSTRUCTOR,
+      Nil,
+      List(Nil),
+      TypeTree(),
+      Block(
+        List(Apply(Select(Super(This(emptyTypeName), emptyTypeName), nme.CONSTRUCTOR), Nil)),
+        Literal(Constant(()))
       )
+    )
 
-      def moduleBody = Template(List(gen.scalaAnyRefConstr), noSelfType, emptyInit :: definitions)
-      def moduleDef = ModuleDef(NoMods, newTermName(objectName), moduleBody)
-      parser.makePackaging(0, emptyPkg, (imports :+ moduleDef).toList)
-    }
+    def moduleBody =
+      Template(List(gen.scalaAnyRefConstr), noSelfType, (emptyInit: Tree) :: definitions)
+    def moduleDef = ModuleDef(NoMods, newTermName(objectName), moduleBody)
+    parser.makePackaging(0, emptyPkg, (imports :+ (moduleDef: Tree)).toList)
+  }
 
   private[this] final class TypeExtractor extends Traverser {
     private[this] var result = ""
     def getType(t: Tree) = { result = ""; traverse(t); result }
     override def traverse(tree: Tree): Unit = tree match {
-      case d: DefDef if d.symbol.nameString == WrapValName => result = d.symbol.tpe.finalResultType.toString
+      case d: DefDef if d.symbol.nameString == WrapValName =>
+        result = d.symbol.tpe.finalResultType.toString
       case _ => super.traverse(tree)
     }
   }
+
   /** Tree traverser that obtains the names of vals in a top-level module whose type is a subtype of one of `types`.*/
   private[this] final class ValExtractor(tpes: Set[String]) extends Traverser {
     private[this] var vals = List[String]()
@@ -242,15 +340,22 @@ final class Eval(optionsNoncp: Seq[String], classpath: Seq[File], mkReporter: Se
       }
     }
     override def traverse(tree: Tree): Unit = tree match {
-      case ValDef(_, n, actualTpe, _) if isTopLevelModule(tree.symbol.owner) && isAcceptableType(actualTpe.tpe) =>
+      case ValDef(_, n, actualTpe, _)
+          if isTopLevelModule(tree.symbol.owner) && isAcceptableType(actualTpe.tpe) =>
         vals ::= n.dropLocal.encoded
       case _ => super.traverse(tree)
     }
   }
   // inlined implemented of Symbol.isTopLevelModule that was removed in e5b050814deb2e7e1d6d05511d3a6cb6b013b549
-  private[this] def isTopLevelModule(s: Symbol): Boolean = s.hasFlag(reflect.internal.Flags.MODULE) && s.owner.isPackageClass
+  private[this] def isTopLevelModule(s: Symbol): Boolean =
+    s.hasFlag(reflect.internal.Flags.MODULE) && s.owner.isPackageClass
 
-  private[this] final class EvalIntermediate[T](val extra: T, val loader: ClassLoader => ClassLoader, val generated: Seq[File], val enclosingModule: String)
+  private[this] final class EvalIntermediate[T](
+      val extra: T,
+      val loader: ClassLoader => ClassLoader,
+      val generated: Seq[File],
+      val enclosingModule: String
+  )
 
   private[this] def classExists(dir: File, name: String) = (new File(dir, name + ".class")).exists
   // TODO: use the code from Analyzer
@@ -263,12 +368,13 @@ final class Eval(optionsNoncp: Seq[String], classpath: Seq[File], mkReporter: Se
     def accept(dir: File, s: String) =
       (s contains moduleName)
   }
-  private[this] def moduleClassFilter(moduleName: String) = new java.io.FilenameFilter {
-    def accept(dir: File, s: String) =
-      (s contains moduleName) && (s endsWith ".class")
-  }
 
-  private[this] class ParseErrorStrings(val base: String, val extraBlank: String, val missingBlank: String, val extraSemi: String)
+  private[this] class ParseErrorStrings(
+      val base: String,
+      val extraBlank: String,
+      val missingBlank: String,
+      val extraSemi: String
+  )
   private[this] def definitionErrorStrings = new ParseErrorStrings(
     base = "Error parsing definition.",
     extraBlank = "  Ensure that there are no blank lines within a definition.",
@@ -279,67 +385,69 @@ final class Eval(optionsNoncp: Seq[String], classpath: Seq[File], mkReporter: Se
     base = "Error parsing expression.",
     extraBlank = "  Ensure that there are no blank lines within a setting.",
     missingBlank = "  Ensure that settings are separated by blank lines.",
-    extraSemi = "  Note that settings are expressions and do not end with semicolons.  (Semicolons are fine within {} blocks, however.)"
+    extraSemi =
+      "  Note that settings are expressions and do not end with semicolons.  (Semicolons are fine within {} blocks, however.)"
   )
 
   /**
    * Parses the provided compilation `unit` according to `f` and then performs checks on the final parser state
    * to catch errors that are common when the content is embedded in a blank-line-delimited format.
    */
-  private[this] def parse[T](unit: CompilationUnit, errors: ParseErrorStrings, f: syntaxAnalyzer.UnitParser => T): (syntaxAnalyzer.UnitParser, T) =
-    {
-      val parser = new syntaxAnalyzer.UnitParser(unit)
+  private[this] def parse[T](
+      unit: CompilationUnit,
+      errors: ParseErrorStrings,
+      f: syntaxAnalyzer.UnitParser => T
+  ): (syntaxAnalyzer.UnitParser, T) = {
+    val parser = new syntaxAnalyzer.UnitParser(unit)
 
-      val tree = f(parser)
-      val extra = parser.in.token match {
-        case EOF => errors.extraBlank
-        case _   => ""
-      }
-      checkError(errors.base + extra)
-
-      parser.accept(EOF)
-      val extra2 = parser.in.token match {
-        case SEMI               => errors.extraSemi
-        case NEWLINE | NEWLINES => errors.missingBlank
-        case _                  => ""
-      }
-      checkError(errors.base + extra2)
-
-      (parser, tree)
+    val tree = f(parser)
+    val extra = parser.in.token match {
+      case EOF => errors.extraBlank
+      case _   => ""
     }
-  private[this] def parseType(tpe: String): Tree =
-    {
-      val tpeParser = new syntaxAnalyzer.UnitParser(mkUnit("<expected-type>", DefaultStartLine, tpe))
-      val tpt0: Tree = tpeParser.typ()
-      tpeParser.accept(EOF)
-      checkError("Error parsing expression type.")
-      tpt0
+    checkError(errors.base + extra)
+
+    parser.accept(EOF)
+    val extra2 = parser.in.token match {
+      case SEMI               => errors.extraSemi
+      case NEWLINE | NEWLINES => errors.missingBlank
+      case _                  => ""
     }
+    checkError(errors.base + extra2)
+
+    (parser, tree)
+  }
+  private[this] def parseType(tpe: String): Tree = {
+    val tpeParser = new syntaxAnalyzer.UnitParser(mkUnit("<expected-type>", DefaultStartLine, tpe))
+    val tpt0: Tree = tpeParser.typ()
+    tpeParser.accept(EOF)
+    checkError("Error parsing expression type.")
+    tpt0
+  }
   private[this] def parseImports(imports: EvalImports): Seq[Tree] =
     imports.strings flatMap { case (s, line) => parseImport(mkUnit(imports.srcName, line, s)) }
-  private[this] def parseImport(importUnit: CompilationUnit): Seq[Tree] =
-    {
-      val parser = new syntaxAnalyzer.UnitParser(importUnit)
-      val trees: Seq[Tree] = parser.importClause()
-      parser.accept(EOF)
-      checkError("Error parsing imports for expression.")
-      trees
-    }
+  private[this] def parseImport(importUnit: CompilationUnit): Seq[Tree] = {
+    val parser = new syntaxAnalyzer.UnitParser(importUnit)
+    val trees: Seq[Tree] = parser.importClause()
+    parser.accept(EOF)
+    checkError("Error parsing imports for expression.")
+    trees
+  }
   private[this] def parseDefinitions(du: CompilationUnit): Seq[Tree] =
     parse(du, definitionErrorStrings, parseDefinitions)._2
 
   /** Parses one or more definitions (defs, vals, lazy vals, classes, traits, modules). */
-  private[this] def parseDefinitions(parser: syntaxAnalyzer.UnitParser): Seq[Tree] =
-    {
-      val defs = ListBuffer[Tree]()
-      do {
-        defs ++= parser.nonLocalDefOrDcl
-        parser.acceptStatSepOpt()
-      } while (!parser.isStatSeqEnd)
-      defs.toList
-    }
+  private[this] def parseDefinitions(parser: syntaxAnalyzer.UnitParser): Seq[Tree] = {
+    val defs = ListBuffer[Tree]()
+    do {
+      defs ++= parser.nonLocalDefOrDcl
+      parser.acceptStatSepOpt()
+    } while (!parser.isStatSeqEnd)
+    defs.toList
+  }
 
   private[this] trait EvalType[T] {
+
     /** Extracts additional information after the compilation unit is evaluated.*/
     def extra(run: Run, unit: CompilationUnit): T
 
@@ -373,47 +481,56 @@ final class Eval(optionsNoncp: Seq[String], classpath: Seq[File], mkReporter: Se
   val DefaultStartLine = 0
   private[this] def makeModuleName(hash: String): String = "$" + Hash.halve(hash)
   private[this] def noImports = new EvalImports(Nil, "")
-  private[this] def mkUnit(srcName: String, firstLine: Int, s: String) = new CompilationUnit(new EvalSourceFile(srcName, firstLine, s))
-  private[this] def checkError(label: String) = if (reporter.hasErrors) throw new EvalException(label)
+  private[this] def mkUnit(srcName: String, firstLine: Int, s: String) =
+    new CompilationUnit(new EvalSourceFile(srcName, firstLine, s))
+  private[this] def checkError(label: String) =
+    if (reporter.hasErrors) throw new EvalException(label)
 
-  private[this] final class EvalSourceFile(name: String, startLine: Int, contents: String) extends BatchSourceFile(name, contents) {
+  private[this] final class EvalSourceFile(name: String, startLine: Int, contents: String)
+      extends BatchSourceFile(name, contents) {
     override def lineToOffset(line: Int): Int = super.lineToOffset((line - startLine) max 0)
     override def offsetToLine(offset: Int): Int = super.offsetToLine(offset) + startLine
   }
+
   /**
    * Constructs a CompilationUnit for each definition, which can be used to independently parse the definition into a Tree.
    * Additionally, a CompilationUnit for the combined definitions is constructed for use by combined compilation after parsing.
    */
-  private[this] def mkDefsUnit(srcName: String, definitions: Seq[(String, scala.Range)]): (CompilationUnit, Seq[CompilationUnit]) =
-    {
-      def fragmentUnit(content: String, lineMap: Array[Int]) = new CompilationUnit(fragmentSourceFile(srcName, content, lineMap))
+  private[this] def mkDefsUnit(
+      srcName: String,
+      definitions: Seq[(String, scala.Range)]
+  ): (CompilationUnit, Seq[CompilationUnit]) = {
+    def fragmentUnit(content: String, lineMap: Array[Int]) =
+      new CompilationUnit(fragmentSourceFile(srcName, content, lineMap))
 
-      import collection.mutable.ListBuffer
-      val lines = new ListBuffer[Int]()
-      val defs = new ListBuffer[CompilationUnit]()
-      val fullContent = new java.lang.StringBuilder()
-      for ((defString, range) <- definitions) {
-        defs += fragmentUnit(defString, range.toArray)
-        fullContent.append(defString)
-        lines ++= range
-        fullContent.append("\n\n")
-        lines ++= (range.end :: range.end :: Nil)
-      }
-      val fullUnit = fragmentUnit(fullContent.toString, lines.toArray)
-      (fullUnit, defs.toSeq)
+    import collection.mutable.ListBuffer
+    val lines = new ListBuffer[Int]()
+    val defs = new ListBuffer[CompilationUnit]()
+    val fullContent = new java.lang.StringBuilder()
+    for ((defString, range) <- definitions) {
+      defs += fragmentUnit(defString, range.toArray)
+      fullContent.append(defString)
+      lines ++= range
+      fullContent.append("\n\n")
+      lines ++= (range.end :: range.end :: Nil)
     }
+    val fullUnit = fragmentUnit(fullContent.toString, lines.toArray)
+    (fullUnit, defs.toSeq)
+  }
 
   /**
    * Source file that can map the offset in the file to and from line numbers that may discontinuous.
    * The values in `lineMap` must be ordered, but need not be consecutive.
    */
-  private[this] def fragmentSourceFile(srcName: String, content: String, lineMap: Array[Int]) = new BatchSourceFile(srcName, content) {
-    override def lineToOffset(line: Int): Int = super.lineToOffset(lineMap.indexWhere(_ == line) max 0)
-    override def offsetToLine(offset: Int): Int = index(lineMap, super.offsetToLine(offset))
-    // the SourceFile attribute is populated from this method, so we are required to only return the name
-    override def toString = new File(srcName).getName
-    private[this] def index(a: Array[Int], i: Int): Int = if (i < 0 || i >= a.length) 0 else a(i)
-  }
+  private[this] def fragmentSourceFile(srcName: String, content: String, lineMap: Array[Int]) =
+    new BatchSourceFile(srcName, content) {
+      override def lineToOffset(line: Int): Int =
+        super.lineToOffset(lineMap.indexWhere(_ == line) max 0)
+      override def offsetToLine(offset: Int): Int = index(lineMap, super.offsetToLine(offset))
+      // the SourceFile attribute is populated from this method, so we are required to only return the name
+      override def toString = new File(srcName).getName
+      private[this] def index(a: Array[Int], i: Int): Int = if (i < 0 || i >= a.length) 0 else a(i)
+    }
 }
 private[sbt] object Eval {
   def optBytes[T](o: Option[T])(f: T => Array[Byte]): Array[Byte] = seqBytes(o.toSeq)(f)
@@ -421,27 +538,41 @@ private[sbt] object Eval {
   def seqBytes[T](s: Seq[T])(f: T => Array[Byte]): Array[Byte] = bytes(s map f)
   def bytes(b: Seq[Array[Byte]]): Array[Byte] = bytes(b.length) ++ b.flatten.toArray[Byte]
   def bytes(b: Boolean): Array[Byte] = Array[Byte](if (b) 1 else 0)
-  def filesModifiedBytes(fs: Array[File]): Array[Byte] = if (fs eq null) filesModifiedBytes(Array[File]()) else seqBytes(fs)(fileModifiedBytes)
-  def fileModifiedBytes(f: File): Array[Byte] =
-    (if (f.isDirectory) filesModifiedBytes(f listFiles classDirFilter) else bytes(f.lastModified)) ++
-      bytes(f.getAbsolutePath)
+
+  // fileModifiedBytes is a hot method, taking up 0.85% of reload time
+  // This is a procedural version
+  def fileModifiedHash(f: File, digester: MessageDigest): Unit = {
+    if (f.isDirectory)
+      (f listFiles classDirFilter) foreach { x =>
+        fileModifiedHash(x, digester)
+      } else digester.update(bytes(getModifiedTimeOrZero(f)))
+
+    digester.update(bytes(f.getAbsolutePath))
+  }
+
+  // This uses NIO instead of the JNA-based IO.getModifiedTimeOrZero for speed
+  def getModifiedTimeOrZero(f: File): Long =
+    try {
+      sbt.io.JavaMilli.getModifiedTime(f.getPath)
+    } catch {
+      case _: FileNotFoundException => 0L
+    }
+
   def fileExistsBytes(f: File): Array[Byte] =
     bytes(f.exists) ++
       bytes(f.getAbsolutePath)
 
   def bytes(s: String): Array[Byte] = s getBytes "UTF-8"
-  def bytes(l: Long): Array[Byte] =
-    {
-      val buffer = ByteBuffer.allocate(8)
-      buffer.putLong(l)
-      buffer.array
-    }
-  def bytes(i: Int): Array[Byte] =
-    {
-      val buffer = ByteBuffer.allocate(4)
-      buffer.putInt(i)
-      buffer.array
-    }
+  def bytes(l: Long): Array[Byte] = {
+    val buffer = ByteBuffer.allocate(8)
+    buffer.putLong(l)
+    buffer.array
+  }
+  def bytes(i: Int): Array[Byte] = {
+    val buffer = ByteBuffer.allocate(4)
+    buffer.putInt(i)
+    buffer.array
+  }
 
   /** The name of the synthetic val in the synthetic module that an expression is assigned to. */
   final val WrapValName = "$sbtdef"
@@ -450,20 +581,18 @@ private[sbt] object Eval {
    * Gets the value of the expression wrapped in module `objectName`, which is accessible via `loader`.
    * The module name should not include the trailing `$`.
    */
-  def getValue[T](objectName: String, loader: ClassLoader): T =
-    {
-      val module = getModule(objectName, loader)
-      val accessor = module.getClass.getMethod(WrapValName)
-      val value = accessor.invoke(module)
-      value.asInstanceOf[T]
-    }
+  def getValue[T](objectName: String, loader: ClassLoader): T = {
+    val module = getModule(objectName, loader)
+    val accessor = module.getClass.getMethod(WrapValName)
+    val value = accessor.invoke(module)
+    value.asInstanceOf[T]
+  }
 
   /** Gets the top-level module `moduleName` from the provided class `loader`.  The module name should not include the trailing `$`.*/
-  def getModule(moduleName: String, loader: ClassLoader): Any =
-    {
-      val clazz = Class.forName(moduleName + "$", true, loader)
-      clazz.getField("MODULE$").get(null)
-    }
+  def getModule(moduleName: String, loader: ClassLoader): Any = {
+    val clazz = Class.forName(moduleName + "$", true, loader)
+    clazz.getField("MODULE$").get(null)
+  }
 
   private val classDirFilter: FileFilter = DirectoryFilter || GlobFilter("*.class")
 }
diff --git a/main-actions/src/test/scala/sbt/CacheIvyTest.scala b/main-actions/src/test/scala/sbt/CacheIvyTest.scala
index c185ef39c..17cb778e1 100644
--- a/main-actions/src/test/scala/sbt/CacheIvyTest.scala
+++ b/main-actions/src/test/scala/sbt/CacheIvyTest.scala
@@ -1,34 +1,78 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import org.scalacheck._
 import org.scalacheck.Arbitrary._
 import Prop._
 import sbt.librarymanagement._
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
 
 class CacheIvyTest extends Properties("CacheIvy") {
-  import CacheIvy._
-  import sbinary.Operations._
-  import sbinary._
-  import sbinary.DefaultProtocol._
+  import sbt.util.{ CacheStore, SingletonCache }
+  import SingletonCache._
 
-  private def cachePreservesEquality[T: Format](m: T, eq: (T, T) => Prop, str: T => String): Prop = {
-    val out = fromByteArray[T](toByteArray(m))
+  import sjsonnew._
+  import sjsonnew.support.scalajson.unsafe.Converter
+
+  private class InMemoryStore(converter: SupportConverter[JValue]) extends CacheStore {
+    private var content: JValue = _
+    override def delete(): Unit = ()
+    override def close(): Unit = ()
+
+    override def read[T: JsonReader](): T =
+      try converter.fromJsonUnsafe[T](content)
+      catch { case t: Throwable => t.printStackTrace(); throw t }
+
+    override def read[T: JsonReader](default: => T): T =
+      try read[T]()
+      catch { case _: Throwable => default }
+
+    override def write[T: JsonWriter](value: T): Unit =
+      content = converter.toJsonUnsafe(value)
+  }
+
+  private def testCache[T: JsonFormat, U](
+      f: (SingletonCache[T], CacheStore) => U
+  )(implicit cache: SingletonCache[T]): U = {
+    val store = new InMemoryStore(Converter)
+    f(cache, store)
+  }
+
+  private def cachePreservesEquality[T: JsonFormat](
+      m: T,
+      eq: (T, T) => Prop,
+      str: T => String
+  ): Prop = testCache[T, Prop] { (cache, store) =>
+    cache.write(store, m)
+    val out = cache.read(store)
     eq(out, m) :| s"Expected: ${str(m)}" :| s"Got: ${str(out)}"
   }
 
-  implicit val arbExclusionRule: Arbitrary[ExclusionRule] = Arbitrary(
+  implicit val arbConfigRef: Arbitrary[ConfigRef] = Arbitrary(
+    for {
+      n <- Gen.alphaStr
+    } yield ConfigRef(n)
+  )
+
+  implicit val arbExclusionRule: Arbitrary[InclExclRule] = Arbitrary(
     for {
       o <- Gen.alphaStr
       n <- Gen.alphaStr
       a <- Gen.alphaStr
-      cs <- arbitrary[List[String]]
-    } yield ExclusionRule(o, n, a, cs)
+      v <- arbCrossVersion.arbitrary
+      cs <- arbitrary[List[ConfigRef]]
+    } yield InclExclRule(o, n, a, cs.toVector, v)
   )
 
   implicit val arbCrossVersion: Arbitrary[CrossVersion] = Arbitrary {
     // Actual functions don't matter, just Disabled vs Binary vs Full
-    import CrossVersion._
-    Gen.oneOf(Disabled, new Binary(identity), new Full(identity))
+    Gen.oneOf(Disabled(), Binary(), Full())
   }
 
   implicit val arbArtifact: Arbitrary[Artifact] = Arbitrary {
@@ -48,14 +92,25 @@ class CacheIvyTest extends Properties("CacheIvy") {
       isTransitive <- arbitrary[Boolean]
       isForce <- arbitrary[Boolean]
       explicitArtifacts <- Gen.listOf(arbitrary[Artifact])
-      exclusions <- Gen.listOf(arbitrary[ExclusionRule])
-      inclusions <- Gen.listOf(arbitrary[InclusionRule])
+      exclusions <- Gen.listOf(arbitrary[InclExclRule])
+      inclusions <- Gen.listOf(arbitrary[InclExclRule])
       extraAttributes <- Gen.mapOf(arbitrary[(String, String)])
       crossVersion <- arbitrary[CrossVersion]
     } yield ModuleID(
-      organization = o, name = n, revision = r, configurations = cs, isChanging = isChanging, isTransitive = isTransitive,
-      isForce = isForce, explicitArtifacts = explicitArtifacts, inclusions = inclusions, exclusions = exclusions,
-      extraAttributes = extraAttributes, crossVersion = crossVersion, branchName = branch)
+      organization = o,
+      name = n,
+      revision = r,
+      configurations = cs,
+      isChanging = isChanging,
+      isTransitive = isTransitive,
+      isForce = isForce,
+      explicitArtifacts = explicitArtifacts.toVector,
+      inclusions = inclusions.toVector,
+      exclusions = exclusions.toVector,
+      extraAttributes = extraAttributes,
+      crossVersion = crossVersion,
+      branchName = branch
+    )
   }
 
   property("moduleIDFormat") = forAll { (m: ModuleID) =>
@@ -65,16 +120,16 @@ class CacheIvyTest extends Properties("CacheIvy") {
         s"$inclusions, $extraAttributes, $crossVersion, $branchName)"
     }
     def eq(a: ModuleID, b: ModuleID): Prop = {
-      import CrossVersion._
-      def rest = a.copy(crossVersion = b.crossVersion) == b
+      def rest = a.withCrossVersion(b.crossVersion) == b
       (a.crossVersion, b.crossVersion) match {
-        case (Disabled, Disabled)   => rest
-        case (_: Binary, _: Binary) => rest
-        case (_: Full, _: Full)     => rest
-        case (a, b)                 => Prop(false) :| s"CrossVersions don't match: $a vs $b"
+        case (_: Disabled, _: Disabled) => rest
+        case (_: Binary, _: Binary)     => rest
+        case (_: Full, _: Full)         => rest
+        case (a, b)                     => Prop(false) :| s"CrossVersions don't match: $a vs $b"
       }
 
     }
+    import sbt.librarymanagement.LibraryManagementCodec._
     cachePreservesEquality(m, eq _, str)
   }
 }
diff --git a/main-actions/src/test/scala/sbt/compiler/EvalTest.scala b/main-actions/src/test/scala/sbt/compiler/EvalTest.scala
index dfdd839cf..21ffe61b9 100644
--- a/main-actions/src/test/scala/sbt/compiler/EvalTest.scala
+++ b/main-actions/src/test/scala/sbt/compiler/EvalTest.scala
@@ -1,37 +1,47 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package compiler
 
 import scala.language.reflectiveCalls
 import org.scalacheck._
 import Prop._
+import scala.tools.nsc.Settings
 import scala.tools.nsc.reporters.StoreReporter
 
 import sbt.io.IO
 
-object EvalTest extends Properties("eval") {
-  private[this] val reporter = new StoreReporter
-  import reporter.{ ERROR, Info }
-  private[this] val eval = new Eval(_ => reporter, None)
+class EvalTest extends Properties("eval") {
+  private[this] lazy val reporter = new StoreReporter(new Settings())
+  import reporter.ERROR
+  private[this] lazy val eval = new Eval(_ => reporter, None)
 
   property("inferred integer") = forAll { (i: Int) =>
     val result = eval.eval(i.toString)
     (label("Value", value(result)) |: (value(result) == i)) &&
-      (label("Type", value(result)) |: (result.tpe == IntType)) &&
-      (label("Files", result.generated) |: (result.generated.isEmpty))
+    (label("Type", value(result)) |: (result.tpe == IntType)) &&
+    (label("Files", result.generated) |: (result.generated.isEmpty))
   }
 
   property("explicit integer") = forAll { (i: Int) =>
     val result = eval.eval(i.toString, tpeName = Some(IntType))
     (label("Value", value(result)) |: (value(result) == i)) &&
-      (label("Type", result.tpe) |: (result.tpe == IntType)) &&
-      (label("Files", result.generated) |: (result.generated.isEmpty))
+    (label("Type", result.tpe) |: (result.tpe == IntType)) &&
+    (label("Files", result.generated) |: (result.generated.isEmpty))
   }
 
   property("type mismatch") = forAll { (i: Int, l: Int) =>
     val line = math.abs(l)
     val src = "mismatch"
-    throws(classOf[RuntimeException])(eval.eval(i.toString, tpeName = Some(BooleanType), line = line, srcName = src)) &&
-      hasErrors(line + 1, src)
+    throws(classOf[RuntimeException])(
+      eval.eval(i.toString, tpeName = Some(BooleanType), line = line, srcName = src)
+    ) &&
+    hasErrors(line + 1, src)
   }
 
   property("backed local class") = forAll { (i: Int) =>
@@ -40,8 +50,8 @@ object EvalTest extends Properties("eval") {
       val result = eval.eval(local(i))
       val v = value(result).asInstanceOf[{ def i: Int }].i
       (label("Value", v) |: (v == i)) &&
-        (label("Type", result.tpe) |: (result.tpe == LocalType)) &&
-        (label("Files", result.generated) |: result.generated.nonEmpty)
+      (label("Type", result.tpe) |: (result.tpe == LocalType)) &&
+      (label("Files", result.generated) |: result.generated.nonEmpty)
     }
   }
 
@@ -62,35 +72,41 @@ val p = {
 
   property("val test") = secure {
     val defs = (ValTestContent, 1 to 7) :: Nil
-    val res = eval.evalDefinitions(defs, new EvalImports(Nil, ""), "<defs>", None, "scala.Int" :: Nil)
+    val res =
+      eval.evalDefinitions(defs, new EvalImports(Nil, ""), "<defs>", None, "scala.Int" :: Nil)
     label("Val names", res.valNames) |: (res.valNames.toSet == ValTestNames)
   }
 
   property("explicit import") = forAll(testImport("import math.abs" :: Nil))
   property("wildcard import") = forAll(testImport("import math._" :: Nil))
-  property("comma-separated imports") = forAll(testImport("import annotation._, math._, meta._" :: Nil))
-  property("multiple imports") = forAll(testImport("import annotation._" :: "import math._" :: "import meta._" :: Nil))
+  property("comma-separated imports") = forAll(
+    testImport("import annotation._, math._, meta._" :: Nil)
+  )
+  property("multiple imports") = forAll(
+    testImport("import annotation._" :: "import math._" :: "import meta._" :: Nil)
+  )
 
-  private[this] def testImport(imports: Seq[String]): Int => Prop = i =>
-    value(eval.eval("abs(" + i + ")", new EvalImports(imports.zipWithIndex, "imp"))) == math.abs(i)
+  private[this] def testImport(imports: Seq[String]): Int => Prop =
+    i =>
+      value(eval.eval("abs(" + i + ")", new EvalImports(imports.zipWithIndex, "imp"))) == math.abs(
+        i
+      )
 
   private[this] def local(i: Int) = "{ class ETest(val i: Int); new ETest(" + i + ") }"
   val LocalType = "AnyRef{val i: Int}"
 
   private[this] def value(r: EvalResult) = r.getValue(getClass.getClassLoader)
-  private[this] def hasErrors(line: Int, src: String) =
-    {
-      val is = reporter.infos
-      ("Has errors" |: is.nonEmpty) &&
-        all(is.toSeq.map(validPosition(line, src)): _*)
-    }
-  private[this] def validPosition(line: Int, src: String)(i: Info) =
-    {
-      val nme = i.pos.source.file.name
-      (label("Severity", i.severity) |: (i.severity == ERROR)) &&
-        (label("Line", i.pos.line) |: (i.pos.line == line)) &&
-        (label("Name", nme) |: (nme == src))
-    }
+  private[this] def hasErrors(line: Int, src: String) = {
+    val is = reporter.infos
+    ("Has errors" |: is.nonEmpty) &&
+    all(is.toSeq.map(validPosition(line, src)): _*)
+  }
+  private[this] def validPosition(line: Int, src: String)(i: StoreReporter.Info) = {
+    val nme = i.pos.source.file.name
+    (label("Severity", i.severity) |: (i.severity == ERROR)) &&
+    (label("Line", i.pos.line) |: (i.pos.line == line)) &&
+    (label("Name", nme) |: (nme == src))
+  }
   val IntType = "Int"
   val BooleanType = "Boolean"
 
diff --git a/main-command/src/main/contraband-scala/CommandSourceFormats.scala b/main-command/src/main/contraband-scala/CommandSourceFormats.scala
new file mode 100644
index 000000000..77ef33283
--- /dev/null
+++ b/main-command/src/main/contraband-scala/CommandSourceFormats.scala
@@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CommandSourceFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val CommandSourceFormat: JsonFormat[sbt.CommandSource] = new JsonFormat[sbt.CommandSource] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.CommandSource = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val channelName = unbuilder.readField[String]("channelName")
+      unbuilder.endObject()
+      sbt.CommandSource(channelName)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.CommandSource, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("channelName", obj.channelName)
+    builder.endObject()
+  }
+}
+}
diff --git a/main-command/src/main/contraband-scala/ConnectionTypeFormats.scala b/main-command/src/main/contraband-scala/ConnectionTypeFormats.scala
new file mode 100644
index 000000000..08d115b45
--- /dev/null
+++ b/main-command/src/main/contraband-scala/ConnectionTypeFormats.scala
@@ -0,0 +1,28 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ConnectionTypeFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ConnectionTypeFormat: JsonFormat[sbt.ConnectionType] = new JsonFormat[sbt.ConnectionType] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.ConnectionType = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.readString(__js) match {
+        case "Local" => sbt.ConnectionType.Local
+        case "Tcp" => sbt.ConnectionType.Tcp
+      }
+      case None =>
+      deserializationError("Expected JsString but found None")
+    }
+  }
+  override def write[J](obj: sbt.ConnectionType, builder: Builder[J]): Unit = {
+    val str = obj match {
+      case sbt.ConnectionType.Local => "Local"
+      case sbt.ConnectionType.Tcp => "Tcp"
+    }
+    builder.writeString(str)
+  }
+}
+}
diff --git a/main-command/src/main/contraband-scala/ExecFormats.scala b/main-command/src/main/contraband-scala/ExecFormats.scala
new file mode 100644
index 000000000..c5fee86d5
--- /dev/null
+++ b/main-command/src/main/contraband-scala/ExecFormats.scala
@@ -0,0 +1,30 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ExecFormats { self: CommandSourceFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ExecFormat: JsonFormat[sbt.Exec] = new JsonFormat[sbt.Exec] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.Exec = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val commandLine = unbuilder.readField[String]("commandLine")
+      val execId = unbuilder.readField[Option[String]]("execId")
+      val source = unbuilder.readField[Option[sbt.CommandSource]]("source")
+      unbuilder.endObject()
+      sbt.Exec(commandLine, execId, source)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.Exec, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("commandLine", obj.commandLine)
+    builder.addField("execId", obj.execId)
+    builder.addField("source", obj.source)
+    builder.endObject()
+  }
+}
+}
diff --git a/main-command/src/main/contraband-scala/ServerAuthenticationFormats.scala b/main-command/src/main/contraband-scala/ServerAuthenticationFormats.scala
new file mode 100644
index 000000000..e05ca2bb1
--- /dev/null
+++ b/main-command/src/main/contraband-scala/ServerAuthenticationFormats.scala
@@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ServerAuthenticationFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ServerAuthenticationFormat: JsonFormat[sbt.ServerAuthentication] = new JsonFormat[sbt.ServerAuthentication] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.ServerAuthentication = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.readString(__js) match {
+        case "Token" => sbt.ServerAuthentication.Token
+      }
+      case None =>
+      deserializationError("Expected JsString but found None")
+    }
+  }
+  override def write[J](obj: sbt.ServerAuthentication, builder: Builder[J]): Unit = {
+    val str = obj match {
+      case sbt.ServerAuthentication.Token => "Token"
+    }
+    builder.writeString(str)
+  }
+}
+}
diff --git a/main-command/src/main/contraband-scala/sbt/CommandSource.scala b/main-command/src/main/contraband-scala/sbt/CommandSource.scala
new file mode 100644
index 000000000..938fdbf7c
--- /dev/null
+++ b/main-command/src/main/contraband-scala/sbt/CommandSource.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+final class CommandSource private (
+  val channelName: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CommandSource => (this.channelName == x.channelName)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.CommandSource".##) + channelName.##)
+  }
+  override def toString: String = {
+    "CommandSource(" + channelName + ")"
+  }
+  private[this] def copy(channelName: String = channelName): CommandSource = {
+    new CommandSource(channelName)
+  }
+  def withChannelName(channelName: String): CommandSource = {
+    copy(channelName = channelName)
+  }
+}
+object CommandSource {
+  
+  def apply(channelName: String): CommandSource = new CommandSource(channelName)
+}
diff --git a/main-command/src/main/contraband-scala/sbt/ConnectionType.scala b/main-command/src/main/contraband-scala/sbt/ConnectionType.scala
new file mode 100644
index 000000000..10a0b05e0
--- /dev/null
+++ b/main-command/src/main/contraband-scala/sbt/ConnectionType.scala
@@ -0,0 +1,13 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+sealed abstract class ConnectionType extends Serializable
+object ConnectionType {
+  
+  /** This uses Unix domain socket on POSIX, and named pipe on Windows. */
+  case object Local extends ConnectionType
+  case object Tcp extends ConnectionType
+}
diff --git a/main-command/src/main/contraband-scala/sbt/Exec.scala b/main-command/src/main/contraband-scala/sbt/Exec.scala
new file mode 100644
index 000000000..b37684818
--- /dev/null
+++ b/main-command/src/main/contraband-scala/sbt/Exec.scala
@@ -0,0 +1,49 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+final class Exec private (
+  val commandLine: String,
+  val execId: Option[String],
+  val source: Option[sbt.CommandSource]) extends Serializable {
+  
+  private def this(commandLine: String, source: Option[sbt.CommandSource]) = this(commandLine, None, source)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Exec => (this.commandLine == x.commandLine) && (this.execId == x.execId) && (this.source == x.source)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.Exec".##) + commandLine.##) + execId.##) + source.##)
+  }
+  override def toString: String = {
+    "Exec(" + commandLine + ", " + execId + ", " + source + ")"
+  }
+  private[this] def copy(commandLine: String = commandLine, execId: Option[String] = execId, source: Option[sbt.CommandSource] = source): Exec = {
+    new Exec(commandLine, execId, source)
+  }
+  def withCommandLine(commandLine: String): Exec = {
+    copy(commandLine = commandLine)
+  }
+  def withExecId(execId: Option[String]): Exec = {
+    copy(execId = execId)
+  }
+  def withExecId(execId: String): Exec = {
+    copy(execId = Option(execId))
+  }
+  def withSource(source: Option[sbt.CommandSource]): Exec = {
+    copy(source = source)
+  }
+  def withSource(source: sbt.CommandSource): Exec = {
+    copy(source = Option(source))
+  }
+}
+object Exec {
+  def newExecId: String = java.util.UUID.randomUUID.toString
+  def apply(commandLine: String, source: Option[sbt.CommandSource]): Exec = new Exec(commandLine, source)
+  def apply(commandLine: String, source: sbt.CommandSource): Exec = new Exec(commandLine, Option(source))
+  def apply(commandLine: String, execId: Option[String], source: Option[sbt.CommandSource]): Exec = new Exec(commandLine, execId, source)
+  def apply(commandLine: String, execId: String, source: sbt.CommandSource): Exec = new Exec(commandLine, Option(execId), Option(source))
+}
diff --git a/main-command/src/main/contraband-scala/sbt/ServerAuthentication.scala b/main-command/src/main/contraband-scala/sbt/ServerAuthentication.scala
new file mode 100644
index 000000000..5744c9814
--- /dev/null
+++ b/main-command/src/main/contraband-scala/sbt/ServerAuthentication.scala
@@ -0,0 +1,12 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+sealed abstract class ServerAuthentication extends Serializable
+object ServerAuthentication {
+  
+  
+  case object Token extends ServerAuthentication
+}
diff --git a/main-command/src/main/contraband/state.contra b/main-command/src/main/contraband/state.contra
new file mode 100644
index 000000000..2737ce8ab
--- /dev/null
+++ b/main-command/src/main/contraband/state.contra
@@ -0,0 +1,25 @@
+package sbt
+@target(Scala)
+
+type Exec {
+  commandLine: String!
+  execId: String @since("0.0.1")
+  source: sbt.CommandSource
+
+  #xcompanion def newExecId: String = java.util.UUID.randomUUID.toString
+}
+
+type CommandSource {
+  channelName: String!
+}
+
+enum ServerAuthentication {
+  Token
+}
+
+enum ConnectionType {
+  ## This uses Unix domain socket on POSIX, and named pipe on Windows.
+  Local
+  Tcp
+  # Ssh
+}
diff --git a/main-command/src/main/datatype-scala/sbt/internal/server/CommandMessage.scala b/main-command/src/main/datatype-scala/sbt/internal/server/CommandMessage.scala
deleted file mode 100644
index 889f8fe7a..000000000
--- a/main-command/src/main/datatype-scala/sbt/internal/server/CommandMessage.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * This code is generated using sbt-datatype.
- */
-
-// DO NOT EDIT MANUALLY
-package sbt.internal.server
-final class CommandMessage(
-  val `type`: String,
-  val commandLine: Option[String]) extends Serializable {
-  
-  def this(`type`: String) = this(`type`, None)
-  
-  override def equals(o: Any): Boolean = o match {
-    case x: CommandMessage => (this.`type` == x.`type`) && (this.commandLine == x.commandLine)
-    case _ => false
-  }
-  override def hashCode: Int = {
-    37 * (37 * (17 + `type`.##) + commandLine.##)
-  }
-  override def toString: String = {
-    "CommandMessage(" + `type` + ", " + commandLine + ")"
-  }
-  def copy(`type`: String): CommandMessage = {
-    new CommandMessage(`type`, commandLine)
-  }
-  def copy(`type`: String = `type`, commandLine: Option[String] = commandLine): CommandMessage = {
-    new CommandMessage(`type`, commandLine)
-  }
-  def withType(`type`: String): CommandMessage = {
-    copy(`type` = `type`)
-  }
-  def withCommandLine(commandLine: Option[String]): CommandMessage = {
-    copy(commandLine = commandLine)
-  }
-}
-object CommandMessage {
-  def apply(`type`: String): CommandMessage = new CommandMessage(`type`, None)
-  def apply(`type`: String, commandLine: Option[String]): CommandMessage = new CommandMessage(`type`, commandLine)
-}
diff --git a/main-command/src/main/datatype-scala/sbt/internal/server/EventMessage.scala b/main-command/src/main/datatype-scala/sbt/internal/server/EventMessage.scala
deleted file mode 100644
index 55946b0e7..000000000
--- a/main-command/src/main/datatype-scala/sbt/internal/server/EventMessage.scala
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * This code is generated using sbt-datatype.
- */
-
-// DO NOT EDIT MANUALLY
-package sbt.internal.server
-final class EventMessage(
-  val `type`: String,
-  val status: Option[String],
-  val commandQueue: Vector[String],
-  val level: Option[String],
-  val message: Option[String],
-  val success: Option[Boolean],
-  val commandLine: Option[String]) extends Serializable {
-  
-  def this(`type`: String) = this(`type`, None, Vector(), None, None, None, None)
-  
-  override def equals(o: Any): Boolean = o match {
-    case x: EventMessage => (this.`type` == x.`type`) && (this.status == x.status) && (this.commandQueue == x.commandQueue) && (this.level == x.level) && (this.message == x.message) && (this.success == x.success) && (this.commandLine == x.commandLine)
-    case _ => false
-  }
-  override def hashCode: Int = {
-    37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + `type`.##) + status.##) + commandQueue.##) + level.##) + message.##) + success.##) + commandLine.##)
-  }
-  override def toString: String = {
-    "EventMessage(" + `type` + ", " + status + ", " + commandQueue + ", " + level + ", " + message + ", " + success + ", " + commandLine + ")"
-  }
-  def copy(`type`: String): EventMessage = {
-    new EventMessage(`type`, status, commandQueue, level, message, success, commandLine)
-  }
-  def copy(`type`: String = `type`, status: Option[String] = status, commandQueue: Vector[String] = commandQueue, level: Option[String] = level, message: Option[String] = message, success: Option[Boolean] = success, commandLine: Option[String] = commandLine): EventMessage = {
-    new EventMessage(`type`, status, commandQueue, level, message, success, commandLine)
-  }
-  def withType(`type`: String): EventMessage = {
-    copy(`type` = `type`)
-  }
-  def withStatus(status: Option[String]): EventMessage = {
-    copy(status = status)
-  }
-  def withCommandQueue(commandQueue: Vector[String]): EventMessage = {
-    copy(commandQueue = commandQueue)
-  }
-  def withLevel(level: Option[String]): EventMessage = {
-    copy(level = level)
-  }
-  def withMessage(message: Option[String]): EventMessage = {
-    copy(message = message)
-  }
-  def withSuccess(success: Option[Boolean]): EventMessage = {
-    copy(success = success)
-  }
-  def withCommandLine(commandLine: Option[String]): EventMessage = {
-    copy(commandLine = commandLine)
-  }
-}
-object EventMessage {
-  def apply(`type`: String): EventMessage = new EventMessage(`type`, None, Vector(), None, None, None, None)
-  def apply(`type`: String, status: Option[String], commandQueue: Vector[String], level: Option[String], message: Option[String], success: Option[Boolean], commandLine: Option[String]): EventMessage = new EventMessage(`type`, status, commandQueue, level, message, success, commandLine)
-}
diff --git a/main-command/src/main/datatype-scala/sbt/internal/server/codec/CommandMessageFormats.scala b/main-command/src/main/datatype-scala/sbt/internal/server/codec/CommandMessageFormats.scala
deleted file mode 100644
index 17130c90e..000000000
--- a/main-command/src/main/datatype-scala/sbt/internal/server/codec/CommandMessageFormats.scala
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * This code is generated using sbt-datatype.
- */
-
-// DO NOT EDIT MANUALLY
-package sbt.internal.server.codec
-import _root_.sjsonnew.{ deserializationError, serializationError, Builder, JsonFormat, Unbuilder }
-trait CommandMessageFormats { self: sjsonnew.BasicJsonProtocol =>
-implicit lazy val CommandMessageFormat: JsonFormat[sbt.internal.server.CommandMessage] = new JsonFormat[sbt.internal.server.CommandMessage] {
-  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.server.CommandMessage = {
-    jsOpt match {
-      case Some(js) =>
-      unbuilder.beginObject(js)
-      val `type` = unbuilder.readField[String]("type")
-      val commandLine = unbuilder.readField[Option[String]]("commandLine")
-      unbuilder.endObject()
-      new sbt.internal.server.CommandMessage(`type`, commandLine)
-      case None =>
-      deserializationError("Expected JsObject but found None")
-    }
-  }
-  override def write[J](obj: sbt.internal.server.CommandMessage, builder: Builder[J]): Unit = {
-    builder.beginObject()
-    builder.addField("type", obj.`type`)
-    builder.addField("commandLine", obj.commandLine)
-    builder.endObject()
-  }
-}
-}
diff --git a/main-command/src/main/datatype-scala/sbt/internal/server/codec/EventMessageFormats.scala b/main-command/src/main/datatype-scala/sbt/internal/server/codec/EventMessageFormats.scala
deleted file mode 100644
index 4ce95d9ef..000000000
--- a/main-command/src/main/datatype-scala/sbt/internal/server/codec/EventMessageFormats.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * This code is generated using sbt-datatype.
- */
-
-// DO NOT EDIT MANUALLY
-package sbt.internal.server.codec
-import _root_.sjsonnew.{ deserializationError, serializationError, Builder, JsonFormat, Unbuilder }
-trait EventMessageFormats { self: sjsonnew.BasicJsonProtocol =>
-implicit lazy val EventMessageFormat: JsonFormat[sbt.internal.server.EventMessage] = new JsonFormat[sbt.internal.server.EventMessage] {
-  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.server.EventMessage = {
-    jsOpt match {
-      case Some(js) =>
-      unbuilder.beginObject(js)
-      val `type` = unbuilder.readField[String]("type")
-      val status = unbuilder.readField[Option[String]]("status")
-      val commandQueue = unbuilder.readField[Vector[String]]("commandQueue")
-      val level = unbuilder.readField[Option[String]]("level")
-      val message = unbuilder.readField[Option[String]]("message")
-      val success = unbuilder.readField[Option[Boolean]]("success")
-      val commandLine = unbuilder.readField[Option[String]]("commandLine")
-      unbuilder.endObject()
-      new sbt.internal.server.EventMessage(`type`, status, commandQueue, level, message, success, commandLine)
-      case None =>
-      deserializationError("Expected JsObject but found None")
-    }
-  }
-  override def write[J](obj: sbt.internal.server.EventMessage, builder: Builder[J]): Unit = {
-    builder.beginObject()
-    builder.addField("type", obj.`type`)
-    builder.addField("status", obj.status)
-    builder.addField("commandQueue", obj.commandQueue)
-    builder.addField("level", obj.level)
-    builder.addField("message", obj.message)
-    builder.addField("success", obj.success)
-    builder.addField("commandLine", obj.commandLine)
-    builder.endObject()
-  }
-}
-}
diff --git a/main-command/src/main/datatype/server.json b/main-command/src/main/datatype/server.json
deleted file mode 100644
index 3dcc4af17..000000000
--- a/main-command/src/main/datatype/server.json
+++ /dev/null
@@ -1,73 +0,0 @@
-{
-  "codecNamespace": "sbt.internal.server.codec",
-  "types": [
-    {
-      "name": "CommandMessage",
-      "namespace": "sbt.internal.server",
-      "type": "record",
-      "target": "Scala",
-      "fields": [
-        {
-          "name": "type",
-          "type": "String",
-          "since": "0.0.0"
-        },
-        {
-          "name": "commandLine",
-          "type": "String?",
-          "default": "None",
-          "since": "0.1.0"
-        }
-      ]
-    },
-    {
-      "name": "EventMessage",
-      "namespace": "sbt.internal.server",
-      "type": "record",
-      "target": "Scala",
-      "fields": [
-        {
-          "name": "type",
-          "type": "String",
-          "since": "0.0.0"
-        },
-        {
-          "name": "status",
-          "type": "String?",
-          "default": "None",
-          "since": "0.1.0"
-        },
-        {
-          "name": "commandQueue",
-          "type": "String*",
-          "default": "Vector()",
-          "since": "0.1.0"
-        },
-        {
-          "name": "level",
-          "type": "String?",
-          "default": "None",
-          "since": "0.1.0"
-        },
-        {
-          "name": "message",
-          "type": "String?",
-          "default": "None",
-          "since": "0.1.0"
-        },
-        {
-          "name": "success",
-          "type": "boolean?",
-          "default": "None",
-          "since": "0.1.0"
-        },
-        {
-          "name": "commandLine",
-          "type": "String?",
-          "default": "None",
-          "since": "0.1.0"
-        }
-      ]
-    }
-  ]
-}
diff --git a/main-command/src/main/java/sbt/internal/BootServerSocket.java b/main-command/src/main/java/sbt/internal/BootServerSocket.java
new file mode 100644
index 000000000..beff97566
--- /dev/null
+++ b/main-command/src/main/java/sbt/internal/BootServerSocket.java
@@ -0,0 +1,360 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.Socket;
+import java.net.ServerSocket;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import net.openhft.hashing.LongHashFunction;
+import org.scalasbt.ipcsocket.UnixDomainServerSocket;
+import org.scalasbt.ipcsocket.Win32NamedPipeServerSocket;
+import org.scalasbt.ipcsocket.Win32NamedPipeSocket;
+import org.scalasbt.ipcsocket.Win32SecurityLevel;
+import sbt.internal.util.Terminal;
+import xsbti.AppConfiguration;
+
+/**
+ * A BootServerSocket is used for remote clients to connect to sbt for io while sbt is still loading
+ * the build. There are two scenarios in which this functionality is needed:
+ *
+ * <p>1. client a starts an sbt server and then client b tries to connect to the server before the
+ * server has loaded. Presently, client b will try to start a new server even though there is one
+ * booting. This can cause a java process leak because the second server launched by client b is
+ * unable to create a server because there is an existing portfile by the time it starts up.
+ *
+ * <p>2. a remote client initiates a reboot command. Reboot causes sbt to shutdown the server which
+ * makes the client disconnect. Since sbt does not start the server until the project has
+ * successfully loaded, there is no way for the client to see the output of the server. This is
+ * particularly problematic if loading fails because the server will be stuck waiting for input that
+ * will not be forthcoming.
+ *
+ * <p>To address these issues, the BootServerSocket can be used to immediately create a server
+ * socket before sbt even starts loading the build. It works by creating a local socket either in
+ * project/target/SOCK_NAME or a windows named pipe with name SOCK_NAME where SOCK_NAME is computed
+ * as the hash of the project's base directory (for disambiguation in the windows case). If the
+ * server can't create a server socket because there is already one running, it either prompts the
+ * user if they want to start a new server even if there is already one running if there is a
+ * console available or exits with the status code 2 which indicates that there is another sbt
+ * process starting up.
+ *
+ * <p>Once the server socket is created, it listens for new client connections. When a client
+ * connects, the server will forward its input and output to the client via Terminal.setBootStreams
+ * which updates the Terminal.proxyOutputStream to forward all bytes written to the
+ * BootServerSocket's outputStream which in turn writes the output to each of the connected clients.
+ * Input is handed similarly.
+ *
+ * <p>When the server finishes loading, it closes the boot server socket.
+ *
+ * <p>BootServerSocket is implemented in java so that it can be classloaded as quickly as possible.
+ */
+public class BootServerSocket implements AutoCloseable {
+  private ServerSocket serverSocket = null;
+  private final AtomicBoolean closed = new AtomicBoolean(false);
+  private final AtomicBoolean running = new AtomicBoolean(false);
+  private final AtomicInteger threadId = new AtomicInteger(1);
+  private final Future<?> acceptFuture;
+  private final ExecutorService service =
+      Executors.newCachedThreadPool(
+          r -> new Thread(r, "boot-server-socket-thread-" + threadId.getAndIncrement()));
+  private final Set<ClientSocket> clientSockets = ConcurrentHashMap.newKeySet();
+  private final Object lock = new Object();
+  private final LinkedBlockingQueue<ClientSocket> clientSocketReads = new LinkedBlockingQueue<>();
+  private final Path socketFile;
+  private final AtomicBoolean needInput = new AtomicBoolean(false);
+
+  private class ClientSocket implements AutoCloseable {
+    final Socket socket;
+    final AtomicBoolean alive = new AtomicBoolean(true);
+    final Future<?> future;
+    private final LinkedBlockingQueue<Integer> bytes = new LinkedBlockingQueue<Integer>();
+    private final AtomicBoolean closed = new AtomicBoolean(false);
+
+    @SuppressWarnings("deprecation")
+    ClientSocket(final Socket socket) {
+      this.socket = socket;
+      clientSockets.add(this);
+      Future<?> f = null;
+      try {
+        f =
+            service.submit(
+                () -> {
+                  try {
+                    Terminal.console()
+                        .getLines()
+                        .foreach(
+                            l -> {
+                              try {
+                                write((l + System.lineSeparator()).getBytes("UTF-8"));
+                              } catch (final IOException e) {
+                              }
+                              return 0;
+                            });
+                    final InputStream inputStream = socket.getInputStream();
+                    while (alive.get()) {
+                      try {
+                        synchronized (needInput) {
+                          while (!needInput.get() && alive.get()) needInput.wait();
+                        }
+                        if (alive.get()) {
+                          socket.getOutputStream().write(5);
+                          int b = inputStream.read();
+                          if (b != -1) {
+                            bytes.put(b);
+                            clientSocketReads.put(ClientSocket.this);
+                          } else {
+                            alive.set(false);
+                          }
+                        }
+
+                      } catch (IOException e) {
+                        alive.set(false);
+                      }
+                    }
+                  } catch (final Exception ex) {
+                  }
+                });
+      } catch (final RejectedExecutionException e) {
+        alive.set(false);
+      }
+      future = f;
+    }
+
+    private void write(final int i) {
+      try {
+        if (alive.get()) socket.getOutputStream().write(i);
+      } catch (final IOException e) {
+        alive.set(false);
+        close();
+      }
+    }
+
+    private void write(final byte[] b) {
+      try {
+        if (alive.get()) socket.getOutputStream().write(b);
+      } catch (final IOException e) {
+        alive.set(false);
+        close();
+      }
+    }
+
+    private void write(final byte[] b, final int offset, final int len) {
+      try {
+        if (alive.get()) socket.getOutputStream().write(b, offset, len);
+      } catch (final IOException e) {
+        alive.set(false);
+        close();
+      }
+    }
+
+    private void flush() {
+      try {
+        socket.getOutputStream().flush();
+      } catch (final IOException e) {
+        alive.set(false);
+        close();
+      }
+    }
+
+    @SuppressWarnings("EmptyCatchBlock")
+    @Override
+    public void close() {
+      if (closed.compareAndSet(false, true)) {
+        if (alive.get()) {
+          write(2);
+          bytes.forEach(this::write);
+          bytes.clear();
+          write(3);
+          flush();
+        }
+        alive.set(false);
+        if (future != null) future.cancel(true);
+        try {
+          socket.getOutputStream().close();
+          socket.getInputStream().close();
+          // Windows is very slow to close the socket for whatever reason
+          // We close the server socket anyway, so this should die then.
+          if (!System.getProperty("os.name", "").toLowerCase().startsWith("win")) socket.close();
+        } catch (final IOException e) {
+        }
+        clientSockets.remove(this);
+      }
+    }
+  }
+
+  private final Object writeLock = new Object();
+
+  public InputStream inputStream() {
+    return inputStream;
+  }
+
+  private final InputStream inputStream =
+      new InputStream() {
+        @Override
+        public int read() {
+          if (clientSockets.isEmpty()) return Terminal.NO_BOOT_CLIENTS_CONNECTED();
+          try {
+            synchronized (needInput) {
+              needInput.set(true);
+              needInput.notifyAll();
+            }
+            ClientSocket clientSocket = clientSocketReads.take();
+            return clientSocket.bytes.take();
+          } catch (final InterruptedException e) {
+            return -1;
+          } finally {
+            synchronized (needInput) {
+              needInput.set(false);
+            }
+          }
+        }
+      };
+  private final OutputStream outputStream =
+      new OutputStream() {
+        @Override
+        public void write(final int b) {
+          synchronized (lock) {
+            clientSockets.forEach(cs -> cs.write(b));
+          }
+        }
+
+        @Override
+        public void write(final byte[] b) {
+          write(b, 0, b.length);
+        }
+
+        @Override
+        public void write(final byte[] b, final int offset, final int len) {
+          synchronized (lock) {
+            clientSockets.forEach(cs -> cs.write(b, offset, len));
+          }
+        }
+
+        @Override
+        public void flush() {
+          synchronized (lock) {
+            clientSockets.forEach(cs -> cs.flush());
+          }
+        }
+      };
+
+  public OutputStream outputStream() {
+    return outputStream;
+  }
+
+  private final Runnable acceptRunnable =
+      () -> {
+        try {
+          serverSocket.setSoTimeout(5000);
+          while (running.get()) {
+            try {
+              ClientSocket clientSocket = new ClientSocket(serverSocket.accept());
+            } catch (final SocketTimeoutException e) {
+            } catch (final IOException e) {
+              running.set(false);
+            }
+          }
+        } catch (final SocketException e) {
+        }
+      };
+
+  public BootServerSocket(final AppConfiguration configuration)
+      throws ServerAlreadyBootingException, IOException {
+    final Path base = configuration.baseDirectory().toPath().toRealPath();
+    final Path target = base.resolve("project").resolve("target");
+    if (!isWindows) {
+      if (!Files.isDirectory(target)) Files.createDirectories(target);
+      socketFile = Paths.get(socketLocation(base));
+    } else {
+      socketFile = null;
+    }
+    serverSocket = newSocket(socketLocation(base));
+    if (serverSocket != null) {
+      running.set(true);
+      acceptFuture = service.submit(acceptRunnable);
+    } else {
+      closed.set(true);
+      acceptFuture = null;
+    }
+  }
+
+  public static String socketLocation(final Path base) throws UnsupportedEncodingException {
+    final Path target = base.resolve("project").resolve("target");
+    if (isWindows) {
+      long hash = LongHashFunction.farmNa().hashBytes(target.toString().getBytes("UTF-8"));
+      return "sbt-load" + hash;
+    } else {
+      return base.relativize(target.resolve("sbt-load.sock")).toString();
+    }
+  }
+
+  @SuppressWarnings("EmptyCatchBlock")
+  @Override
+  public void close() {
+    if (closed.compareAndSet(false, true)) {
+      // avoid concurrent modification exception
+      clientSockets.forEach(ClientSocket::close);
+      if (acceptFuture != null) acceptFuture.cancel(true);
+      service.shutdownNow();
+      try {
+        if (serverSocket != null) serverSocket.close();
+      } catch (final IOException e) {
+      }
+      try {
+        if (socketFile != null) Files.deleteIfExists(socketFile);
+      } catch (final IOException e) {
+      }
+    }
+  }
+
+  static final boolean isWindows =
+      System.getProperty("os.name", "").toLowerCase().startsWith("win");
+
+  static ServerSocket newSocket(final String sock) throws ServerAlreadyBootingException {
+    ServerSocket socket = null;
+    String name = socketName(sock);
+    boolean jni = requiresJNI() || System.getProperty("sbt.ipcsocket.jni", "false").equals("true");
+    try {
+      if (!isWindows) Files.deleteIfExists(Paths.get(sock));
+      socket =
+          isWindows
+              ? new Win32NamedPipeServerSocket(name, jni, Win32SecurityLevel.OWNER_DACL)
+              : new UnixDomainServerSocket(name, jni);
+      return socket;
+    } catch (final IOException e) {
+      throw new ServerAlreadyBootingException(e);
+    }
+  }
+
+  public static Boolean requiresJNI() {
+    final boolean isMac = System.getProperty("os.name").toLowerCase().startsWith("mac");
+    return isMac && !System.getProperty("os.arch", "").equals("x86_64");
+  }
+
+  private static String socketName(String sock) {
+    return isWindows ? "\\\\.\\pipe\\" + sock : sock;
+  }
+}
diff --git a/main-command/src/main/java/sbt/internal/ServerAlreadyBootingException.java b/main-command/src/main/java/sbt/internal/ServerAlreadyBootingException.java
new file mode 100644
index 000000000..90a16fdff
--- /dev/null
+++ b/main-command/src/main/java/sbt/internal/ServerAlreadyBootingException.java
@@ -0,0 +1,17 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.IOException;
+
+public class ServerAlreadyBootingException extends Exception {
+
+  public ServerAlreadyBootingException(IOException e) {
+    super(e);
+  }
+}
diff --git a/main-command/src/main/java/sbt/internal/classpath/WrappedLoader.java b/main-command/src/main/java/sbt/internal/classpath/WrappedLoader.java
new file mode 100644
index 000000000..76942d046
--- /dev/null
+++ b/main-command/src/main/java/sbt/internal/classpath/WrappedLoader.java
@@ -0,0 +1,45 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.classpath;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class WrappedLoader extends URLClassLoader {
+  private final AtomicBoolean invalidated = new AtomicBoolean(false);
+
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+
+  WrappedLoader(final ClassLoader parent) {
+    super(new URL[] {}, parent);
+  }
+
+  void invalidate() {
+    invalidated.set(true);
+  }
+
+  boolean invalidated() {
+    return invalidated.get();
+  }
+
+  @Override
+  public URL[] getURLs() {
+    final ClassLoader parent = getParent();
+    return (parent instanceof URLClassLoader)
+        ? ((URLClassLoader) parent).getURLs()
+        : super.getURLs();
+  }
+
+  @Override
+  public String toString() {
+    return "WrappedClassLoader(" + getParent() + ")";
+  }
+}
diff --git a/main-command/src/main/scala/sbt/BasicCommandStrings.scala b/main-command/src/main/scala/sbt/BasicCommandStrings.scala
index bfd424a65..d7a310929 100644
--- a/main-command/src/main/scala/sbt/BasicCommandStrings.scala
+++ b/main-command/src/main/scala/sbt/BasicCommandStrings.scala
@@ -1,50 +1,76 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import sbt.util.Level
 import sbt.internal.util.complete.HistoryCommands
 
 object BasicCommandStrings {
-  val HelpCommand = "help"
-  val CompletionsCommand = "completions"
-  val Exit = "exit"
-  val Quit = "quit"
+  val HelpCommand: String = "help"
+  val CompletionsCommand: String = "completions"
+  val Exit: String = "exit"
+  val Shutdown: String = "shutdown"
+  val Quit: String = "quit"
+  val TemplateCommand: String = "new"
+  val Cancel: String = "cancel"
 
   /** The command name to terminate the program.*/
   val TerminateAction: String = Exit
 
-  def helpBrief = (HelpCommand, s"Displays this help message or prints detailed help on requested commands (run '$HelpCommand <command>').")
-  def helpDetailed = HelpCommand + """
+  def helpBrief: (String, String) =
+    (
+      HelpCommand,
+      s"Displays this help message or prints detailed help on requested commands (run '$HelpCommand <command>')."
+    )
+  def helpDetailed: String = s"""$HelpCommand
 
 	Prints a help summary.
 
-""" + HelpCommand + """ <command>
+$HelpCommand <command>
 
 	Prints detailed help for command <command>.
 
-""" + HelpCommand + """ <regular expression>
+$HelpCommand <regular expression>
 
 	Searches the help according to the provided regular expression.
 """
 
-  def CompletionsDetailed = "Displays a list of completions for the given argument string (run 'completions <string>')."
-  def CompletionsBrief = (CompletionsCommand, CompletionsDetailed)
+  def CompletionsDetailed: String =
+    "Displays a list of completions for the given argument string (run 'completions <string>')."
+  def CompletionsBrief: (String, String) = (CompletionsCommand, CompletionsDetailed)
 
-  def HistoryHelpBrief = (HistoryCommands.Start -> "History command help.  Lists and describes all history commands.")
-  def historyHelp = Help(Nil, (HistoryHelpBrief +: HistoryCommands.descriptions).toMap, Set(HistoryCommands.Start))
+  def templateBrief: (String, String) = (TemplateCommand, "Creates a new sbt build.")
+  def templateDetailed: String =
+    TemplateCommand + """ [--options] <template>
+  Create a new sbt build based on the given template.
+  sbt provides out-of-the-box support for Giter8 templates. See foundweekends.org/giter8/ for details.
+  
+  Example:
+    sbt new scala/scala-seed.g8
+  """
 
-  def exitBrief = "Terminates the build."
+  def HistoryHelpBrief: (String, String) =
+    (HistoryCommands.Start, "History command help.  Lists and describes all history commands.")
+  def historyHelp =
+    Help(Nil, (HistoryHelpBrief +: HistoryCommands.descriptions).toMap, Set(HistoryCommands.Start))
+
+  def exitBrief: String = "Terminates the remote client or the build when called from the console."
+  def shutdownBrief: String = "Terminates the build."
+
+  def logLevelHelp: Help = {
+    val levels = Level.values.toSeq
+    val levelList = levels.mkString(", ")
+    val brief =
+      ("<log-level>", "Sets the logging level to 'log-level'.  Valid levels: " + levelList)
+    val detailed = levels.map(l => (l.toString, logLevelDetail(l))).toMap
+    Help(brief, detailed)
+  }
 
-  def logLevelHelp =
-    {
-      val levels = Level.values.toSeq
-      val levelList = levels.mkString(", ")
-      val brief = ("<log-level>", "Sets the logging level to 'log-level'.  Valid levels: " + levelList)
-      val detailed = levels.map(l => (l.toString, logLevelDetail(l))).toMap
-      Help(brief, detailed)
-    }
   private[this] def logLevelDetail(level: Level.Value): String =
     s"""$level
 
@@ -52,7 +78,7 @@ object BasicCommandStrings {
 	This will be used as the default level for logging from commands, settings, and tasks.
 	Any explicit `logLevel` configuration in a project overrides this setting.
 
--$level
+-$level OR --$level
 
 	Sets the global logging level as described above, but does so before any other commands are executed on startup, including project loading.
 	This is useful as a startup option:
@@ -60,25 +86,37 @@ object BasicCommandStrings {
 		* if no other commands are passed, interactive mode is still entered
 """
 
-  def runEarly(command: String) = s"$EarlyCommand($command)"
+  def runEarly(command: String): String = s"$EarlyCommand($command)"
   private[sbt] def isEarlyCommand(s: String): Boolean = {
-    val levelOptions = Level.values.toSeq map { "-" + _ }
+    val levelOptions = Level.values.toSeq flatMap { elem =>
+      List("-" + elem, "--" + elem)
+    }
     (s.startsWith(EarlyCommand + "(") && s.endsWith(")")) ||
-      (levelOptions contains s)
+    (levelOptions contains s) ||
+    (s.startsWith("-" + AddPluginSbtFileCommand) || s.startsWith("--" + AddPluginSbtFileCommand))
   }
 
-  val EarlyCommand = "early"
-  val EarlyCommandBrief = (s"$EarlyCommand(<command>)", "Schedules a command to run before other commands on startup.")
-  val EarlyCommandDetailed =
+  val EarlyCommand: String = "early"
+  val EarlyCommandBrief: (String, String) =
+    (s"$EarlyCommand(<command>)", "Schedules a command to run before other commands on startup.")
+  val EarlyCommandDetailed: String =
     s"""$EarlyCommand(<command>)
 
 	Schedules an early command, which will be run before other commands on the command line.
 	The order is preserved between all early commands, so `sbt "early(a)" "early(b)"` executes `a` and `b` in order.
 """
 
-  def ReadCommand = "<"
-  def ReadFiles = " file1 file2 ..."
-  def ReadDetailed =
+  def addPluginSbtFileHelp(): Help = {
+    val brief =
+      (s"--$AddPluginSbtFileCommand=<file>", "Adds the given *.sbt file to the plugin build.")
+    Help(brief)
+  }
+
+  val AddPluginSbtFileCommand: String = "addPluginSbtFile"
+
+  def ReadCommand: String = "<"
+  def ReadFiles: String = " file1 file2 ..."
+  def ReadDetailed: String =
     ReadCommand + ReadFiles + """
 
 	Reads the lines from the given files and inserts them as commands.
@@ -91,88 +129,104 @@ object BasicCommandStrings {
 
 	You probably need to escape this command if entering it at your shell."""
 
-  def ApplyCommand = "apply"
-  def ApplyDetailed =
+  def ApplyCommand: String = "apply"
+  def ApplyDetailed: String =
     ApplyCommand + """ [-cp|-classpath <classpath>] <module-name>*
 	Transforms the current State by calling <module-name>.apply(currentState) for each listed module name.
 	Here, currentState is of type sbt.State.
    If a classpath is provided, modules are loaded from a new class loader for this classpath.
 """
 
-  def RebootCommand = "reboot"
-  def RebootDetailed =
-    RebootCommand + """ [full]
+  private[sbt] def RebootNetwork: String = "sbtRebootNetwork"
+  private[sbt] def RebootImpl: String = "sbtRebootImpl"
+  def RebootCommand: String = "reboot"
+  def RebootDetailed: String =
+    RebootCommand + """ [dev | full]
 
 	This command is equivalent to exiting sbt, restarting, and running the
 	  remaining commands with the exception that the JVM is not shut down.
 
-	If 'full' is specified, the boot directory (`~/.sbt/boot` by default)
-	  is deleted before restarting.  This forces an update of sbt and Scala
-	  and is useful when working with development versions of sbt or Scala."""
+	If 'dev' is specified, the current sbt artifacts from the boot directory
+	  (`~/.sbt/boot` by default) are deleted before restarting.
+	This forces an update of sbt and Scala, which is useful when working with development
+	  versions of sbt.
+	If 'full' is specified, the boot directory is wiped out before restarting.
+"""
 
-  def Multi = ";"
-  def MultiBrief = (Multi + " <command> (" + Multi + " <command>)*", "Runs the provided semicolon-separated commands.")
-  def MultiDetailed =
+  def Multi: String = ";"
+  def MultiBrief: (String, String) =
+    (
+      "<command> (" + Multi + " <command>)*",
+      "Runs the provided semicolon-separated commands."
+    )
+  def MultiDetailed: String =
     Multi + " command1 " + Multi + """ command2 ...
 
 	Runs the specified commands."""
 
-  def AppendCommand = "append"
-  def AppendLastDetailed =
+  def AppendCommand: String = "append"
+  def AppendLastDetailed: String =
     AppendCommand + """ <command>
 	Appends 'command' to list of commands to run.
 """
 
-  val AliasCommand = "alias"
-  def AliasDetailed =
-    AliasCommand + """
+  val AliasCommand: String = "alias"
+  def AliasDetailed: String =
+    s"""$AliasCommand
 
 	Prints a list of defined aliases.
 
-""" +
-      AliasCommand + """ name
+$AliasCommand name
 
 	Prints the alias defined for `name`.
 
-""" +
-      AliasCommand + """ name=value
+$AliasCommand name=value
 
 	Sets the alias `name` to `value`, replacing any existing alias with that name.
 	Whenever `name` is entered, the corresponding `value` is run.
 	If any argument is provided to `name`, it is appended as argument to `value`.
 
-""" +
-      AliasCommand + """ name=
+$AliasCommand name=
 
 	Removes the alias for `name`."""
 
   def Shell = "shell"
-  def ShellDetailed = "Provides an interactive prompt from which commands can be run."
+  def ShellDetailed: String =
+    "Provides an interactive prompt and network server from which commands can be run."
 
-  def Server = "server"
-  def ServerDetailed = "Provides a network server and an interactive prompt from which commands can be run."
+  def StartServer = "startServer"
+  def StartServerDetailed: String =
+    s"""$StartServer
+	Starts the server if it has not been started. This is intended to be used with
+	-Dsbt.server.autostart=false."""
 
-  def StashOnFailure = "sbtStashOnFailure"
-  def PopOnFailure = "sbtPopOnFailure"
+  def ServerDetailed: String =
+    "--server always runs sbt in not-daemon mode."
+  def DashDashServer: String = "--server"
 
-  // commands with poor choices for names since they clash with the usual conventions for command line options
-  //   these are not documented and are mainly internal commands and can be removed without a full deprecation cycle
-  object Compat {
-    def OnFailure = "-"
-    def ClearOnFailure = "--"
-    def FailureWall = "---"
-    def OnFailureDeprecated = deprecatedAlias(OnFailure, BasicCommandStrings.OnFailure)
-    def ClearOnFailureDeprecated = deprecatedAlias(ClearOnFailure, BasicCommandStrings.ClearOnFailure)
-    def FailureWallDeprecated = deprecatedAlias(FailureWall, BasicCommandStrings.FailureWall)
-    private[this] def deprecatedAlias(oldName: String, newName: String): String =
-      s"The `$oldName` command is deprecated in favor of `$newName` and will be removed in 0.14.0"
-  }
+  def OldShell: String = "oldshell"
+  def OldShellDetailed = "Provides an interactive prompt from which commands can be run."
 
-  def FailureWall = "resumeFromFailure"
+  def Client: String = "client"
+  def ClientDetailed: String =
+    "Provides an interactive prompt from which commands can be run on a server."
+  def DashClient: String = "-client"
+  def DashDashClient: String = "--client"
+  def DashDashDetachStdio: String = "--detach-stdio"
 
-  def ClearOnFailure = "sbtClearOnFailure"
-  def OnFailure = "onFailure"
-  def OnFailureDetailed =
+  def StashOnFailure: String = "sbtStashOnFailure"
+  def PopOnFailure: String = "sbtPopOnFailure"
+
+  def FailureWall: String = "resumeFromFailure"
+
+  def ReportResult = "sbtReportResult"
+  def CompleteExec = "sbtCompleteExec"
+  def MapExec = "sbtMapExec"
+  def PromptChannel = "sbtPromptChannel"
+
+  def ClearOnFailure: String = "sbtClearOnFailure"
+  def OnFailure: String = "onFailure"
+  def OnFailureDetailed: String =
     OnFailure + """ command
 
 	Registers 'command' to run when a command fails to complete normally.
@@ -186,11 +240,17 @@ object BasicCommandStrings {
   def IfLast = "iflast"
   def IfLastCommon = "If there are no more commands after this one, 'command' is run."
   def IfLastDetailed =
-    IfLast + """ <command>
+    s"""$IfLast <command>
 
-	""" + IfLastCommon
+	$IfLastCommon"""
 
   val ContinuousExecutePrefix = "~"
-  def continuousDetail = "Executes the specified command whenever source files change."
-  def continuousBriefHelp = (ContinuousExecutePrefix + " <command>", continuousDetail)
+  def continuousDetail: String = "Executes the specified command whenever source files change."
+  def continuousBriefHelp: (String, String) =
+    (ContinuousExecutePrefix + " <command>", continuousDetail)
+  def ClearCaches: String = "clearCaches"
+  def ClearCachesDetailed: String = "Clears all of sbt's internal caches."
+
+  private[sbt] val networkExecPrefix = "__"
+  private[sbt] val DisconnectNetworkChannel = s"${networkExecPrefix}disconnectNetworkChannel"
 }
diff --git a/main-command/src/main/scala/sbt/BasicCommands.scala b/main-command/src/main/scala/sbt/BasicCommands.scala
index 12e0ef49b..9a3e49936 100644
--- a/main-command/src/main/scala/sbt/BasicCommands.scala
+++ b/main-command/src/main/scala/sbt/BasicCommands.scala
@@ -1,178 +1,395 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
+import java.nio.file.Paths
 import sbt.util.Level
-import sbt.internal.util.{ AttributeKey, FullReader }
-import sbt.internal.util.complete.{ Completion, Completions, DefaultParsers, History => CHistory, HistoryCommands, Parser, TokenCompletions }
+import sbt.internal.util.{ AttributeKey, FullReader, LineReader, Terminal }
+import sbt.internal.util.complete.{
+  Completion,
+  Completions,
+  DefaultParsers,
+  HistoryCommands,
+  Parser,
+  TokenCompletions,
+  History => CHistory
+}
 import sbt.internal.util.Types.{ const, idFun }
-import sbt.internal.inc.classpath.ClasspathUtilities.toLoader
+import sbt.internal.util.Util.{ AnyOps, nil, nilSeq, none }
+import sbt.internal.inc.classpath.ClasspathUtil.toLoader
 import sbt.internal.inc.ModuleUtilities
-import sbt.internal.{ Exec, CommandSource, CommandStatus }
+import sbt.internal.client.NetworkClient
 import DefaultParsers._
+
 import Function.tupled
 import Command.applyEffect
 import BasicCommandStrings._
 import CommandUtil._
 import BasicKeys._
-
 import java.io.File
-import sbt.io.IO
-import java.util.concurrent.atomic.AtomicBoolean
 
+import sbt.io.IO
+import sbt.util.Level
+
+import scala.Function.tupled
+import scala.collection.mutable.ListBuffer
 import scala.util.control.NonFatal
 
 object BasicCommands {
-  lazy val allBasicCommands = Seq(nop, ignore, help, completionsCommand, multi, ifLast, append, setOnFailure, clearOnFailure, stashOnFailure, popOnFailure, reboot, call, early, exit, continuous, history, shell, server, read, alias) ++ compatCommands
+  lazy val allBasicCommands: Seq[Command] = Seq(
+    nop,
+    ignore,
+    help,
+    completionsCommand,
+    ifLast,
+    append,
+    setOnFailure,
+    clearOnFailure,
+    stashOnFailure,
+    popOnFailure,
+    reboot,
+    rebootImpl,
+    call,
+    early,
+    exit,
+    shutdown,
+    history,
+    oldshell,
+    client,
+    read,
+    alias,
+    reportResultsCommand,
+    mapExecCommand,
+    completeExecCommand,
+  )
 
-  def nop = Command.custom(s => success(() => s))
-  def ignore = Command.command(FailureWall)(idFun)
+  def nop: Command = Command.custom(s => success(() => s))
+  def ignore: Command = Command.command(FailureWall)(idFun)
+
+  def early: Command = Command.arb(earlyParser, earlyHelp)((s, other) => other :: s)
 
-  def early = Command.arb(earlyParser, earlyHelp) { (s, other) => other :: s }
   private[this] def levelParser: Parser[String] =
-    token(Level.Debug.toString) | token(Level.Info.toString) | token(Level.Warn.toString) | token(Level.Error.toString)
-  private[this] def earlyParser: State => Parser[String] = (s: State) =>
-    (token(EarlyCommand + "(") flatMap { _ =>
-      otherCommandParser(s) <~ token(")")
-    }) |
-      (token("-") flatMap { _ =>
-        levelParser
-      })
+    Iterator(Level.Debug, Level.Info, Level.Warn, Level.Error) map (l => token(l.toString)) reduce (_ | _)
+
+  private[this] def addPluginSbtFileParser: Parser[File] = {
+    token(AddPluginSbtFileCommand) ~> (":" | "=" | Space.map(_.toString)) ~> (StringBasic).examples(
+      "/some/extra.sbt"
+    ) map {
+      new File(_)
+    }
+  }
+
+  private[this] def addPluginSbtFileStringParser: Parser[String] = {
+    token(
+      token(AddPluginSbtFileCommand) ~ (":" | "=" | Space.map(_.toString)) ~ (StringBasic)
+        .examples("/some/extra.sbt") map {
+        case s1 ~ s2 ~ s3 => s1 + s2 + s3
+      }
+    )
+  }
+
+  private[this] def earlyParser: State => Parser[String] = (s: State) => {
+    val p1 = token(EarlyCommand + "(") flatMap (_ => otherCommandParser(s) <~ token(")"))
+    val p2 = (token("-") | token("--")) flatMap (_ => levelParser)
+    val p3 = (token("-") | token("--")) flatMap (_ => addPluginSbtFileStringParser)
+    p1 | p2 | p3
+  }
+
   private[this] def earlyHelp = Help(EarlyCommand, EarlyCommandBrief, EarlyCommandDetailed)
 
-  def help = Command.make(HelpCommand, helpBrief, helpDetailed)(helpParser)
+  /**
+   * Adds additional *.sbt to the plugin build.
+   * This must be combined with early command as: --addPluginSbtFile=/tmp/extra.sbt
+   */
+  def addPluginSbtFile: Command = Command.arb(_ => addPluginSbtFileParser, addPluginSbtFileHelp) {
+    (s, extraSbtFile) =>
+      val extraFiles = s.get(BasicKeys.extraMetaSbtFiles).toList.flatten
+      s.put(BasicKeys.extraMetaSbtFiles, (extraFiles: Seq[File]) :+ extraSbtFile)
+  }
 
-  def helpParser(s: State) =
-    {
-      val h = (Help.empty /: s.definedCommands) { (a, b) =>
-        a ++
-          (try b.help(s) catch { case NonFatal(ex) => Help.empty })
-      }
-      val helpCommands = h.detail.keySet
-      val spacedArg = singleArgument(helpCommands).?
-      applyEffect(spacedArg)(runHelp(s, h))
+  def help: Command = Command.make(HelpCommand, helpBrief, helpDetailed)(helpParser)
+
+  def helpParser(s: State): Parser[() => State] = {
+    val h = s.definedCommands.foldLeft(Help.empty)(
+      (a, b) =>
+        a ++ (try b.help(s)
+        catch { case NonFatal(_) => Help.empty })
+    )
+    val helpCommands = h.detail.keySet
+    val spacedArg = singleArgument(helpCommands).?
+    applyEffect(spacedArg)(runHelp(s, h))
+  }
+
+  def runHelp(s: State, h: Help)(arg: Option[String]): State = {
+
+    val (extraArgs, remainingCommands) = s.remainingCommands match {
+      case xs :+ exec if exec.commandLine == "shell" => (xs, exec :: Nil)
+      case xs                                        => (xs, nil[Exec])
     }
 
-  def runHelp(s: State, h: Help)(arg: Option[String]): State =
-    {
-      val message = try
-        Help.message(h, arg)
-      catch {
-        case NonFatal(ex) =>
-          ex.toString
-      }
-      System.out.println(message)
-      s
+    val topic = (arg.toList ++ extraArgs.map(_.commandLine)) match {
+      case Nil => none[String]
+      case xs  => xs.mkString(" ").some
     }
-  @deprecated("Use Help.moreMessage", "0.13.0")
-  def moreHelp(more: Seq[String]): String = Help.moreMessage(more)
+    val message = try Help.message(h, topic)
+    catch { case NonFatal(ex) => ex.toString }
+    System.out.println(message)
+    s.copy(remainingCommands = remainingCommands)
+  }
 
-  def completionsCommand = Command.make(CompletionsCommand, CompletionsBrief, CompletionsDetailed)(completionsParser)
-  def completionsParser(state: State) =
-    {
-      val notQuoted = (NotQuoted ~ any.*) map { case (nq, s) => nq ++ s }
-      val quotedOrUnquotedSingleArgument = Space ~> (StringVerbatim | StringEscapable | notQuoted)
+  def completionsCommand: Command =
+    Command(CompletionsCommand, CompletionsBrief, CompletionsDetailed)(_ => completionsParser)(
+      runCompletions(_)(_)
+    )
+
+  @deprecated("No longer public", "1.1.1")
+  def completionsParser(state: State): Parser[String] = completionsParser
+
+  private[this] def completionsParser: Parser[String] = {
+    val notQuoted = (NotQuoted ~ any.*) map { case (nq, s) => nq + s }
+    val quotedOrUnquotedSingleArgument = Space ~> (StringVerbatim | StringEscapable | notQuoted)
+    token(quotedOrUnquotedSingleArgument ?? "" examples ("", " "))
+  }
 
-      applyEffect(token(quotedOrUnquotedSingleArgument ?? "" examples ("", " ")))(runCompletions(state))
-    }
   def runCompletions(state: State)(input: String): State = {
-    Parser.completions(state.combinedParser, input, 9).get map {
-      c => if (c.isEmpty) input else input + c.append
+    Parser.completions(state.combinedParser, input, 9).get map { c =>
+      if (c.isEmpty) input else input + c.append
     } foreach { c =>
       System.out.println("[completions] " + c.replaceAll("\n", " "))
     }
     state
   }
 
-  def multiParser(s: State): Parser[Seq[String]] =
-    {
-      val nonSemi = token(charClass(_ != ';').+, hide = const(true))
-      (token(';' ~> OptSpace) flatMap { _ => matched((s.combinedParser & nonSemi) | nonSemi) <~ token(OptSpace) } map (_.trim)).+
+  private[sbt] def multiParserImpl(state: Option[State]): Parser[List[String]] =
+    multiParserImpl(state, "alias" :: Nil)
+  private[sbt] def multiParserImpl(
+      state: Option[State],
+      exclude: Seq[String]
+  ): Parser[List[String]] = {
+    val nonSemi = charClass(_ != ';', "not ';'")
+    val nonDelim = charClass(c => c != '"' && c != '{' && c != '}', label = "not '\"', '{', '}'")
+    // Accept empty commands to simplify the parser.
+    val cmdPart =
+      matched(((nonSemi & nonDelim).map(_.toString) | StringEscapable | braces('{', '}')).*)
+        .examples()
+
+    val completionParser: Option[Parser[String]] =
+      state.map(s => (matched(s.nonMultiParser) & cmdPart) | cmdPart)
+    val cmdParser = {
+      val parser = completionParser.getOrElse(cmdPart).map(_.trim)
+      exclude.foldLeft(parser) { case (p, e) => p & not(OptSpace ~ s"$e ", s"!$e").examples() }
+    }
+    val multiCmdParser: Parser[String] = token(';') ~> OptSpace ~> cmdParser
+
+    /*
+     * We accept empty commands at the end of the the list as an implementation detail that allows
+     * for a trailing semi-colon without an extra parser since the cmdParser accepts an empty string
+     * and the multi parser is `token(';') ~ cmdParser`. We do not want to accept empty commands
+     * that occur in the middle of the sequence so if  we find one, we return a failed parser. If
+     * we wanted to relax that restriction, then we could just replace the flatMap below with
+     * `rest.filterNot(_.isEmpty)`.
+     */
+    def validateCommands(s: Seq[String]): Parser[List[String]] = {
+      val result = new ListBuffer[String]
+      val it = s.iterator
+      var fail = false
+      while (it.hasNext && !fail) {
+        it.next match {
+          case ""   => fail = it.hasNext; ()
+          case next => result += next; ()
+        }
+      }
+      if (fail) Parser.failure(s"Couldn't parse empty commands in ${s.mkString(";")}")
+      else Parser.success(result.toList)
     }
 
-  def multiApplied(s: State) =
-    Command.applyEffect(multiParser(s))(_ ::: s)
+    (cmdParser ~ multiCmdParser.+)
+      .flatMap {
+        case ("", rest) => validateCommands(rest)
+        case (p, rest)  => validateCommands(rest).map(p :: _)
+      }
+  }
 
-  def multi = Command.custom(multiApplied, Help(Multi, MultiBrief, MultiDetailed))
+  def multiParser(s: State): Parser[List[String]] = multiParserImpl(Some(s))
+
+  def multiApplied(state: State): Parser[() => State] = {
+    Command.applyEffect(multiParserImpl(Some(state))) {
+      // the (@ _ :: _) ensures tail length >= 1.
+      case commands @ first :: (tail @ _ :: _) =>
+        require(first.head != ' ', s"Commands must be trimmed. Received: '$first'.")
+        // Note: scalafmt refuses to align on '*' using multiline /*...*/ here
+        //
+        // This case is only executed if the multi parser actually returns multiple commands to run.
+        // Otherwise we just prefix the single extracted command with the semicolon stripped to the
+        // state. Since there is no semicolon in the stripped command, the multi command parser will
+        // fail to parse that single command so we do not end up in a loop.
+        //
+        // If there are multiple commands, we give a named command a chance to parse the raw input
+        // and possibly directly evaluate the side effects. This is desirable if, for example,
+        // the command runs other commands. The continuous (~) command is one such example. If the
+        // input command is `~foo; bar`, the multi parser would extract "~foo" :: "bar" :: Nil.
+        // If we naively just prepended the state with both of these commands, it would run '~foo'
+        // and then when watch exited, it'd run 'bar', which is likely unexpected. To address this,
+        // we search for a named command whose name is a prefix of the first command in the list.
+        // In this case, we'd find '~' and then pass 'foo;bar' into its parser. If this succeeds,
+        // which it will in the case of continuous (so long as foo and bar are valid commands),
+        // then we directly evaluate the `() => State` returned by the parser. Otherwise, we
+        // fall back to prefixing the multi commands to the state.
+        //
+        state.nonMultiCommands.view.flatMap { command =>
+          command.nameOption match {
+            case Some(commandName) if first.startsWith(commandName) =>
+              // A lot of commands expect leading semicolons in their parsers. In order to
+              // ensure that they are multi-command capable, we strip off any leading spaces.
+              // Without doing this, we could run simple commands like `set` with the full
+              // input. This would likely fail because `set` doesn't know how to handle
+              // semicolons. This is a bit of a hack that is specifically there
+              // to handle `~` which doesn't require a space before its argument. Any command
+              // whose parser accepts multi commands without a leading space should be accepted.
+              // All other commands should be rejected. Note that `alias` is also handled by
+              // this case.
+              val commandArgs =
+                (first.drop(commandName.length).trim :: Nil ::: tail).mkString(";")
+              parse(commandArgs, command.parser(state)).toOption
+            case _ => none[() => State]
+          }
+        }.headOption match {
+          case Some(s) => s()
+          case _       => commands ::: state
+        }
+      case commands => commands ::: state
+    }
+  }
+
+  val multi: Command =
+    Command.custom(multiApplied, Help(Multi, MultiBrief, MultiDetailed), Multi)
+
+  lazy val otherCommandParser: State => Parser[String] =
+    (s: State) => token(OptSpace ~> combinedLax(s, NotSpaceClass ~ any.*))
 
-  lazy val otherCommandParser = (s: State) => token(OptSpace ~> combinedLax(s, NotSpaceClass ~ any.*))
   def combinedLax(s: State, any: Parser[_]): Parser[String] =
-    matched(s.combinedParser | token(any, hide = const(true)))
+    matched((s.combinedParser: Parser[_]) | token(any, hide = const(true)))
 
-  def ifLast = Command(IfLast, Help.more(IfLast, IfLastDetailed))(otherCommandParser) { (s, arg) =>
-    if (s.remainingCommands.isEmpty) arg :: s else s
-  }
-  def append = Command(AppendCommand, Help.more(AppendCommand, AppendLastDetailed))(otherCommandParser) { (s, arg) =>
-    s.copy(remainingCommands = s.remainingCommands :+ arg)
-  }
+  def ifLast: Command =
+    Command(IfLast, Help.more(IfLast, IfLastDetailed))(otherCommandParser)(
+      (s, arg) => if (s.remainingCommands.isEmpty) arg :: s else s
+    )
 
-  def setOnFailure = Command(OnFailure, Help.more(OnFailure, OnFailureDetailed))(otherCommandParser) { (s, arg) =>
-    s.copy(onFailure = Some(arg))
-  }
-  private[sbt] def compatCommands = Seq(
-    Command.command(Compat.ClearOnFailure) { s =>
-      s.log.warn(Compat.ClearOnFailureDeprecated)
-      s.copy(onFailure = None)
-    },
-    Command.arb(s => token(Compat.OnFailure, hide = const(true)).flatMap(x => otherCommandParser(s))) { (s, arg) =>
-      s.log.warn(Compat.OnFailureDeprecated)
-      s.copy(onFailure = Some(arg))
-    },
-    Command.command(Compat.FailureWall) { s =>
-      s.log.warn(Compat.FailureWallDeprecated)
-      s
-    }
-  )
+  def append: Command =
+    Command(AppendCommand, Help.more(AppendCommand, AppendLastDetailed))(otherCommandParser)(
+      (s, arg) => s.copy(remainingCommands = s.remainingCommands :+ Exec(arg, s.source))
+    )
 
-  def clearOnFailure = Command.command(ClearOnFailure)(s => s.copy(onFailure = None))
-  def stashOnFailure = Command.command(StashOnFailure)(s => s.copy(onFailure = None).update(OnFailureStack)(s.onFailure :: _.toList.flatten))
-  def popOnFailure = Command.command(PopOnFailure) { s =>
-    val stack = s.get(OnFailureStack).getOrElse(Nil)
-    val updated = if (stack.isEmpty) s.remove(OnFailureStack) else s.put(OnFailureStack, stack.tail)
+  def setOnFailure: Command =
+    Command(OnFailure, Help.more(OnFailure, OnFailureDetailed))(otherCommandParser)(
+      (s, arg) => s.copy(onFailure = Some(Exec(arg, s.source)))
+    )
+
+  def clearOnFailure: Command = Command.command(ClearOnFailure)(s => s.copy(onFailure = None))
+
+  def stashOnFailure: Command =
+    Command.command(StashOnFailure)(
+      s => s.copy(onFailure = None).update(OnFailureStack)(s.onFailure :: _.toList.flatten)
+    )
+
+  def popOnFailure: Command = Command.command(PopOnFailure) { s =>
+    val stack = s.get(OnFailureStack).getOrElse(nil)
+    val updated =
+      if (stack.isEmpty) s.remove(OnFailureStack) else s.put(OnFailureStack, stack.tail)
     updated.copy(onFailure = stack.headOption.flatten)
   }
 
-  def reboot = Command(RebootCommand, Help.more(RebootCommand, RebootDetailed))(rebootParser) { (s, full) =>
-    s.reboot(full)
-  }
-  def rebootParser(s: State) = token(Space ~> "full" ^^^ true) ?? false
-
-  def call = Command(ApplyCommand, Help.more(ApplyCommand, ApplyDetailed))(_ => callParser) {
-    case (state, (cp, args)) =>
-      val parentLoader = getClass.getClassLoader
-      state.log.info("Applying State transformations " + args.mkString(", ") + (if (cp.isEmpty) "" else " from " + cp.mkString(File.pathSeparator)))
-      val loader = if (cp.isEmpty) parentLoader else toLoader(cp.map(f => new File(f)), parentLoader)
-      val loaded = args.map(arg => ModuleUtilities.getObject(arg, loader).asInstanceOf[State => State])
-      (state /: loaded)((s, obj) => obj(s))
-  }
-  def callParser: Parser[(Seq[String], Seq[String])] = token(Space) ~> ((classpathOptionParser ?? Nil) ~ rep1sep(className, token(Space)))
-  private[this] def className: Parser[String] =
-    {
-      val base = StringBasic & not('-' ~> any.*, "Class name cannot start with '-'.")
-      def single(s: String) = Completions.single(Completion.displayOnly(s))
-      val compl = TokenCompletions.fixed((seen, level) => if (seen.startsWith("-")) Completions.nil else single("<class name>"))
-      token(base, compl)
+  def reboot: Command =
+    Command(RebootCommand, Help.more(RebootCommand, RebootDetailed))(_ => rebootOptionParser) {
+      case (s, (full, currentOnly)) =>
+        val option = if (full) " full" else if (currentOnly) " dev" else ""
+        RebootNetwork :: s"$RebootImpl$option" :: s
     }
+  def rebootImpl: Command =
+    Command.arb(_ => (RebootImpl ~> rebootOptionParser).examples()) {
+      case (s, (full, currentOnly)) =>
+        s.reboot(full, currentOnly)
+    }
+
+  @deprecated("Use rebootOptionParser", "1.1.0")
+  def rebootParser(s: State): Parser[Boolean] = rebootOptionParser map { case (full, _) => full }
+
+  private[sbt] def rebootOptionParser: Parser[(Boolean, Boolean)] = {
+    val fullOption = "full" ^^^ ((true, false))
+    val devOption = "dev" ^^^ ((false, true))
+    token(Space ~> (fullOption | devOption)) ?? ((false, false))
+  }
+
+  def call: Command =
+    Command(ApplyCommand, Help.more(ApplyCommand, ApplyDetailed))(_ => callParser) {
+      case (state, (cp, args)) =>
+        val parentLoader = getClass.getClassLoader
+        def argsStr = args mkString ", "
+        def cpStr = cp mkString File.pathSeparator
+        def fromCpStr = if (cp.isEmpty) "" else s" from $cpStr"
+        state.log info s"Applying State transformations $argsStr$fromCpStr"
+        val loader =
+          if (cp.isEmpty) parentLoader else toLoader(cp.map(f => Paths.get(f)), parentLoader)
+        val loaded =
+          args.map(arg => ModuleUtilities.getObject(arg, loader).asInstanceOf[State => State])
+        loaded.foldLeft(state)((s, obj) => obj(s))
+    }
+
+  def callParser: Parser[(Seq[String], Seq[String])] =
+    token(Space) ~> ((classpathOptionParser ?? nilSeq) ~ rep1sep(className, token(Space)))
+
+  private[this] def className: Parser[String] = {
+    val base = StringBasic & not('-' ~> any.*, "Class name cannot start with '-'.")
+    def single(s: String) = Completions.single(Completion.displayOnly(s))
+    val compl = TokenCompletions.fixed(
+      (seen, _) => if (seen.startsWith("-")) Completions.nil else single("<class name>")
+    )
+    token(base, compl)
+  }
+
   private[this] def classpathOptionParser: Parser[Seq[String]] =
     token(("-cp" | "-classpath") ~> Space) ~> classpathStrings <~ token(Space)
+
   private[this] def classpathStrings: Parser[Seq[String]] =
     token(StringBasic.map(s => IO.pathSplit(s).toSeq), "<classpath>")
 
-  def exit = Command.command(TerminateAction, exitBrief, exitBrief)(_ exit true)
+  def exit: Command = Command.command(TerminateAction, exitBrief, exitBrief) { s =>
+    s.source match {
+      case Some(c) if c.channelName.startsWith("network") =>
+        s"${DisconnectNetworkChannel} ${c.channelName}" :: s
+      case _ => s exit true
+    }
+  }
+  def shutdown: Command = Command.command(Shutdown, shutdownBrief, shutdownBrief) { s =>
+    s.source match {
+      case Some(c) if c.channelName.startsWith("network") =>
+        s"${DisconnectNetworkChannel} ${c.channelName}" :: (Exec(Shutdown, None) +: s)
+      case _ => s exit true
+    }
+  }
 
-  def continuous =
-    Command(ContinuousExecutePrefix, continuousBriefHelp, continuousDetail)(otherCommandParser) { (s, arg) =>
-      withAttribute(s, Watched.Configuration, "Continuous execution not configured.") { w =>
-        val repeat = ContinuousExecutePrefix + (if (arg.startsWith(" ")) arg else " " + arg)
-        Watched.executeContinuously(w, s, arg, repeat)
-      }
+  @deprecated("Replaced by BuiltInCommands.continuous", "1.3.0")
+  def continuous: Command =
+    Command(ContinuousExecutePrefix, continuousBriefHelp, continuousDetail)(otherCommandParser) {
+      (s, arg) =>
+        withAttribute(s, Watched.Configuration, "Continuous execution not configured.") { w =>
+          val repeat = ContinuousExecutePrefix + (if (arg.startsWith(" ")) arg else " " + arg)
+          Watched.executeContinuously(w, s, arg, repeat)
+        }
     }
 
-  def history = Command.custom(historyParser, BasicCommandStrings.historyHelp)
+  def history: Command = Command.custom(historyParser, BasicCommandStrings.historyHelp)
+
   def historyParser(s: State): Parser[() => State] =
     Command.applyEffect(HistoryCommands.actionParser) { histFun =>
-      val logError = (msg: String) => s.log.error(msg)
-      val hp = s get historyPath getOrElse None
+      val hp = (s get historyPath).flatten
       val lines = hp.toList.flatMap(p => IO.readLines(p)).toIndexedSeq
-      histFun(CHistory(lines, hp, logError)) match {
+      histFun(CHistory(lines, hp)) match {
         case Some(commands) =>
           commands foreach println //printing is more appropriate than logging
           (commands ::: s).continue
@@ -180,44 +397,59 @@ object BasicCommands {
       }
     }
 
-  def shell = Command.command(Shell, Help.more(Shell, ShellDetailed)) { s =>
-    val history = (s get historyPath) getOrElse Some(new File(s.baseDir, ".history"))
+  def oldshell: Command = Command.command(OldShell, Help.more(Shell, OldShellDetailed)) { s =>
+    val history = (s get historyPath) getOrElse (new File(s.baseDir, ".history")).some
     val prompt = (s get shellPrompt) match { case Some(pf) => pf(s); case None => "> " }
-    val reader = new FullReader(history, s.combinedParser)
+    val reader = new FullReader(history, s.combinedParser, LineReader.HandleCONT, Terminal.console)
     val line = reader.readLine(prompt)
     line match {
       case Some(line) =>
-        val newState = s.copy(onFailure = Some(Shell), remainingCommands = line +: Shell +: s.remainingCommands).setInteractive(true)
+        val newState = s
+          .copy(
+            onFailure = Some(Exec(Shell, None)),
+            remainingCommands = Exec(line, s.source) +: Exec(OldShell, None) +: s.remainingCommands
+          )
+          .setInteractive(true)
         if (line.trim.isEmpty) newState else newState.clearGlobalLog
       case None => s.setInteractive(false)
     }
   }
 
-  def server = Command.command(Server, Help.more(Server, ServerDetailed)) { s0 =>
-    val exchange = State.exchange
-    val s1 = exchange.run(s0)
-    exchange.publishStatus(CommandStatus(s0, true), None)
-    val Exec(source, line) = exchange.blockUntilNextExec
-    val newState = s1.copy(onFailure = Some(Server), remainingCommands = line +: Server +: s1.remainingCommands).setInteractive(true)
-    exchange.publishStatus(CommandStatus(newState, false), Some(source))
-    if (line.trim.isEmpty) newState
-    else newState.clearGlobalLog
+  def client: Command =
+    Command(Client, Help.more(Client, ClientDetailed))(_ => clientParser)(runClient)
+
+  def clientParser: Parser[Seq[String]] =
+    (token(Space) ~> repsep(StringBasic, token(Space))) | (token(EOF) map (_ => nilSeq))
+
+  def runClient(s0: State, inputArg: Seq[String]): State = {
+    val arguments = inputArg.toList ++
+      (s0.remainingCommands match {
+        case e :: Nil if e.commandLine == "shell" => nil
+        case xs                                   => xs map (_.commandLine)
+      })
+    NetworkClient.run(s0.configuration, arguments)
+    TerminateAction :: s0.copy(remainingCommands = Nil)
+  }
+
+  def read: Command =
+    Command(ReadCommand, Help.more(ReadCommand, ReadDetailed))(readParser)(doRead(_)(_))
+
+  def readParser(s: State): Parser[Either[Int, Seq[File]]] = {
+    val files = (token(Space) ~> fileParser(s.baseDir)).+
+    val portAndSuccess = token(OptSpace) ~> Port
+    portAndSuccess || files
   }
 
-  def read = Command.make(ReadCommand, Help.more(ReadCommand, ReadDetailed))(s => applyEffect(readParser(s))(doRead(s)))
-  def readParser(s: State) =
-    {
-      val files = (token(Space) ~> fileParser(s.baseDir)).+
-      val portAndSuccess = token(OptSpace) ~> Port
-      portAndSuccess || files
-    }
   def doRead(s: State)(arg: Either[Int, Seq[File]]): State =
     arg match {
       case Left(portAndSuccess) =>
         val port = math.abs(portAndSuccess)
         val previousSuccess = portAndSuccess >= 0
         readMessage(port, previousSuccess) match {
-          case Some(message) => (message :: (ReadCommand + " " + port) :: s).copy(onFailure = Some(ReadCommand + " " + (-port)))
+          case Some(message) =>
+            (message :: (ReadCommand + " " + port) :: s).copy(
+              onFailure = Some(Exec(ReadCommand + " " + (-port), s.source))
+            )
           case None =>
             System.err.println("Connection closed.")
             s.fail
@@ -225,32 +457,33 @@ object BasicCommands {
       case Right(from) =>
         val notFound = notReadable(from)
         if (notFound.isEmpty)
-          readLines(from) ::: s // this means that all commands from all files are loaded, parsed, and inserted before any are executed
+          // this means that all commands from all files are loaded, parsed, & inserted before any are executed
+          readLines(from).toList ::: s
         else {
           s.log.error("Command file(s) not readable: \n\t" + notFound.mkString("\n\t"))
           s
         }
     }
-  private def readMessage(port: Int, previousSuccess: Boolean): Option[String] =
-    {
-      // split into two connections because this first connection ends the previous communication
-      xsbt.IPC.client(port) { _.send(previousSuccess.toString) }
-      //   and this second connection starts the next communication
-      xsbt.IPC.client(port) { ipc =>
-        val message = ipc.receive
-        if (message eq null) None else Some(message)
-      }
-    }
 
-  def alias = Command.make(AliasCommand, Help.more(AliasCommand, AliasDetailed)) { s =>
-    val name = token(OpOrID.examples(aliasNames(s): _*))
-    val assign = token(OptSpace ~ '=' ~ OptSpace)
-    val sfree = removeAliases(s)
-    val to = matched(sfree.combinedParser, partial = true).failOnException | any.+.string
-    val base = (OptSpace ~> (name ~ (assign ~> to.?).?).?)
-    applyEffect(base)(t => runAlias(s, t))
+  private def readMessage(port: Int, previousSuccess: Boolean): Option[String] = {
+    // split into two connections because this first connection ends the previous communication
+    xsbt.IPC.client(port) { _.send(previousSuccess.toString) }
+    //   and this second connection starts the next communication
+    xsbt.IPC.client(port) { ipc =>
+      val message = ipc.receive
+      if (message eq null) None else Some(message)
+    }
   }
 
+  def alias: Command =
+    Command(AliasCommand, Help.more(AliasCommand, AliasDetailed)) { s =>
+      val name = token(OpOrID.examples(aliasNames(s): _*))
+      val assign = token(OptSpace ~ '=' ~ OptSpace)
+      val sfree = removeAliases(s)
+      val to = matched(sfree.combinedParser, partial = true).failOnException | any.+.string
+      OptSpace ~> (name ~ (assign ~> to.?).?).?
+    }(runAlias)
+
   def runAlias(s: State, args: Option[(String, Option[Option[String]])]): State =
     args match {
       case None =>
@@ -272,42 +505,100 @@ object BasicCommands {
     s.copy(definedCommands = newAlias(name, value) +: s.definedCommands)
 
   def removeAliases(s: State): State = removeTagged(s, CommandAliasKey)
-  def removeAlias(s: State, name: String): State = s.copy(definedCommands = s.definedCommands.filter(c => !isAliasNamed(name, c)))
 
-  def removeTagged(s: State, tag: AttributeKey[_]): State = s.copy(definedCommands = removeTagged(s.definedCommands, tag))
-  def removeTagged(as: Seq[Command], tag: AttributeKey[_]): Seq[Command] = as.filter(c => !(c.tags contains tag))
+  def removeAlias(s: State, name: String): State =
+    s.copy(definedCommands = s.definedCommands.filter(c => !isAliasNamed(name, c)))
+
+  def removeTagged(s: State, tag: AttributeKey[_]): State =
+    s.copy(definedCommands = removeTagged(s.definedCommands, tag))
+
+  def removeTagged(as: Seq[Command], tag: AttributeKey[_]): Seq[Command] =
+    as.filter(c => !(c.tags contains tag))
 
   def isAliasNamed(name: String, c: Command): Boolean = isNamed(name, getAlias(c))
-  def isNamed(name: String, alias: Option[(String, String)]): Boolean = alias match { case None => false; case Some((n, _)) => name == n }
+
+  def isNamed(name: String, alias: Option[(String, String)]): Boolean =
+    alias match { case None => false; case Some((n, _)) => name == n }
 
   def getAlias(c: Command): Option[(String, String)] = c.tags get CommandAliasKey
-  def printAlias(s: State, name: String): Unit = printAliases(aliases(s, (n, v) => n == name))
+  def printAlias(s: State, name: String): Unit = printAliases(aliases(s, (n, _) => n == name))
   def printAliases(s: State): Unit = printAliases(allAliases(s))
+
   def printAliases(as: Seq[(String, String)]): Unit =
     for ((name, value) <- as)
       println("\t" + name + " = " + value)
 
   def aliasNames(s: State): Seq[String] = allAliases(s).map(_._1)
-  def allAliases(s: State): Seq[(String, String)] = aliases(s, (n, v) => true)
+  def allAliases(s: State): Seq[(String, String)] = aliases(s, (_, _) => true)
   def aliases(s: State, pred: (String, String) => Boolean): Seq[(String, String)] =
     s.definedCommands.flatMap(c => getAlias(c).filter(tupled(pred)))
 
   def newAlias(name: String, value: String): Command =
-    Command.make(name, (name, "'" + value + "'"), "Alias of '" + value + "'")(aliasBody(name, value)).tag(CommandAliasKey, (name, value))
+    Command
+      .make(name, (name, s"'$value'"), s"Alias of '$value'")(aliasBody(name, value))
+      .tag(CommandAliasKey, (name, value))
+
   def aliasBody(name: String, value: String)(state: State): Parser[() => State] = {
     val aliasRemoved = removeAlias(state, name)
     // apply the alias value to the commands of `state` except for the alias to avoid recursion (#933)
-    val partiallyApplied = Parser(Command.combine(aliasRemoved.definedCommands)(aliasRemoved))(value)
-    val arg = matched(partiallyApplied & (success(()) | (SpaceClass ~ any.*)))
-    // by scheduling the expanded alias instead of directly executing, we get errors on the expanded string (#598)
+    val partiallyApplied = Parser(aliasRemoved.combinedParser)(value)
+    val arg: Parser[String] = matched(
+      partiallyApplied & (success((): Any) | ((SpaceClass ~ any.*): Parser[Any]))
+    )
+    // by scheduling the expanded alias instead of directly executing,
+    // we get errors on the expanded string (#598)
     arg.map(str => () => (value + str) :: state)
   }
 
-  def delegateToAlias(name: String, orElse: Parser[() => State])(state: State): Parser[() => State] =
+  def delegateToAlias(name: String, orElse: Parser[() => State])(
+      state: State
+  ): Parser[() => State] =
     aliases(state, (nme, _) => nme == name).headOption match {
       case None         => orElse
       case Some((n, v)) => aliasBody(n, v)(state)
     }
 
-  val CommandAliasKey = AttributeKey[(String, String)]("is-command-alias", "Internal: marker for Commands created as aliases for another command.")
+  val CommandAliasKey: AttributeKey[(String, String)] =
+    AttributeKey[(String, String)](
+      "is-command-alias",
+      "Internal: marker for Commands created as aliases for another command."
+    )
+
+  private[sbt] def reportParser(key: String) =
+    (key: Parser[String]).examples() ~> " ".examples() ~> matched(any.*).examples()
+  def reportResultsCommand =
+    Command.arb(_ => reportParser(ReportResult)) { (state, id) =>
+      val newState = state.get(execMap) match {
+        case Some(m) => state.put(execMap, m - id)
+        case _       => state
+      }
+      newState.get(execResults) match {
+        case Some(m) if m.contains(id) => state.put(execResults, m - id)
+        case _                         => state.fail
+      }
+    }
+  def mapExecCommand =
+    Command.arb(_ => reportParser(MapExec)) { (state, mapping) =>
+      mapping.split(" ") match {
+        case Array(key, value) =>
+          state.get(execMap) match {
+            case Some(m) => state.put(execMap, m + (key -> value))
+            case None    => state.put(execMap, Map(key -> value))
+          }
+        case _ => state
+      }
+    }
+  def completeExecCommand =
+    Command.arb(_ => reportParser(CompleteExec)) { (state, id) =>
+      val newState = state.get(execResults) match {
+        case Some(m) => state.put(execResults, m + (id -> true))
+        case _       => state.put(execResults, Map(id -> true))
+      }
+      newState.get(execMap) match {
+        case Some(m) => newState.put(execMap, m - id)
+        case _       => newState
+      }
+    }
+  private[sbt] val execResults = AttributeKey[Map[String, Boolean]]("execResults", Int.MaxValue)
+  private[sbt] val execMap = AttributeKey[Map[String, String]]("execMap", Int.MaxValue)
 }
diff --git a/main-command/src/main/scala/sbt/BasicKeys.scala b/main-command/src/main/scala/sbt/BasicKeys.scala
index d42a1d381..84c7471b2 100644
--- a/main-command/src/main/scala/sbt/BasicKeys.scala
+++ b/main-command/src/main/scala/sbt/BasicKeys.scala
@@ -1,16 +1,152 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import java.io.File
+
+import sbt.internal.inc.classpath.{ ClassLoaderCache => IncClassLoaderCache }
+import sbt.internal.classpath.ClassLoaderCache
+import sbt.internal.server.ServerHandler
 import sbt.internal.util.AttributeKey
-import sbt.internal.inc.classpath.ClassLoaderCache
+import sbt.librarymanagement.ModuleID
+import sbt.util.Level
+import scala.annotation.nowarn
+import scala.concurrent.duration.FiniteDuration
 
 object BasicKeys {
-  val historyPath = AttributeKey[Option[File]]("history", "The location where command line history is persisted.", 40)
-  val shellPrompt = AttributeKey[State => String]("shell-prompt", "The function that constructs the command prompt from the current build state.", 10000)
-  val watch = AttributeKey[Watched]("watch", "Continuous execution configuration.", 1000)
-  val serverPort = AttributeKey[Int]("server-port", "The port number used by server command.", 10000)
-  private[sbt] val interactive = AttributeKey[Boolean]("interactive", "True if commands are currently being entered from an interactive environment.", 10)
-  private[sbt] val classLoaderCache = AttributeKey[ClassLoaderCache]("class-loader-cache", "Caches class loaders based on the classpath entries and last modified times.", 10)
-  private[sbt] val OnFailureStack = AttributeKey[List[Option[String]]]("on-failure-stack", "Stack that remembers on-failure handlers.", 10)
-  private[sbt] val explicitGlobalLogLevels = AttributeKey[Boolean]("explicit-global-log-levels", "True if the global logging levels were explicitly set by the user.", 10)
+  val historyPath = AttributeKey[Option[File]](
+    "history",
+    "The location where command line history is persisted.",
+    40
+  )
+
+  val extraMetaSbtFiles = AttributeKey[Seq[File]](
+    "extraMetaSbtFile",
+    "Additional plugin.sbt files.",
+    10000
+  )
+
+  val shellPrompt = AttributeKey[State => String](
+    "shell-prompt",
+    "The function that constructs the command prompt from the current build state.",
+    10000
+  )
+  val colorShellPrompt = AttributeKey[(Boolean, State) => String](
+    "color-shell-prompt",
+    "The function that constructs the command prompt from the current build state for a given terminal.",
+    10000
+  )
+  @nowarn val watch =
+    AttributeKey[Watched]("watched", "Continuous execution configuration.", 1000)
+  val serverPort =
+    AttributeKey[Int]("server-port", "The port number used by server command.", 10000)
+
+  val serverHost =
+    AttributeKey[String]("serverHost", "The host used by server command.", 10000)
+
+  val serverAuthentication =
+    AttributeKey[Set[ServerAuthentication]](
+      "serverAuthentication",
+      "Method of authenticating server command.",
+      10000
+    )
+
+  val serverConnectionType =
+    AttributeKey[ConnectionType](
+      "serverConnectionType",
+      "The wire protocol for the server command.",
+      10000
+    )
+
+  val fullServerHandlers =
+    AttributeKey[Seq[ServerHandler]](
+      "fullServerHandlers",
+      "Combines default server handlers and user-defined handlers.",
+      10000
+    )
+
+  val autoStartServer =
+    AttributeKey[Boolean](
+      "autoStartServer",
+      "If true, the sbt server will startup automatically during interactive sessions.",
+      10000
+    )
+
+  val windowsServerSecurityLevel =
+    AttributeKey[Int](
+      "windowsServerSecurityLevel",
+      "Configures the security level of the named pipe. Values: 0 - No security; 1 - Logon user only; 2 - Process owner only",
+      10000
+    )
+  val serverUseJni =
+    AttributeKey[Boolean](
+      "serverUseJni",
+      "Toggles whether to use the jna or jni implementation in ipcsocket.",
+      10000
+    )
+
+  val serverIdleTimeout =
+    AttributeKey[Option[FiniteDuration]](
+      "serverIdleTimeOut",
+      "If set to a defined value, sbt server will exit if it goes at least the specified duration without receiving any commands.",
+      10000
+    )
+
+  val bspEnabled =
+    AttributeKey[Boolean](
+      "bspEnabled",
+      "Enable/Disable BSP for this build, project or configuration",
+      10000
+    )
+
+  // Unlike other BasicKeys, this is not used directly as a setting key,
+  // and severLog / logLevel is used instead.
+  private[sbt] val serverLogLevel =
+    AttributeKey[Level.Value]("serverLogLevel", "The log level for the server.", 10000)
+
+  private[sbt] val logLevel =
+    AttributeKey[Level.Value]("logLevel", "The amount of logging sent to the screen.", 10)
+
+  private[sbt] val interactive = AttributeKey[Boolean](
+    "interactive",
+    "True if commands are currently being entered from an interactive environment.",
+    10
+  )
+  private[sbt] val classLoaderCache = AttributeKey[IncClassLoaderCache](
+    "class-loader-cache",
+    "Caches class loaders based on the classpath entries and last modified times.",
+    10
+  )
+  private[sbt] val extendedClassLoaderCache = AttributeKey[ClassLoaderCache](
+    "extended-class-loader-cache",
+    "Caches class loaders based on the classpath entries and last modified times.",
+    10
+  )
+  private[sbt] val OnFailureStack = AttributeKey[List[Option[Exec]]](
+    "on-failure-stack",
+    "Stack that remembers on-failure handlers.",
+    10
+  )
+  private[sbt] val explicitGlobalLogLevels = AttributeKey[Boolean](
+    "explicit-global-log-levels",
+    "True if the global logging levels were explicitly set by the user.",
+    10
+  )
+  private[sbt] val templateResolverInfos = AttributeKey[Seq[TemplateResolverInfo]](
+    "templateResolverInfos",
+    "List of template resolver infos.",
+    1000
+  )
+  private[sbt] val detachStdio = AttributeKey[Boolean](
+    "detach-stdio",
+    "Toggles wheter or not to close system in, out and error when the server starts.",
+    1000
+  )
 }
+
+case class TemplateResolverInfo(module: ModuleID, implementationClass: String)
diff --git a/main-command/src/main/scala/sbt/Command.scala b/main-command/src/main/scala/sbt/Command.scala
index 9764697be..ec224b551 100644
--- a/main-command/src/main/scala/sbt/Command.scala
+++ b/main-command/src/main/scala/sbt/Command.scala
@@ -1,142 +1,275 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009, 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import sbt.internal.inc.ReflectUtilities
 import sbt.internal.util.complete.{ DefaultParsers, EditDistance, Parser }
 import sbt.internal.util.Types.const
 import sbt.internal.util.{ AttributeKey, AttributeMap, Util }
+import sbt.internal.util.Util.{ nilSeq }
 
+/**
+ * An operation that can be executed from the sbt console.
+ *
+ * <p>The operation takes a [[sbt.State State]] as a parameter and returns a [[sbt.State State]].
+ * This means that a command can look at or modify other sbt settings, for example.
+ * Typically you would resort to a command when you need to do something that's impossible in a regular task.
+ */
 sealed trait Command {
   def help: State => Help
   def parser: State => Parser[() => State]
+
   def tags: AttributeMap
   def tag[T](key: AttributeKey[T], value: T): Command
+
+  def nameOption: Option[String] = this match {
+    case sc: SimpleCommand => Some(sc.name)
+    case _                 => None
+  }
 }
-private[sbt] final class SimpleCommand(val name: String, private[sbt] val help0: Help, val parser: State => Parser[() => State], val tags: AttributeMap) extends Command {
-  assert(Command validID name, "'" + name + "' is not a valid command name.")
-  def tag[T](key: AttributeKey[T], value: T): SimpleCommand = new SimpleCommand(name, help0, parser, tags.put(key, value))
+
+private[sbt] final class SimpleCommand(
+    val name: String,
+    private[sbt] val help0: Help,
+    val parser: State => Parser[() => State],
+    val tags: AttributeMap
+) extends Command {
+
+  assert(Command validID name, s"'$name' is not a valid command name.")
+
   def help = const(help0)
+
+  def tag[T](key: AttributeKey[T], value: T): SimpleCommand =
+    new SimpleCommand(name, help0, parser, tags.put(key, value))
+
   override def toString = s"SimpleCommand($name)"
 }
-private[sbt] final class ArbitraryCommand(val parser: State => Parser[() => State], val help: State => Help, val tags: AttributeMap) extends Command {
-  def tag[T](key: AttributeKey[T], value: T): ArbitraryCommand = new ArbitraryCommand(parser, help, tags.put(key, value))
+
+private[sbt] final class ArbitraryCommand(
+    val parser: State => Parser[() => State],
+    val help: State => Help,
+    val tags: AttributeMap,
+    override val nameOption: Option[String]
+) extends Command {
+  def this(parser: State => Parser[() => State], help: State => Help, tags: AttributeMap) =
+    this(parser, help, tags, None)
+  def tag[T](key: AttributeKey[T], value: T): ArbitraryCommand =
+    new ArbitraryCommand(parser, help, tags.put(key, value))
 }
 
+// format: off
+
 object Command {
   import DefaultParsers._
 
-  def command(name: String, briefHelp: String, detail: String)(f: State => State): Command = command(name, Help(name, (name, briefHelp), detail))(f)
-  def command(name: String, help: Help = Help.empty)(f: State => State): Command = make(name, help)(state => success(() => f(state)))
+  // Lowest-level command construction
 
-  def make(name: String, briefHelp: (String, String), detail: String)(parser: State => Parser[() => State]): Command =
+  def make(name: String, help: Help = Help.empty)(parser: State => Parser[() => State]): Command =
+    new SimpleCommand(name, help, parser, AttributeMap.empty)
+
+  def make(name: String, briefHelp: (String, String), detail: String)(
+      parser: State => Parser[() => State]
+  ): Command =
     make(name, Help(name, briefHelp, detail))(parser)
-  def make(name: String, help: Help = Help.empty)(parser: State => Parser[() => State]): Command = new SimpleCommand(name, help, parser, AttributeMap.empty)
 
-  def apply[T](name: String, briefHelp: (String, String), detail: String)(parser: State => Parser[T])(effect: (State, T) => State): Command =
-    apply(name, Help(name, briefHelp, detail))(parser)(effect)
-  def apply[T](name: String, help: Help = Help.empty)(parser: State => Parser[T])(effect: (State, T) => State): Command =
+  // General command construction
+
+  /** Construct a command with the given name, parser and effect. */
+  def apply[T](name: String, help: Help = Help.empty)(
+      parser: State => Parser[T]
+  )(effect: (State, T) => State): Command =
     make(name, help)(applyEffect(parser)(effect))
 
-  def args(name: String, briefHelp: (String, String), detail: String, display: String)(f: (State, Seq[String]) => State): Command =
-    args(name, display, Help(name, briefHelp, detail))(f)
+  def apply[T](name: String, briefHelp: (String, String), detail: String)(
+      parser: State => Parser[T]
+  )(effect: (State, T) => State): Command =
+    apply(name, Help(name, briefHelp, detail))(parser)(effect)
 
-  def args(name: String, display: String, help: Help = Help.empty)(f: (State, Seq[String]) => State): Command =
-    make(name, help)(state => spaceDelimited(display) map apply1(f, state))
+  // No-argument command construction
 
-  def single(name: String, briefHelp: (String, String), detail: String)(f: (State, String) => State): Command =
-    single(name, Help(name, briefHelp, detail))(f)
+  /** Construct a no-argument command with the given name and effect. */
+  def command(name: String, help: Help = Help.empty)(f: State => State): Command =
+    make(name, help)(state => success(() => f(state)))
+
+  def command(name: String, briefHelp: String, detail: String)(f: State => State): Command =
+    command(name, Help(name, (name, briefHelp), detail))(f)
+
+  // Single-argument command construction
+
+  /** Construct a single-argument command with the given name and effect. */
   def single(name: String, help: Help = Help.empty)(f: (State, String) => State): Command =
     make(name, help)(state => token(trimmed(spacedAny(name)) map apply1(f, state)))
 
-  def custom(parser: State => Parser[() => State], help: Help = Help.empty): Command = customHelp(parser, const(help))
-  def customHelp(parser: State => Parser[() => State], help: State => Help): Command = new ArbitraryCommand(parser, help, AttributeMap.empty)
-  def arb[T](parser: State => Parser[T], help: Help = Help.empty)(effect: (State, T) => State): Command = custom(applyEffect(parser)(effect), help)
+  def single(name: String, briefHelp: (String, String), detail: String)(
+      f: (State, String) => State
+  ): Command =
+    single(name, Help(name, briefHelp, detail))(f)
 
-  def validID(name: String) = DefaultParsers.matches(OpOrID, name)
+  // Multi-argument command construction
 
-  def applyEffect[T](parser: State => Parser[T])(effect: (State, T) => State): State => Parser[() => State] =
+  /** Construct a multi-argument command with the given name, tab completion display and effect. */
+  def args(name: String, display: String, help: Help = Help.empty)(
+      f: (State, Seq[String]) => State
+  ): Command =
+    make(name, help)(state => spaceDelimited(display) map apply1(f, state))
+
+  def args(name: String, briefHelp: (String, String), detail: String, display: String)(
+      f: (State, Seq[String]) => State
+  ): Command =
+    args(name, display, Help(name, briefHelp, detail))(f)
+
+  // create ArbitraryCommand
+
+  def customHelp(parser: State => Parser[() => State], help: State => Help): Command =
+    new ArbitraryCommand(parser, help, AttributeMap.empty)
+
+  private[sbt] def custom(parser: State => Parser[() => State], help: Help, name: String): Command =
+    new ArbitraryCommand(parser, const(help), AttributeMap.empty, Some(name))
+  def custom(parser: State => Parser[() => State], help: Help = Help.empty): Command =
+    customHelp(parser, const(help))
+
+  def arb[T](parser: State => Parser[T], help: Help = Help.empty)(
+      effect: (State, T) => State
+  ): Command =
+    custom(applyEffect(parser)(effect), help)
+
+  // misc Command object utilities
+
+  def validID(name: String): Boolean = DefaultParsers.matches(OpOrID, name)
+
+  def applyEffect[T](p: Parser[T])(f: T => State): Parser[() => State] = p map (t => () => f(t))
+
+  def applyEffect[T](
+      parser: State => Parser[T]
+  )(effect: (State, T) => State): State => Parser[() => State] =
     s => applyEffect(parser(s))(t => effect(s, t))
-  def applyEffect[T](p: Parser[T])(f: T => State): Parser[() => State] =
-    p map { t => () => f(t) }
 
-  def combine(cmds: Seq[Command]): State => Parser[() => State] =
-    {
-      val (simple, arbs) = separateCommands(cmds)
-      state => (simpleParser(simple)(state) /: arbs.map(_ parser state)) { _ | _ }
-    }
-  private[this] def separateCommands(cmds: Seq[Command]): (Seq[SimpleCommand], Seq[ArbitraryCommand]) =
+  def combine(cmds: Seq[Command]): State => Parser[() => State] = {
+    val (simple, arbs) = separateCommands(cmds)
+    state =>
+      arbs.map(_ parser state).foldLeft(simpleParser(simple)(state))(_ | _)
+  }
+
+  private[this] def separateCommands(
+      cmds: Seq[Command]
+  ): (Seq[SimpleCommand], Seq[ArbitraryCommand]) =
     Util.separate(cmds) { case s: SimpleCommand => Left(s); case a: ArbitraryCommand => Right(a) }
-  private[this] def apply1[A, B, C](f: (A, B) => C, a: A): B => () => C =
-    b => () => f(a, b)
+
+  private[this] def apply1[A, B, C](f: (A, B) => C, a: A): B => () => C = b => () => f(a, b)
 
   def simpleParser(cmds: Seq[SimpleCommand]): State => Parser[() => State] =
     simpleParser(cmds.map(sc => (sc.name, argParser(sc))).toMap)
-  private[this] def argParser(sc: SimpleCommand): State => Parser[() => State] =
-    {
-      def usageError = s"${sc.name} usage:" + Help.message(sc.help0, None)
-      s => (Parser.softFailure(usageError, definitive = true): Parser[() => State]) | sc.parser(s)
-    }
 
-  def simpleParser(commandMap: Map[String, State => Parser[() => State]]): State => Parser[() => State] =
-    (state: State) => token(OpOrID examples commandMap.keys.toSet) flatMap { id =>
-      (commandMap get id) match {
-        case None    => failure(invalidValue("command", commandMap.keys)(id))
-        case Some(c) => c(state)
-      }
-    }
+  private[this] def argParser(sc: SimpleCommand): State => Parser[() => State] = {
+    def usageError = s"${sc.name} usage:" + Help.message(sc.help0, None)
+    s =>
+      (Parser.softFailure(usageError, definitive = true): Parser[() => State]) | sc.parser(s)
+  }
 
-  def process(command: String, state: State): State =
-    {
-      val parser = combine(state.definedCommands)
-      parse(command, parser(state)) match {
-        case Right(s) => s() // apply command.  command side effects happen here
-        case Left(errMsg) =>
-          state.log.error(errMsg)
-          state.fail
-      }
+  def simpleParser(
+      commandMap: Map[String, State => Parser[() => State]]
+  ): State => Parser[() => State] =
+    state =>
+      token(OpOrID examples commandMap.keys.toSet) flatMap (
+          id =>
+            (commandMap get id) match {
+              case None    => failure(invalidValue("command", commandMap.keys)(id))
+              case Some(c) => c(state)
+            }
+    )
+
+  def process(command: String, state: State): State = {
+    (if (command.contains(";")) parse(command, state.combinedParser)
+    else parse(command, state.nonMultiParser)) match {
+      case Right(s) => s() // apply command.  command side effects happen here
+      case Left(errMsg) =>
+        state.log error errMsg
+        state.fail
     }
+  }
+
   def invalidValue(label: String, allowed: Iterable[String])(value: String): String =
-    "Not a valid " + label + ": " + value + similar(value, allowed)
-  def similar(value: String, allowed: Iterable[String]): String =
-    {
-      val suggested = if (value.length > 2) suggestions(value, allowed.toSeq) else Nil
-      if (suggested.isEmpty) "" else suggested.mkString(" (similar: ", ", ", ")")
-    }
-  def suggestions(a: String, bs: Seq[String], maxDistance: Int = 3, maxSuggestions: Int = 3): Seq[String] =
-    bs.map { b => (b, distance(a, b)) } filter (_._2 <= maxDistance) sortBy (_._2) take (maxSuggestions) map (_._1)
+    s"Not a valid $label: $value" + similar(value, allowed)
+
+  def similar(value: String, allowed: Iterable[String]): String = {
+    val suggested = if (value.length > 2) suggestions(value, allowed.toSeq) else nilSeq
+    if (suggested.isEmpty) "" else suggested.mkString(" (similar: ", ", ", ")")
+  }
+
+  def suggestions(
+      a: String,
+      bs: Seq[String],
+      maxDistance: Int = 3,
+      maxSuggestions: Int = 3
+  ): Seq[String] =
+    bs map (b => (b, distance(a, b))) filter (_._2 <= maxDistance) sortBy (_._2) take (maxSuggestions) map (_._1)
+
   def distance(a: String, b: String): Int =
-    EditDistance.levenshtein(a, b, insertCost = 1, deleteCost = 1, subCost = 2, transposeCost = 1, matchCost = -1, caseCost = 1, true)
+    EditDistance.levenshtein(
+      a,
+      b,
+      insertCost = 1,
+      deleteCost = 1,
+      subCost = 2,
+      matchCost = -1,
+      caseCost = 1,
+      transpositions = true
+    )
 
   def spacedAny(name: String): Parser[String] = spacedC(name, any)
+
   def spacedC(name: String, c: Parser[Char]): Parser[String] =
     ((c & opOrIDSpaced(name)) ~ c.+) map { case (f, rem) => (f +: rem).mkString }
 }
 
+// format: on
+
 trait Help {
   def detail: Map[String, String]
   def brief: Seq[(String, String)]
   def more: Set[String]
   def ++(o: Help): Help
 }
-private final class Help0(val brief: Seq[(String, String)], val detail: Map[String, String], val more: Set[String]) extends Help {
-  def ++(h: Help): Help = new Help0(Help0.this.brief ++ h.brief, Help0.this.detail ++ h.detail, more ++ h.more)
+
+private final class Help0(
+    val brief: Seq[(String, String)],
+    val detail: Map[String, String],
+    val more: Set[String]
+) extends Help {
+  def ++(h: Help): Help =
+    new Help0(
+      Help0.this.brief ++ h.brief,
+      Map(Help0.this.detail.toSeq ++ h.detail.toSeq: _*),
+      more ++ h.more
+    )
 }
+
 object Help {
   val empty: Help = briefDetail(Nil)
 
-  def apply(name: String, briefHelp: (String, String), detail: String): Help = apply(briefHelp, Map((name, detail)))
+  def apply(name: String, briefHelp: (String, String), detail: String): Help =
+    apply(briefHelp, Map((name, detail)))
 
   def apply(briefHelp: (String, String), detailedHelp: Map[String, String] = Map.empty): Help =
     apply(briefHelp :: Nil, detailedHelp)
 
   def apply(briefHelp: Seq[(String, String)], detailedHelp: Map[String, String]): Help =
     apply(briefHelp, detailedHelp, Set.empty[String])
-  def apply(briefHelp: Seq[(String, String)], detailedHelp: Map[String, String], more: Set[String]): Help =
+
+  def apply(
+      briefHelp: Seq[(String, String)],
+      detailedHelp: Map[String, String],
+      more: Set[String]
+  ): Help =
     new Help0(briefHelp, detailedHelp, more)
 
-  def more(name: String, detailedHelp: String): Help = apply(Nil, Map(name -> detailedHelp), Set(name))
+  def more(name: String, detailedHelp: String): Help =
+    apply(Nil, Map(name -> detailedHelp), Set(name))
   def briefDetail(help: Seq[(String, String)]): Help = apply(help, help.toMap)
   def briefOnly(help: Seq[(String, String)]): Help = apply(help, Map.empty[String, String])
   def detailOnly(help: Seq[(String, String)]): Help = apply(Nil, help.toMap)
@@ -148,15 +281,17 @@ object Help {
       case Some(x) => detail(x, h.detail)
       case None =>
         val brief = aligned("  ", "   ", h.brief).mkString("\n", "\n", "\n")
-        val more = h.more.toSeq.sorted
+        val more = h.more
         if (more.isEmpty)
           brief
         else
-          brief + "\n" + moreMessage(more)
+          brief + "\n" + moreMessage(more.toSeq.sorted)
     }
+
   def moreMessage(more: Seq[String]): String =
     more.mkString("More command help available using 'help <command>' for:\n  ", ", ", "\n")
 }
+
 trait CommandDefinitions extends (State => State) {
   def commands: Seq[Command] = ReflectUtilities.allVals[Command](this).values.toSeq
   def apply(s: State): State = s ++ commands
diff --git a/main-command/src/main/scala/sbt/CommandUtil.scala b/main-command/src/main/scala/sbt/CommandUtil.scala
index f2f53943c..f5f15733c 100644
--- a/main-command/src/main/scala/sbt/CommandUtil.scala
+++ b/main-command/src/main/scala/sbt/CommandUtil.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import java.io.File
@@ -6,13 +13,18 @@ import java.util.regex.{ Pattern, PatternSyntaxException }
 import sbt.internal.util.AttributeKey
 import sbt.internal.util.complete.Parser
 import sbt.internal.util.complete.DefaultParsers._
+import sbt.internal.util.Util.nilSeq
 
 import sbt.io.IO
+import sbt.io.syntax._
 
 object CommandUtil {
-  def readLines(files: Seq[File]): Seq[String] = files flatMap (line => IO.readLines(line)) flatMap processLine
-  def processLine(s: String) = { val trimmed = s.trim; if (ignoreLine(trimmed)) None else Some(trimmed) }
-  def ignoreLine(s: String) = s.isEmpty || s.startsWith("#")
+  def readLines(files: Seq[File]): Seq[String] =
+    files flatMap (IO.readLines(_)) flatMap processLine
+  def processLine(s: String): Option[String] = {
+    val s2 = s.trim; if (ignoreLine(s2)) None else Some(s2)
+  }
+  def ignoreLine(s: String): Boolean = s.isEmpty || s.startsWith("#")
 
   private def canRead = (_: File).canRead
   def notReadable(files: Seq[File]): Seq[File] = files filterNot canRead
@@ -20,58 +32,66 @@ object CommandUtil {
 
   // slightly better fallback in case of older launcher
   def bootDirectory(state: State): File =
-    try { state.configuration.provider.scalaProvider.launcher.bootDirectory }
-    catch { case e: NoSuchMethodError => new File(".").getAbsoluteFile }
+    try state.configuration.provider.scalaProvider.launcher.bootDirectory
+    catch { case _: NoSuchMethodError => new File(".").getAbsoluteFile }
 
-  def aligned(pre: String, sep: String, in: Seq[(String, String)]): Seq[String] = if (in.isEmpty) Nil else {
-    val width = in.map(_._1.length).max
-    in.map { case (a, b) => (pre + fill(a, width) + sep + b) }
-  }
-  def fill(s: String, size: Int) = s + " " * math.max(size - s.length, 0)
+  def aligned(pre: String, sep: String, in: Seq[(String, String)]): Seq[String] =
+    if (in.isEmpty) nilSeq
+    else {
+      val width = in.iterator.map(_._1.length).max
+      for ((a, b) <- in) yield pre + fill(a, width) + sep + b
+    }
+
+  def fill(s: String, size: Int): String = s + " " * math.max(size - s.length, 0)
 
   def withAttribute[T](s: State, key: AttributeKey[T], ifMissing: String)(f: T => State): State =
-    (s get key) match {
+    s get key match {
       case None =>
         s.log.error(ifMissing); s.fail
       case Some(nav) => f(nav)
     }
 
-  def singleArgument(exampleStrings: Set[String]): Parser[String] =
-    {
-      val arg = (NotSpaceClass ~ any.*) map { case (ns, s) => (ns +: s).mkString }
-      token(Space) ~> token(arg examples exampleStrings)
-    }
+  def singleArgument(exampleStrings: Set[String]): Parser[String] = {
+    val arg = (NotSpaceClass ~ any.*) map { case (ns, s) => (ns +: s).mkString }
+    token(Space) ~> token(arg examples exampleStrings)
+  }
+
   def detail(selected: String, detailMap: Map[String, String]): String =
     detailMap.get(selected) match {
       case Some(exactDetail) => exactDetail
-      case None => try {
-        val details = searchHelp(selected, detailMap)
-        if (details.isEmpty)
-          "No matches for regular expression '" + selected + "'."
-        else
-          layoutDetails(details)
-      } catch {
-        case pse: PatternSyntaxException => sys.error("Invalid regular expression (java.util.regex syntax).\n" + pse.getMessage)
-      }
-    }
-  def searchHelp(selected: String, detailMap: Map[String, String]): Map[String, String] =
-    {
-      val pattern = Pattern.compile(selected, HelpPatternFlags)
-      detailMap flatMap {
-        case (k, v) =>
-          val contentMatches = Highlight.showMatches(pattern)(v)
-          val keyMatches = Highlight.showMatches(pattern)(k)
-          val keyString = Highlight.bold(keyMatches getOrElse k)
-          val contentString = contentMatches getOrElse v
-          if (keyMatches.isDefined || contentMatches.isDefined)
-            (keyString, contentString) :: Nil
+      case None =>
+        try {
+          val details = searchHelp(selected, detailMap)
+          if (details.isEmpty)
+            "No matches for regular expression '" + selected + "'."
           else
-            Nil
-      }
+            layoutDetails(details)
+        } catch {
+          case pse: PatternSyntaxException =>
+            sys.error("Invalid regular expression (java.util.regex syntax).\n" + pse.getMessage)
+        }
     }
+
+  def searchHelp(selected: String, detailMap: Map[String, String]): Map[String, String] = {
+    val pattern = Pattern.compile(selected, HelpPatternFlags)
+    detailMap flatMap {
+      case (k, v) =>
+        val contentMatches = Highlight.showMatches(pattern)(v)
+        val keyMatches = Highlight.showMatches(pattern)(k)
+        val keyString = Highlight.bold(keyMatches getOrElse k)
+        val contentString = contentMatches getOrElse v
+        if (keyMatches.isDefined || contentMatches.isDefined)
+          Seq((keyString, contentString))
+        else
+          nilSeq
+    }
+  }
+
   def layoutDetails(details: Map[String, String]): String =
     details.map { case (k, v) => k + "\n\n  " + v } mkString ("\n", "\n\n", "\n")
 
   final val HelpPatternFlags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE
 
+  private[sbt] def isSbtBuild(baseDir: File) =
+    (baseDir / "project").exists() || (baseDir * "*.sbt").get.nonEmpty
 }
diff --git a/main-command/src/main/scala/sbt/ExceptionCategory.scala b/main-command/src/main/scala/sbt/ExceptionCategory.scala
index 247cf7af3..5fab7dd34 100644
--- a/main-command/src/main/scala/sbt/ExceptionCategory.scala
+++ b/main-command/src/main/scala/sbt/ExceptionCategory.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import java.lang.reflect.InvocationTargetException
diff --git a/main-command/src/main/scala/sbt/Highlight.scala b/main-command/src/main/scala/sbt/Highlight.scala
index 6cb7eb8f4..8dc05f9b1 100644
--- a/main-command/src/main/scala/sbt/Highlight.scala
+++ b/main-command/src/main/scala/sbt/Highlight.scala
@@ -1,23 +1,30 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import java.util.regex.Pattern
 import scala.Console.{ BOLD, RESET }
 
-import sbt.internal.util.ConsoleLogger
+import sbt.internal.util.{ Terminal => UTerminal }
 
 object Highlight {
 
-  def showMatches(pattern: Pattern)(line: String): Option[String] =
-    {
-      val matcher = pattern.matcher(line)
-      if (ConsoleLogger.formatEnabled) {
-        // ANSI codes like \033[39m (normal text color) don't work on Windows
-        val highlighted = matcher.replaceAll(scala.Console.RED + "$0" + RESET)
-        if (highlighted == line) None else Some(highlighted)
-      } else if (matcher.find)
-        Some(line)
-      else
-        None
-    }
-  def bold(s: String) = if (ConsoleLogger.formatEnabled) BOLD + s.replace(RESET, RESET + BOLD) + RESET else s
+  def showMatches(pattern: Pattern)(line: String): Option[String] = {
+    val matcher = pattern.matcher(line)
+    if (UTerminal.isColorEnabled) {
+      // ANSI codes like \033[39m (normal text color) don't work on Windows
+      val highlighted = matcher.replaceAll(scala.Console.RED + "$0" + RESET)
+      if (highlighted == line) None else Some(highlighted)
+    } else if (matcher.find)
+      Some(line)
+    else
+      None
+  }
+  def bold(s: String) =
+    if (UTerminal.isColorEnabled) BOLD + s.replace(RESET, RESET + BOLD) + RESET else s
 }
diff --git a/main-command/src/main/scala/sbt/MainControl.scala b/main-command/src/main/scala/sbt/MainControl.scala
index 7ffb65f57..69d0d2fdb 100644
--- a/main-command/src/main/scala/sbt/MainControl.scala
+++ b/main-command/src/main/scala/sbt/MainControl.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009, 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
@@ -8,10 +12,24 @@ import java.io.File
 final case class Exit(code: Int) extends xsbti.Exit {
   require(code >= 0)
 }
-final case class Reboot(scalaVersion: String, argsList: Seq[String], app: xsbti.ApplicationID, baseDirectory: File) extends xsbti.Reboot {
+final case class Reboot(
+    scalaVersion: String,
+    argsList: Seq[String],
+    app: xsbti.ApplicationID,
+    baseDirectory: File
+) extends xsbti.Reboot {
   def arguments = argsList.toArray
 }
-final case class ApplicationID(groupID: String, name: String, version: String, mainClass: String, components: Seq[String], crossVersionedValue: xsbti.CrossValue, extra: Seq[File]) extends xsbti.ApplicationID {
+
+final case class ApplicationID(
+    groupID: String,
+    name: String,
+    version: String,
+    mainClass: String,
+    components: Seq[String],
+    crossVersionedValue: xsbti.CrossValue,
+    extra: Seq[File]
+) extends xsbti.ApplicationID {
   def mainComponents = components.toArray
   def classpathExtra = extra.toArray
   def crossVersioned = crossVersionedValue != xsbti.CrossValue.Disabled
@@ -20,5 +38,13 @@ object ApplicationID {
   def apply(delegate: xsbti.ApplicationID, newVersion: String): ApplicationID =
     apply(delegate).copy(version = newVersion)
   def apply(delegate: xsbti.ApplicationID): ApplicationID =
-    ApplicationID(delegate.groupID, delegate.name, delegate.version, delegate.mainClass, delegate.mainComponents, delegate.crossVersionedValue, delegate.classpathExtra)
-}
\ No newline at end of file
+    ApplicationID(
+      delegate.groupID,
+      delegate.name,
+      delegate.version,
+      delegate.mainClass,
+      delegate.mainComponents,
+      delegate.crossVersionedValue,
+      delegate.classpathExtra
+    )
+}
diff --git a/main-command/src/main/scala/sbt/MainLoop.scala b/main-command/src/main/scala/sbt/MainLoop.scala
deleted file mode 100644
index 3e7366b29..000000000
--- a/main-command/src/main/scala/sbt/MainLoop.scala
+++ /dev/null
@@ -1,113 +0,0 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010, 2011  Mark Harrah
- */
-package sbt
-
-import scala.annotation.tailrec
-import scala.util.control.NonFatal
-import jline.TerminalFactory
-
-import sbt.io.Using
-import sbt.internal.util.{ ErrorHandling, GlobalLogBacking, GlobalLogging }
-import sbt.util.{ AbstractLogger, Logger }
-
-object MainLoop {
-  /** Entry point to run the remaining commands in State with managed global logging.*/
-  def runLogged(state: State): xsbti.MainResult = {
-    // We've disabled jline shutdown hooks to prevent classloader leaks, and have been careful to always restore
-    // the jline terminal in finally blocks, but hitting ctrl+c prevents finally blocks from being executed, in that
-    // case the only way to restore the terminal is in a shutdown hook.
-    val shutdownHook = new Thread(new Runnable {
-      def run(): Unit = TerminalFactory.get().restore()
-    })
-
-    try {
-      Runtime.getRuntime.addShutdownHook(shutdownHook)
-      runLoggedLoop(state, state.globalLogging.backing)
-    } finally {
-      Runtime.getRuntime.removeShutdownHook(shutdownHook)
-    }
-  }
-
-  /** Run loop that evaluates remaining commands and manages changes to global logging configuration.*/
-  @tailrec def runLoggedLoop(state: State, logBacking: GlobalLogBacking): xsbti.MainResult =
-    runAndClearLast(state, logBacking) match {
-      case ret: Return => // delete current and last log files when exiting normally
-        logBacking.file.delete()
-        deleteLastLog(logBacking)
-        ret.result
-      case clear: ClearGlobalLog => // delete previous log file, move current to previous, and start writing to a new file
-        deleteLastLog(logBacking)
-        runLoggedLoop(clear.state, logBacking.shiftNew())
-      case keep: KeepGlobalLog => // make previous log file the current log file
-        logBacking.file.delete
-        runLoggedLoop(keep.state, logBacking.unshift)
-    }
-
-  /** Runs the next sequence of commands, cleaning up global logging after any exceptions. */
-  def runAndClearLast(state: State, logBacking: GlobalLogBacking): RunNext =
-    try
-      runWithNewLog(state, logBacking)
-    catch {
-      case e: xsbti.FullReload =>
-        deleteLastLog(logBacking)
-        throw e // pass along a reboot request
-      case NonFatal(e) =>
-        System.err.println("sbt appears to be exiting abnormally.\n  The log file for this session is at " + logBacking.file)
-        deleteLastLog(logBacking)
-        throw e
-    }
-
-  /** Deletes the previous global log file. */
-  def deleteLastLog(logBacking: GlobalLogBacking): Unit =
-    logBacking.last.foreach(_.delete())
-
-  /** Runs the next sequence of commands with global logging in place. */
-  def runWithNewLog(state: State, logBacking: GlobalLogBacking): RunNext =
-    Using.fileWriter(append = true)(logBacking.file) { writer =>
-      val out = new java.io.PrintWriter(writer)
-      val newLogging = state.globalLogging.newLogger(out, logBacking)
-      transferLevels(state, newLogging)
-      val loggedState = state.copy(globalLogging = newLogging)
-      try run(loggedState) finally out.close()
-    }
-
-  /** Transfers logging and trace levels from the old global loggers to the new ones. */
-  private[this] def transferLevels(state: State, logging: GlobalLogging): Unit = {
-    val old = state.globalLogging
-    Logger.transferLevels(old.backed, logging.backed)
-    (old.full, logging.full) match { // well, this is a hack
-      case (oldLog: AbstractLogger, newLog: AbstractLogger) => Logger.transferLevels(oldLog, newLog)
-      case _ => ()
-    }
-  }
-
-  sealed trait RunNext
-  final class ClearGlobalLog(val state: State) extends RunNext
-  final class KeepGlobalLog(val state: State) extends RunNext
-  final class Return(val result: xsbti.MainResult) extends RunNext
-
-  /** Runs the next sequence of commands that doesn't require global logging changes.*/
-  @tailrec def run(state: State): RunNext =
-    state.next match {
-      case State.Continue       => run(next(state))
-      case State.ClearGlobalLog => new ClearGlobalLog(state.continue)
-      case State.KeepLastLog    => new KeepGlobalLog(state.continue)
-      case ret: State.Return    => new Return(ret.result)
-    }
-
-  def next(state: State): State =
-    ErrorHandling.wideConvert { state.process(Command.process) } match {
-      case Right(s)                  => s
-      case Left(t: xsbti.FullReload) => throw t
-      case Left(t)                   => state.handleError(t)
-    }
-
-  @deprecated("Use State.handleError", "0.13.0")
-  def handleException(e: Throwable, s: State): State = s.handleError(e)
-
-  @deprecated("Use State.handleError", "0.13.0")
-  def handleException(t: Throwable, s: State, log: Logger): State = State.handleException(t, s, log)
-
-  def logFullException(e: Throwable, log: Logger): Unit = State.logFullException(e, log)
-}
diff --git a/main-command/src/main/scala/sbt/State.scala b/main-command/src/main/scala/sbt/State.scala
index 61edef3e6..00a2d946f 100644
--- a/main-command/src/main/scala/sbt/State.scala
+++ b/main-command/src/main/scala/sbt/State.scala
@@ -1,15 +1,30 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
+import java.net.{ URL, URLClassLoader }
 import java.util.concurrent.Callable
+
+import sbt.internal.classpath.ClassLoaderCache
+import sbt.internal.inc.classpath.{ ClassLoaderCache => IncClassLoaderCache }
+import sbt.internal.util.complete.{ HistoryCommands, Parser }
+import sbt.internal.util._
 import sbt.util.Logger
-import sbt.internal.util.{ AttributeKey, AttributeMap, ErrorHandling, ExitHook, ExitHooks, GlobalLogging }
-import sbt.internal.util.complete.HistoryCommands
-import sbt.internal.CommandExchange
-import sbt.internal.inc.classpath.ClassLoaderCache
+import BasicCommandStrings.{
+  CompleteExec,
+  MapExec,
+  PopOnFailure,
+  ReportResult,
+  StartServer,
+  StashOnFailure,
+  networkExecPrefix,
+}
 
 /**
  * Data structure representing all command execution information.
@@ -27,13 +42,51 @@ final case class State(
     configuration: xsbti.AppConfiguration,
     definedCommands: Seq[Command],
     exitHooks: Set[ExitHook],
-    onFailure: Option[String],
-    remainingCommands: Seq[String],
+    onFailure: Option[Exec],
+    remainingCommands: List[Exec],
     history: State.History,
     attributes: AttributeMap,
     globalLogging: GlobalLogging,
-    next: State.Next) extends Identity {
-  lazy val combinedParser = Command.combine(definedCommands)(this)
+    currentCommand: Option[Exec],
+    next: State.Next
+) extends Identity {
+  private[sbt] lazy val (multiCommands, nonMultiCommands) =
+    definedCommands.partition(_.nameOption.contains(BasicCommandStrings.Multi))
+  private[sbt] lazy val nonMultiParser = Command.combine(nonMultiCommands)(this)
+  lazy val combinedParser: Parser[() => State] =
+    multiCommands.headOption match {
+      case Some(multi) => multi.parser(this) | nonMultiParser
+      case _           => nonMultiParser
+    }
+
+  def source: Option[CommandSource] =
+    currentCommand match {
+      case Some(x) => x.source
+      case _       => None
+    }
+}
+
+/**
+ * Data structure extracted form the State Machine for safe observability purposes.
+ *
+ * @param currentExecId provide the execId extracted from the original State.
+ * @param combinedParser the parser extracted from the original State.
+ */
+@deprecated("unused", "1.4.2")
+private[sbt] final case class SafeState(
+    currentExecId: Option[String],
+    combinedParser: Parser[() => sbt.State]
+)
+
+@deprecated("unused", "1.4.2")
+private[sbt] object SafeState {
+  @deprecated("use StandardMain.exchange.withState", "1.4.2")
+  def apply(s: State) = {
+    new SafeState(
+      currentExecId = s.currentCommand.map(_.execId).flatten,
+      combinedParser = s.combinedParser
+    )
+  }
 }
 
 trait Identity {
@@ -43,15 +96,21 @@ trait Identity {
 }
 
 /** Convenience methods for State transformations and operations. */
-trait StateOps {
-  def process(f: (String, State) => State): State
+trait StateOps extends Any {
+  def process(f: (Exec, State) => State): State
 
   /** Schedules `commands` to be run before any remaining commands.*/
-  def :::(commands: Seq[String]): State
+  def :::(newCommands: List[String]): State
+
+  /** Schedules `commands` to be run before any remaining commands.*/
+  def ++:(newCommands: List[Exec]): State
 
   /** Schedules `command` to be run before any remaining commands.*/
   def ::(command: String): State
 
+  /** Schedules `command` to be run before any remaining commands.*/
+  def +:(command: Exec): State
+
   /** Sets the next command processing action to be to continue processing the next command.*/
   def continue: State
 
@@ -65,11 +124,20 @@ trait StateOps {
    */
   def reboot(full: Boolean): State
 
+  /**
+   * Reboots sbt.  A reboot restarts execution from the entry point of the launcher.
+   * A reboot is designed to be as close as possible to actually restarting the JVM without actually doing so.
+   * Because the JVM is not restarted, JVM exit hooks are not run.
+   * State.exitHooks should be used instead and those will be run before rebooting.
+   * If `full` is true, the boot directory is deleted before starting again.
+   * If `currentOnly` is true, the artifacts for the current sbt version is deleted.
+   * This command is currently implemented to not return, but may be implemented in the future to only reboot at the next command processing step.
+   */
+  private[sbt] def reboot(full: Boolean, currentOnly: Boolean): State
+
   /** Sets the next command processing action to do.*/
   def setNext(n: State.Next): State
 
-  @deprecated("Use setNext", "0.11.0") def setResult(ro: Option[xsbti.MainResult]): State
-
   /**
    * Restarts sbt without dropping loaded Scala classes.  It is a shallower restart than `reboot`.
    * This method takes a snapshot of the remaining commands and will resume executing those commands after reload.
@@ -79,11 +147,13 @@ trait StateOps {
 
   /** Sets the next command processing action to be to rotate the global log and continue executing commands.*/
   def clearGlobalLog: State
+
   /** Sets the next command processing action to be to keep the previous log and continue executing commands.  */
   def keepLastLog: State
 
   /** Sets the next command processing action to be to exit with a zero exit code if `ok` is true and a nonzero exit code if `ok` if false.*/
   def exit(ok: Boolean): State
+
   /** Marks the currently executing command as failing.  This triggers failure handling by the command processor.  See also `State.onFailure`*/
   def fail: State
 
@@ -97,17 +167,22 @@ trait StateOps {
 
   /** Registers `newCommands` as available commands. */
   def ++(newCommands: Seq[Command]): State
+
   /** Registers `newCommand` as an available command. */
   def +(newCommand: Command): State
 
   /** Gets the value associated with `key` from the custom attributes map.*/
   def get[T](key: AttributeKey[T]): Option[T]
+
   /** Sets the value associated with `key` in the custom attributes map.*/
   def put[T](key: AttributeKey[T], value: T): State
+
   /** Removes the `key` and any associated value from the custom attributes map.*/
   def remove(key: AttributeKey[_]): State
+
   /** Sets the value associated with `key` in the custom attributes map by transforming the current value.*/
   def update[T](key: AttributeKey[T])(f: Option[T] => T): State
+
   /** Returns true if `key` exists in the custom attributes map, false if it does not exist.*/
   def has(key: AttributeKey[_]): Boolean
 
@@ -122,83 +197,163 @@ trait StateOps {
 
   /** Runs any defined exitHooks and then clears them.*/
   def runExitHooks(): State
+
   /** Registers a new exit hook, which will run when sbt exits or restarts.*/
   def addExitHook(f: => Unit): State
 
   /** An advisory flag that is `true` if this application will execute commands based on user input.*/
   def interactive: Boolean
+
   /** Changes the advisory `interactive` flag. */
   def setInteractive(flag: Boolean): State
 
   /** Get the class loader cache for the application.*/
-  def classLoaderCache: ClassLoaderCache
+  def classLoaderCache: IncClassLoaderCache
 
   /** Create and register a class loader cache.  This should be called once at the application entry-point.*/
   def initializeClassLoaderCache: State
 }
 
 object State {
+  private class UncloseableURLLoader(cp: Seq[File], parent: ClassLoader)
+      extends URLClassLoader(Array.empty, parent) {
+    override def getURLs: Array[URL] = cp.map(_.toURI.toURL).toArray
+  }
+
   /** Indicates where command execution should resume after a failure.*/
   val FailureWall = BasicCommandStrings.FailureWall
 
   /** Represents the next action for the command processor.*/
   sealed trait Next
+
   /** Indicates that the command processor should process the next command.*/
   object Continue extends Next
+
   /** Indicates that the application should exit with the given result.*/
   final class Return(val result: xsbti.MainResult) extends Next
+
   /** Indicates that global logging should be rotated.*/
   final object ClearGlobalLog extends Next
+
   /** Indicates that the previous log file should be preserved instead of discarded.*/
   final object KeepLastLog extends Next
 
   /**
    * Provides a list of recently executed commands.  The commands are stored as processed instead of as entered by the user.
+   *
    * @param executed the list of the most recently executed commands, with the most recent command first.
    * @param maxSize the maximum number of commands to keep, or 0 to keep an unlimited number.
    */
-  final class History private[State] (val executed: Seq[String], val maxSize: Int) {
+  final class History private[State] (val executed: Seq[Exec], val maxSize: Int) {
+
     /** Adds `command` as the most recently executed command.*/
-    def ::(command: String): History =
-      {
-        val prependTo = if (maxSize > 0 && executed.size >= maxSize) executed.take(maxSize - 1) else executed
-        new History(command +: prependTo, maxSize)
-      }
+    def ::(command: Exec): History = {
+      val prependTo =
+        if (maxSize > 0 && executed.size >= maxSize) executed.take(maxSize - 1) else executed
+      new History(command +: prependTo, maxSize)
+    }
+
     /** Changes the maximum number of commands kept, adjusting the current history if necessary.*/
     def setMaxSize(size: Int): History =
       new History(if (size <= 0) executed else executed.take(size), size)
-    def currentOption: Option[String] = executed.headOption
-    def previous: Option[String] = executed.drop(1).headOption
+    def currentOption: Option[Exec] = executed.headOption
+    def previous: Option[Exec] = executed.drop(1).headOption
   }
+
   /** Constructs an empty command History with a default, finite command limit.*/
   def newHistory = new History(Vector.empty, HistoryCommands.MaxLines)
 
-  def defaultReload(state: State): Reboot =
-    {
-      val app = state.configuration.provider
-      new Reboot(app.scalaProvider.version, state.remainingCommands, app.id, state.configuration.baseDirectory)
-    }
+  def defaultReload(state: State): Reboot = {
+    val app = state.configuration.provider
+    new Reboot(
+      app.scalaProvider.version,
+      state.remainingCommands map { case e: Exec => e.commandLine },
+      app.id,
+      state.configuration.baseDirectory
+    )
+  }
 
-  private[sbt] lazy val exchange = new CommandExchange()
+  @deprecated("Import State._ or State.StateOpsImpl to access state extension methods", "1.3.0")
+  def stateOps(s: State): StateOps = new StateOpsImpl(s)
 
   /** Provides operations and transformations on State. */
-  implicit def stateOps(s: State): StateOps = new StateOps {
-    def process(f: (String, State) => State): State =
-      s.remainingCommands match {
-        case Seq() => exit(true)
-        case Seq(x, xs @ _*) =>
-          log.debug(s"> $x")
-          f(x, s.copy(remainingCommands = xs, history = x :: s.history))
+  implicit class StateOpsImpl(val s: State) extends AnyVal with StateOps {
+    def process(f: (Exec, State) => State): State = {
+      def runCmd(cmd: Exec, remainingCommands: List[Exec]) = {
+        log.debug(s"> $cmd")
+        val s1 = s.copy(
+          remainingCommands = remainingCommands,
+          currentCommand = Some(cmd),
+          history = cmd :: s.history,
+        )
+        f(cmd, s1)
       }
-    def :::(newCommands: Seq[String]): State = s.copy(remainingCommands = newCommands ++ s.remainingCommands)
-    def ::(command: String): State = (command :: Nil) ::: this
-    def ++(newCommands: Seq[Command]): State = s.copy(definedCommands = (s.definedCommands ++ newCommands).distinct)
+      s.remainingCommands match {
+        case Nil => exit(true)
+        case x :: xs =>
+          (x.execId, x.source) match {
+            /*
+             * If the command is coming from a network source, it might be a multi-command. To handle
+             * that, we need to give the command a new exec id and wrap some commands around the
+             * actual command that are used to report it. To make this work, we add a map of exec
+             * results as well as a mapping of exec ids to the exec id that spawned the exec.
+             * We add a command that fills the result map for the original exec. If the command fails,
+             * that map filling command (called sbtCompleteExec) is skipped so the map is never filled
+             * for the original event. The report command (called sbtReportResult) checks the result
+             * map and, if it finds an entry, it succeeds and removes the entry. Otherwise it fails.
+             * The exec for the report command is given the original exec id so the result reported
+             * to the client will be the result of the report command (which should correspond to
+             * the result of the underlying multi-command, which succeeds only if all of the commands
+             * succeed)
+             *
+             */
+            case (Some(id), Some(s))
+                if s.channelName.startsWith("network") &&
+                  !x.commandLine.startsWith(ReportResult) &&
+                  !x.commandLine.startsWith(networkExecPrefix) &&
+                  !id.startsWith(networkExecPrefix) =>
+              val newID = networkExecPrefix + Exec.newExecId
+              val cmd = x.withExecId(newID)
+              val map = Exec(s"$MapExec $id $newID", None)
+              val complete = Exec(s"$CompleteExec $id", None)
+              val report = Exec(s"$ReportResult $id", Some(id), x.source)
+              val stash = Exec(StashOnFailure, None)
+              val failureWall = Exec(FailureWall, None)
+              val pop = Exec(PopOnFailure, None)
+              val remaining = map :: cmd :: complete :: failureWall :: pop :: report :: xs
+              runCmd(stash, remaining)
+            case _ => runCmd(x, xs)
+          }
+      }
+    }
+    def :::(newCommands: List[String]): State = ++:(newCommands map { Exec(_, s.source) })
+    def ++:(newCommands: List[Exec]): State =
+      s.copy(remainingCommands = newCommands ::: s.remainingCommands)
+    def ::(command: String): State = +:(Exec(command, s.source))
+    def +:(command: Exec): State = (command :: Nil) ++: this
+    def ++(newCommands: Seq[Command]): State =
+      s.copy(definedCommands = (s.definedCommands ++ newCommands).distinct)
     def +(newCommand: Command): State = this ++ (newCommand :: Nil)
     def baseDir: File = s.configuration.baseDirectory
     def setNext(n: Next) = s.copy(next = n)
-    def setResult(ro: Option[xsbti.MainResult]) = ro match { case None => continue; case Some(r) => setNext(new Return(r)) }
     def continue = setNext(Continue)
-    def reboot(full: Boolean) = { runExitHooks(); throw new xsbti.FullReload(s.remainingCommands.toArray, full) }
+
+    /** Implementation of reboot. */
+    def reboot(full: Boolean): State = reboot(full, false)
+
+    /** Implementation of reboot. */
+    private[sbt] def reboot(full: Boolean, currentOnly: Boolean): State = {
+      runExitHooks()
+      val remaining: List[String] = s.remainingCommands.map(_.commandLine)
+      val fullRemaining = s.source match {
+        case Some(s) if s.channelName.startsWith("network") =>
+          StartServer :: remaining.dropWhile(!_.startsWith(ReportResult)).tail ::: "shell" :: Nil
+        case _ => remaining
+      }
+      if (currentOnly) throw new RebootCurrent(fullRemaining)
+      else throw new xsbti.FullReload(fullRemaining.toArray, full)
+    }
+
     def reload = runExitHooks().setNext(new Return(defaultReload(s)))
     def clearGlobalLog = setNext(ClearGlobalLog)
     def keepLastLog = setNext(KeepLastLog)
@@ -210,16 +365,14 @@ object State {
     def remove(key: AttributeKey[_]) = s.copy(attributes = s.attributes remove key)
     def log = s.globalLogging.full
     def handleError(t: Throwable): State = handleException(t, s, log)
-    def fail =
-      {
-        import BasicCommandStrings.Compat.{ FailureWall => CompatFailureWall }
-        val remaining = s.remainingCommands.dropWhile(c => c != FailureWall && c != CompatFailureWall)
-        if (remaining.isEmpty)
-          applyOnFailure(s, Nil, exit(ok = false))
-        else
-          applyOnFailure(s, remaining, s.copy(remainingCommands = remaining))
-      }
-    private[this] def applyOnFailure(s: State, remaining: Seq[String], noHandler: => State): State =
+    def fail = {
+      val remaining = s.remainingCommands.dropWhile(c => c.commandLine != FailureWall)
+      if (remaining.isEmpty)
+        applyOnFailure(s, Nil, exit(ok = false))
+      else
+        applyOnFailure(s, remaining, s.copy(remainingCommands = remaining))
+    }
+    private[this] def applyOnFailure(s: State, remaining: List[Exec], noHandler: => State): State =
       s.onFailure match {
         case Some(c) => s.copy(remainingCommands = c +: remaining, onFailure = None)
         case None    => noHandler
@@ -232,28 +385,70 @@ object State {
       s.copy(exitHooks = Set.empty)
     }
     def locked[T](file: File)(t: => T): T =
-      s.configuration.provider.scalaProvider.launcher.globalLock.apply(file, new Callable[T] { def call = t })
+      s.configuration.provider.scalaProvider.launcher.globalLock.apply(file, new Callable[T] {
+        def call = t
+      })
 
     def interactive = getBoolean(s, BasicKeys.interactive, false)
     def setInteractive(i: Boolean) = s.put(BasicKeys.interactive, i)
 
-    def classLoaderCache: ClassLoaderCache = s get BasicKeys.classLoaderCache getOrElse newClassLoaderCache
-    def initializeClassLoaderCache = s.put(BasicKeys.classLoaderCache, newClassLoaderCache)
-    private[this] def newClassLoaderCache = new ClassLoaderCache(s.configuration.provider.scalaProvider.launcher.topLoader)
+    def classLoaderCache: IncClassLoaderCache =
+      s get BasicKeys.classLoaderCache getOrElse (throw new IllegalStateException(
+        "Tried to get classloader cache for uninitialized state."
+      ))
+    private[sbt] def extendedClassLoaderCache: ClassLoaderCache =
+      s get BasicKeys.extendedClassLoaderCache getOrElse (throw new IllegalStateException(
+        "Tried to get extended classloader cache for uninitialized state."
+      ))
+    def initializeClassLoaderCache: State = {
+      s.get(BasicKeys.extendedClassLoaderCache).foreach(_.close())
+      val cache = newClassLoaderCache
+      s.configuration.provider.scalaProvider.loader match {
+        case null => // This can happen in scripted
+        case fullScalaLoader =>
+          val jars = s.configuration.provider.scalaProvider.jars
+          val (library, rest) = jars.partition(_.getName == "scala-library.jar")
+          library.toList match {
+            case l @ lj :: Nil =>
+              fullScalaLoader.getParent match {
+                case null => // This can happen for old launchers.
+                case libraryLoader =>
+                  cache.cachedCustomClassloader(l, () => new UncloseableURLLoader(l, libraryLoader))
+                  fullScalaLoader match {
+                    case u: URLClassLoader
+                        if u.getURLs
+                          .filterNot(_ == lj.toURI.toURL)
+                          .sameElements(rest.map(_.toURI.toURL)) =>
+                      cache.cachedCustomClassloader(
+                        jars.toList,
+                        () => new UncloseableURLLoader(jars, fullScalaLoader)
+                      )
+                      ()
+                    case _ =>
+                  }
+              }
+            case _ =>
+          }
+      }
+      s.put(BasicKeys.extendedClassLoaderCache, cache)
+        .put(BasicKeys.classLoaderCache, new IncClassLoaderCache(cache))
+    }
+    private[this] def newClassLoaderCache =
+      new ClassLoaderCache(s.configuration.provider.scalaProvider)
   }
 
   import ExceptionCategory._
 
-  private[sbt] def handleException(t: Throwable, s: State, log: Logger): State =
-    {
-      ExceptionCategory(t) match {
-        case AlreadyHandled => ()
-        case m: MessageOnly => log.error(m.message)
-        case f: Full        => logFullException(f.exception, log)
-      }
-      s.fail
+  private[this] def handleException(t: Throwable, s: State, log: Logger): State = {
+    ExceptionCategory(t) match {
+      case AlreadyHandled => ()
+      case m: MessageOnly => log.error(m.message)
+      case f: Full        => logFullException(f.exception, log)
     }
+    s.fail
+  }
   private[sbt] def logFullException(e: Throwable, log: Logger): Unit = {
+    e.printStackTrace(System.err)
     log.trace(e)
     log.error(ErrorHandling reducedToString e)
     log.error("Use 'last' for the full log.")
@@ -261,3 +456,5 @@ object State {
   private[sbt] def getBoolean(s: State, key: AttributeKey[Boolean], default: Boolean): Boolean =
     s.get(key) getOrElse default
 }
+
+private[sbt] final class RebootCurrent(val arguments: List[String]) extends RuntimeException
diff --git a/main-command/src/main/scala/sbt/Watched.scala b/main-command/src/main/scala/sbt/Watched.scala
index c74ff2f36..3bb4b4666 100644
--- a/main-command/src/main/scala/sbt/Watched.scala
+++ b/main-command/src/main/scala/sbt/Watched.scala
@@ -1,85 +1,180 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009, 2010  Mikko Peltonen, Stuart Roebuck, Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import BasicCommandStrings.ClearOnFailure
-import State.FailureWall
-import annotation.tailrec
 import java.io.File
+import java.nio.file.FileSystems
 
-import sbt.io.PathFinder
-import sbt.internal.io.{ SourceModificationWatch, WatchState }
-import sbt.internal.util.AttributeKey
+import sbt.internal.LabeledFunctions._
+import sbt.internal.LegacyWatched
+import sbt.internal.io.{ EventMonitor, Source, WatchState }
 import sbt.internal.util.Types.const
+import sbt.internal.util.AttributeKey
+import sbt.io._
 
+import scala.concurrent.duration._
+import scala.util.Properties
+
+@deprecated("Watched is no longer used to implement continuous execution", "1.3.0")
 trait Watched {
-  /** The files watched when an action is run with a preceeding ~ */
-  def watchPaths(s: State): Seq[File] = Nil
+
+  /** The files watched when an action is run with a proceeding ~ */
+  def watchSources(@deprecated("unused", "") s: State): Seq[Watched.WatchSource] = Nil
   def terminateWatch(key: Int): Boolean = Watched.isEnter(key)
+
   /**
-   * The time in milliseconds between checking for changes.  The actual time between the last change made to a file and the
-   * execution time is between `pollInterval` and `pollInterval*2`.
+   * The time in milliseconds between checking for changes.  The actual time between the last change
+   * made to a file and the execution time is between `pollInterval` and `pollInterval*2`.
    */
-  def pollInterval: Int = Watched.PollDelayMillis
+  def pollInterval: FiniteDuration = Watched.PollDelay
+
+  /**
+   * The duration for which the EventMonitor while ignore file events after a file triggers
+   * a new build.
+   */
+  def antiEntropy: FiniteDuration = Watched.AntiEntropy
+
   /** The message to show when triggered execution waits for sources to change.*/
   private[sbt] def watchingMessage(s: WatchState): String = Watched.defaultWatchingMessage(s)
+
   /** The message to show before an action is run. */
   private[sbt] def triggeredMessage(s: WatchState): String = Watched.defaultTriggeredMessage(s)
+
+  /** The `WatchService` to use to monitor the file system. */
+  private[sbt] def watchService(): WatchService = Watched.createWatchService()
 }
 
 object Watched {
-  val defaultWatchingMessage: WatchState => String = _.count + ". Waiting for source changes... (press enter to interrupt)"
-  val defaultTriggeredMessage: WatchState => String = const("")
-  val clearWhenTriggered: WatchState => String = const(clearScreen)
+
+  type WatchSource = Source
+  def terminateWatch(key: Int): Boolean = Watched.isEnter(key)
+
+  private def waitMessage(project: String): String =
+    s"Waiting for source changes$project... (press enter to interrupt)"
+
   def clearScreen: String = "\u001b[2J\u001b[0;0H"
 
+  object WatchSource {
+
+    /**
+     * Creates a new `WatchSource` for watching files, with the given filters.
+     *
+     * @param base          The base directory from which to include files.
+     * @param includeFilter Choose what children of `base` to include.
+     * @param excludeFilter Choose what children of `base` to exclude.
+     * @return An instance of `Source`.
+     */
+    def apply(base: File, includeFilter: FileFilter, excludeFilter: FileFilter): Source =
+      new Source(base, includeFilter, excludeFilter)
+
+    /**
+     * Creates a new `WatchSource` for watching files.
+     *
+     * @param base          The base directory from which to include files.
+     * @return An instance of `Source`.
+     */
+    def apply(base: File): Source = apply(base, AllPassFilter, NothingFilter)
+
+  }
+
+  private[sbt] val newWatchService: () => WatchService =
+    (() => createWatchService()).label("Watched.newWatchService")
+  def createWatchService(pollDelay: FiniteDuration): WatchService = {
+    def closeWatch = new MacOSXWatchService()
+    sys.props.get("sbt.watch.mode") match {
+      case Some("polling") =>
+        new PollingWatchService(pollDelay)
+      case Some("nio") =>
+        FileSystems.getDefault.newWatchService()
+      case Some("closewatch")    => closeWatch
+      case _ if Properties.isMac => closeWatch
+      case _ =>
+        FileSystems.getDefault.newWatchService()
+    }
+  }
+
+  @deprecated("This is no longer used by continuous builds.", "1.3.0")
+  def printIfDefined(msg: String): Unit = if (!msg.isEmpty) System.out.println(msg)
+  @deprecated("This is no longer used by continuous builds.", "1.3.0")
+  def isEnter(key: Int): Boolean = key == 10 || key == 13
+  @deprecated("Replaced by defaultPollInterval", "1.3.0")
+  val PollDelay: FiniteDuration = 500.milliseconds
+  @deprecated("Replaced by defaultAntiEntropy", "1.3.0")
+  val AntiEntropy: FiniteDuration = 40.milliseconds
+  @deprecated("Use the version that explicitly takes the poll delay", "1.3.0")
+  def createWatchService(): WatchService = createWatchService(PollDelay)
+
+  @deprecated("Replaced by Watched.command", "1.3.0")
+  def executeContinuously(watched: Watched, s: State, next: String, repeat: String): State =
+    LegacyWatched.executeContinuously(watched, s, next, repeat)
+
+  // Deprecated apis below
+  @deprecated("unused", "1.3.0")
+  def projectWatchingMessage(projectId: String): WatchState => String =
+    ((ws: WatchState) => projectOnWatchMessage(projectId)(ws.count, projectId, Nil).get)
+      .label("Watched.projectWatchingMessage")
+  @deprecated("unused", "1.3.0")
+  def projectOnWatchMessage(project: String): (Int, String, Seq[String]) => Option[String] = {
+    (count: Int, _: String, _: Seq[String]) =>
+      Some(s"$count. ${waitMessage(s" in project $project")}")
+  }.label("Watched.projectOnWatchMessage")
+
+  @deprecated("This method is not used and may be removed in a future version of sbt", "1.3.0")
   private[this] class AWatched extends Watched
 
+  @deprecated("This method is not used and may be removed in a future version of sbt", "1.3.0")
   def multi(base: Watched, paths: Seq[Watched]): Watched =
     new AWatched {
-      override def watchPaths(s: State) = (base.watchPaths(s) /: paths)(_ ++ _.watchPaths(s))
+      override def watchSources(s: State): Seq[Watched.WatchSource] =
+        paths.foldLeft(base.watchSources(s))(_ ++ _.watchSources(s))
       override def terminateWatch(key: Int): Boolean = base.terminateWatch(key)
-      override val pollInterval = (base +: paths).map(_.pollInterval).min
-      override def watchingMessage(s: WatchState) = base.watchingMessage(s)
-      override def triggeredMessage(s: WatchState) = base.triggeredMessage(s)
+      override val pollInterval: FiniteDuration = (base +: paths).map(_.pollInterval).min
+      override val antiEntropy: FiniteDuration = (base +: paths).map(_.antiEntropy).min
+      override def watchingMessage(s: WatchState): String = base.watchingMessage(s)
+      override def triggeredMessage(s: WatchState): String = base.triggeredMessage(s)
     }
+  @deprecated("This method is not used and may be removed in a future version of sbt", "1.3.0")
   def empty: Watched = new AWatched
 
-  val PollDelayMillis = 500
-  def isEnter(key: Int): Boolean = key == 10 || key == 13
-  def printIfDefined(msg: String) = if (!msg.isEmpty) System.out.println(msg)
+  @deprecated("ContinuousEventMonitor attribute is not used by Watched.command", "1.3.0")
+  val ContinuousEventMonitor =
+    AttributeKey[EventMonitor](
+      "watch event monitor",
+      "Internal: maintains watch state and monitor threads."
+    )
+  @deprecated("Superseded by ContinuousEventMonitor", "1.3.0")
+  val ContinuousState =
+    AttributeKey[WatchState]("watch state", "Internal: tracks state for continuous execution.")
 
-  def executeContinuously(watched: Watched, s: State, next: String, repeat: String): State =
-    {
-      @tailrec def shouldTerminate: Boolean =
-        (System.in.available > 0) && (watched.terminateWatch(System.in.read()) || shouldTerminate)
-      val sourcesFinder = PathFinder { watched watchPaths s }
-      val watchState = s get ContinuousState getOrElse WatchState.empty
+  @deprecated("Superseded by ContinuousEventMonitor", "1.3.0")
+  val ContinuousWatchService =
+    AttributeKey[WatchService](
+      "watch service",
+      "Internal: tracks watch service for continuous execution."
+    )
+  @deprecated("No longer used for continuous execution", "1.3.0")
+  val Configuration =
+    AttributeKey[Watched]("watched-configuration", "Configures continuous execution.")
 
-      if (watchState.count > 0)
-        printIfDefined(watched watchingMessage watchState)
-
-      val (triggered, newWatchState) =
-        try {
-          val (triggered, newWatchState) = SourceModificationWatch.watch(sourcesFinder, watched.pollInterval, watchState)(shouldTerminate)
-          (triggered, newWatchState)
-        } catch {
-          case e: Exception =>
-            val log = s.log
-            log.error("Error occurred obtaining files to watch.  Terminating continuous execution...")
-            State.handleException(e, s, log)
-            (false, watchState)
-        }
-
-      if (triggered) {
-        printIfDefined(watched triggeredMessage newWatchState)
-        (ClearOnFailure :: next :: FailureWall :: repeat :: s).put(ContinuousState, newWatchState)
-      } else {
-        while (System.in.available() > 0) System.in.read()
-        s.put(ContinuousState, WatchState.empty)
-      }
-    }
-  val ContinuousState = AttributeKey[WatchState]("watch state", "Internal: tracks state for continuous execution.")
-  val Configuration = AttributeKey[Watched]("watched-configuration", "Configures continuous execution.")
+  @deprecated("Use Watch.defaultStartWatch in conjunction with the watchStartMessage key", "1.3.0")
+  val defaultWatchingMessage: WatchState => String =
+    ((ws: WatchState) => s"${ws.count}. ${waitMessage("")} ")
+      .label("Watched.projectWatchingMessage")
+  @deprecated(
+    "Use Watch.defaultOnTriggerMessage in conjunction with the watchTriggeredMessage key",
+    "1.3.0"
+  )
+  val defaultTriggeredMessage: WatchState => String =
+    const("").label("Watched.defaultTriggeredMessage")
+  @deprecated(
+    "Use Watch.clearScreenOnTrigger in conjunction with the watchTriggeredMessage key",
+    "1.3.0"
+  )
+  val clearWhenTriggered: WatchState => String =
+    const(clearScreen).label("Watched.clearWhenTriggered")
 }
diff --git a/main-command/src/main/scala/sbt/internal/CommandChannel.scala b/main-command/src/main/scala/sbt/internal/CommandChannel.scala
index f01d9ffbd..c40375ec7 100644
--- a/main-command/src/main/scala/sbt/internal/CommandChannel.scala
+++ b/main-command/src/main/scala/sbt/internal/CommandChannel.scala
@@ -1,36 +1,119 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
 import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.atomic.AtomicReference
+
+import sbt.internal.ui.{ UITask, UserThread }
+import sbt.internal.util.Terminal
+import sbt.protocol.EventMessage
+import sbt.util.Level
+
+import scala.collection.JavaConverters._
 
 /**
  * A command channel represents an IO device such as network socket or human
  * that can issue command or listen for some outputs.
- * We can think of a command channel to be an abstration of the terminal window.
+ * We can think of a command channel to be an abstraction of the terminal window.
  */
 abstract class CommandChannel {
   private val commandQueue: ConcurrentLinkedQueue[Exec] = new ConcurrentLinkedQueue()
-  def append(exec: Exec): Boolean =
-    commandQueue.add(exec)
+  private val registered: java.util.Set[java.util.Queue[Exec]] = new java.util.HashSet
+  private val fastTrack: java.util.Set[java.util.Queue[FastTrackTask]] = new java.util.HashSet
+  private[sbt] final def register(
+      queue: java.util.Queue[Exec],
+      fastTrackQueue: java.util.Queue[FastTrackTask]
+  ): Unit =
+    registered.synchronized {
+      registered.add(queue)
+      if (!commandQueue.isEmpty) {
+        queue.addAll(commandQueue)
+        commandQueue.clear()
+      }
+      fastTrack.add(fastTrackQueue)
+      ()
+    }
+  private[sbt] final def unregister(
+      queue: java.util.Queue[CommandChannel],
+      fastTrackQueue: java.util.Queue[FastTrackTask]
+  ): Unit =
+    registered.synchronized {
+      registered.remove(queue)
+      fastTrack.remove(fastTrackQueue)
+      ()
+    }
+  private[sbt] final def addFastTrackTask(task: String): Unit = {
+    fastTrack.forEach(q => q.synchronized { q.add(new FastTrackTask(this, task)); () })
+  }
+  private[sbt] def mkUIThread: (State, CommandChannel) => UITask
+  private[sbt] def makeUIThread(state: State): UITask = mkUIThread(state, this)
+  final def append(exec: Exec): Boolean = {
+    registered.synchronized {
+      exec.commandLine.nonEmpty && {
+        if (registered.isEmpty) commandQueue.add(exec)
+        else registered.asScala.forall(_.add(exec))
+      }
+    }
+  }
   def poll: Option[Exec] = Option(commandQueue.poll)
 
-  /** start listening for a command exec. */
-  def run(s: State): State
-  def publishStatus(status: CommandStatus, lastSource: Option[CommandSource]): Unit
-  def shutdown(): Unit
+  def prompt(e: ConsolePromptEvent): Unit = userThread.onConsolePromptEvent(e)
+  def unprompt(e: ConsoleUnpromptEvent): Unit = userThread.onConsoleUnpromptEvent(e)
+  def publishBytes(bytes: Array[Byte]): Unit
+  private[sbt] def userThread: UserThread
+  def shutdown(logShutdown: Boolean): Unit = {
+    userThread.stopThread()
+    userThread.close()
+  }
+  @deprecated("Use the variant that takes the logShutdown parameter", "1.4.0")
+  def shutdown(): Unit = shutdown(true)
+  def name: String
+  private[this] val level = new AtomicReference[Level.Value](Level.Info)
+  private[sbt] final def setLevel(l: Level.Value): Unit = level.set(l)
+  private[sbt] final def logLevel: Level.Value = level.get
+  private[this] def setLevel(value: Level.Value, cmd: String): Boolean = {
+    level.set(value)
+    append(Exec(cmd, Some(Exec.newExecId), Some(CommandSource(name))))
+  }
+  private[sbt] def onCommand: String => Boolean = {
+    case "error" => setLevel(Level.Error, "error")
+    case "debug" => setLevel(Level.Debug, "debug")
+    case "info"  => setLevel(Level.Info, "info")
+    case "warn"  => setLevel(Level.Warn, "warn")
+    case cmd =>
+      if (cmd.nonEmpty) append(Exec(cmd, Some(Exec.newExecId), Some(CommandSource(name))))
+      else false
+  }
+  private[sbt] def onFastTrackTask: String => Boolean = { s: String =>
+    fastTrack.synchronized(fastTrack.forEach { q =>
+      q.add(new FastTrackTask(this, s))
+      ()
+    })
+    true
+  }
+
+  private[sbt] def terminal: Terminal
 }
 
-case class Exec(source: CommandSource, commandLine: String)
+// case class Exec(commandLine: String, source: Option[CommandSource])
 
-sealed trait CommandSource
-object CommandSource {
-  case object Human extends CommandSource
-  case object Network extends CommandSource
-}
+// case class CommandSource(channelName: String)
 
-/**
- * This is a data that is passed on to the channels.
- * The canEnter paramter indicates that the console devise or UI
- * should stop listening.
+/*
+ * This is a data passed specifically for local prompting console.
  */
-case class CommandStatus(state: State, canEnter: Boolean)
+case class ConsolePromptEvent(state: State) extends EventMessage
+
+/*
+ * This is a data passed specifically for unprompting local console.
+ */
+case class ConsoleUnpromptEvent(lastSource: Option[CommandSource]) extends EventMessage
+
+private[internal] class FastTrackTask(val channel: CommandChannel, val task: String)
diff --git a/main-command/src/main/scala/sbt/internal/CommandExchange.scala b/main-command/src/main/scala/sbt/internal/CommandExchange.scala
deleted file mode 100644
index 6bce31b0f..000000000
--- a/main-command/src/main/scala/sbt/internal/CommandExchange.scala
+++ /dev/null
@@ -1,52 +0,0 @@
-package sbt
-package internal
-
-import scala.annotation.tailrec
-import scala.collection.mutable.ListBuffer
-import java.util.concurrent.ConcurrentLinkedQueue
-
-/**
- * The command exchange merges multiple command channels (e.g. network and console),
- * and acts as the central multiplexing point.
- * Instead of blocking on JLine.readLine, the server commmand will block on
- * this exchange, which could serve command request from either of the channel.
- */
-private[sbt] final class CommandExchange {
-  private val commandQueue: ConcurrentLinkedQueue[Exec] = new ConcurrentLinkedQueue()
-  private val channelBuffer: ListBuffer[CommandChannel] = new ListBuffer()
-  def channels: List[CommandChannel] = channelBuffer.toList
-  def subscribe(c: CommandChannel): Unit =
-    channelBuffer.append(c)
-
-  subscribe(new ConsoleChannel())
-  subscribe(new NetworkChannel())
-
-  // periodically move all messages from all the channels
-  @tailrec def blockUntilNextExec: Exec =
-    {
-      @tailrec def slurpMessages(): Unit =
-        (((None: Option[Exec]) /: channels) { _ orElse _.poll }) match {
-          case Some(x) =>
-            commandQueue.add(x)
-            slurpMessages
-          case _ => ()
-        }
-      slurpMessages()
-      Option(commandQueue.poll) match {
-        case Some(x) => x
-        case _ =>
-          Thread.sleep(50)
-          blockUntilNextExec
-      }
-    }
-
-  // fanout run to all channels
-  def run(s: State): State =
-    (s /: channels) { (acc, c) => c.run(acc) }
-
-  // fanout publishStatus to all channels
-  def publishStatus(status: CommandStatus, lastSource: Option[CommandSource]): Unit =
-    channels foreach { c =>
-      c.publishStatus(status, lastSource)
-    }
-}
diff --git a/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala b/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala
index 5b0c99497..dac0c9565 100644
--- a/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala
+++ b/main-command/src/main/scala/sbt/internal/ConsoleChannel.scala
@@ -1,59 +1,31 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
+import sbt.internal.ui.{ UITask, UserThread }
 import sbt.internal.util._
-import BasicKeys._
-import java.io.File
+import sjsonnew.JsonFormat
 
-private[sbt] final class ConsoleChannel extends CommandChannel {
-  private var askUserThread: Option[Thread] = None
-  def makeAskUserThread(status: CommandStatus): Thread = new Thread("ask-user-thread") {
-    val s = status.state
-    val history = (s get historyPath) getOrElse Some(new File(s.baseDir, ".history"))
-    val prompt = (s get shellPrompt) match {
-      case Some(pf) => pf(s)
-      case None     => "> "
-    }
-    val reader = new FullReader(history, s.combinedParser, JLine.HandleCONT, true)
-    override def run(): Unit = {
-      // This internally handles thread interruption and returns Some("")
-      val line = reader.readLine(prompt)
-      line match {
-        case Some(cmd) => append(Exec(CommandSource.Human, cmd))
-        case None      => append(Exec(CommandSource.Human, "exit"))
-      }
-      askUserThread = None
-    }
-  }
+private[sbt] final class ConsoleChannel(
+    val name: String,
+    override private[sbt] val mkUIThread: (State, CommandChannel) => UITask
+) extends CommandChannel {
 
   def run(s: State): State = s
 
-  def publishStatus(status: CommandStatus, lastSource: Option[CommandSource]): Unit =
-    if (status.canEnter) {
-      askUserThread match {
-        case Some(x) => //
-        case _ =>
-          val x = makeAskUserThread(status)
-          askUserThread = Some(x)
-          x.start
-      }
-    } else {
-      lastSource match {
-        case Some(src) if src != CommandSource.Human =>
-          askUserThread match {
-            case Some(x) =>
-              shutdown()
-            case _ =>
-          }
-        case _ =>
-      }
-    }
+  def publishBytes(bytes: Array[Byte]): Unit = ()
 
-  def shutdown(): Unit =
-    askUserThread match {
-      case Some(x) if x.isAlive =>
-        x.interrupt
-        askUserThread = None
-      case _ => ()
-    }
+  def publishEvent[A: JsonFormat](event: A, execId: Option[String]): Unit = ()
+
+  override val userThread: UserThread = new UserThread(this)
+  private[sbt] def terminal = Terminal.console
+}
+private[sbt] object ConsoleChannel {
+  private[sbt] def defaultName = "console0"
 }
diff --git a/main-command/src/main/scala/sbt/internal/LabeledFunctions.scala b/main-command/src/main/scala/sbt/internal/LabeledFunctions.scala
new file mode 100644
index 000000000..bb196462d
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/LabeledFunctions.scala
@@ -0,0 +1,163 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+/**
+ * Provides extension methods that allow us to wrap FunctionN instances with another FunctionN that
+ * delegates to the input FunctionN, but overrides the toString method with a user specified
+ * label. Anonymous functions have the default java toString which is just the class name. Because
+ * the anonymous class is generated implicitly, it can be impossible to tell which anonymous
+ * class you are looking at if there are multiple anonymous functions of the same type in a
+ * given object/class/package. We can overcome this limitation by explicitly setting the toString
+ * of the anonymous function instances. This is a fairly crude solution to the problem that
+ * is not ready to be exposed to users. Until the api matures or we decide that it's worth
+ * exposing to users, these should remain sbt package private.
+ */
+private[sbt] object LabeledFunctions {
+
+  /**
+   * Adds extension methods to a zero argument function.
+   * @param f the function to extend
+   * @tparam R the function result type
+   */
+  private[sbt] implicit class Function0Ops[R](val f: () => R) extends AnyVal {
+
+    /**
+     * Add a label to the function.
+     * @param string the new toString method for the function
+     * @return a wrapped function with an overridden toString method.
+     */
+    def label(string: String): () => R = new LabeledFunction0(f, string)
+  }
+
+  /**
+   * Adds extension methods to a single argument function.
+   * @param f the function to extend
+   * @tparam T the input parameter
+   * @tparam R the function result type
+   */
+  private[sbt] implicit class Function1Ops[T, R](val f: T => R) extends AnyVal {
+
+    /**
+     * Add a label to the function.
+     * @param string the new toString method for the function
+     * @return a wrapped function with an overridden toString method.
+     */
+    def label(string: String): T => R = new LabeledFunction1(f, string)
+  }
+
+  /**
+   * Adds extension methods to a two argument function.
+   * @param f the function to extend
+   * @tparam T1 the first function input parameter
+   * @tparam T2 the second function input parameter
+   * @tparam R the function result type
+   */
+  private[sbt] implicit class Function2Ops[T1, T2, R](val f: (T1, T2) => R) extends AnyVal {
+
+    /**
+     * Add a label to the function.
+     * @param string the new toString method for the function
+     * @return a wrapped function with an overridden toString method.
+     */
+    def label(string: String): (T1, T2) => R = new LabeledFunction2(f, string)
+  }
+
+  /**
+   * Adds extension methods to a three argument function.
+   * @param f the function to extend
+   * @tparam T1 the first function input parameter
+   * @tparam T2 the second function input parameter
+   * @tparam T3 the third function input parameter
+   * @tparam R the function result type
+   */
+  private[sbt] implicit class Function3Ops[T1, T2, T3, R](val f: (T1, T2, T3) => R) extends AnyVal {
+
+    /**
+     * Add a label to the function.
+     * @param string the new toString method for the function
+     * @return a wrapped function with an overridden toString method.
+     */
+    def label(string: String): (T1, T2, T3) => R = new LabeledFunction3(f, string)
+  }
+
+  /**
+   * Adds extension methods to a three argument function.
+   * @param f the function to extend
+   * @tparam T1 the first function input parameter
+   * @tparam T2 the second function input parameter
+   * @tparam T3 the third function input parameter
+   * @tparam T4 the fourth function input parameter
+   * @tparam R the function result type
+   */
+  private[sbt] implicit class Function4Ops[T1, T2, T3, T4, R](val f: (T1, T2, T3, T4) => R)
+      extends AnyVal {
+
+    /**
+     * Add a label to the function.
+     * @param string the new toString method for the function
+     * @return a wrapped function with an overridden toString method.
+     */
+    def label(string: String): (T1, T2, T3, T4) => R = new LabeledFunction4(f, string)
+  }
+  private class LabeledFunction0[+R](private val f: () => R, label: String) extends (() => R) {
+    override def apply(): R = f()
+    override def toString: String = label
+    override def equals(o: Any): Boolean = o match {
+      case that: LabeledFunction0[R] @unchecked => this.f == that.f
+      case that: (() => R) @unchecked           => this.f == that
+      case _                                    => false
+    }
+    override def hashCode: Int = f.hashCode
+  }
+  private class LabeledFunction1[-T, +R](private val f: T => R, label: String) extends (T => R) {
+    override def apply(t: T): R = f(t)
+    override def toString: String = label
+    override def equals(o: Any): Boolean = o match {
+      case that: LabeledFunction1[T, R] @unchecked => this.f == that.f
+      case that: (T => R) @unchecked               => this.f == that
+      case _                                       => false
+    }
+    override def hashCode: Int = f.hashCode
+  }
+  private class LabeledFunction2[-T1, -T2, +R](private val f: (T1, T2) => R, label: String)
+      extends ((T1, T2) => R) {
+    override def apply(t1: T1, t2: T2): R = f(t1, t2)
+    override def toString: String = label
+    override def equals(o: Any): Boolean = o match {
+      case that: LabeledFunction2[T1, T2, R] @unchecked => this.f == that.f
+      case that: ((T1, T2) => R) @unchecked             => this.f == that
+      case _                                            => false
+    }
+    override def hashCode: Int = f.hashCode
+  }
+  private class LabeledFunction3[-T1, -T2, -T3, +R](private val f: (T1, T2, T3) => R, label: String)
+      extends ((T1, T2, T3) => R) {
+    override def apply(t1: T1, t2: T2, t3: T3): R = f(t1, t2, t3)
+    override def toString: String = label
+    override def equals(o: Any): Boolean = o match {
+      case that: LabeledFunction3[T1, T2, T3, R] @unchecked => this.f == that.f
+      case that: ((T1, T2, T3) => R) @unchecked             => this.f == that
+      case _                                                => false
+    }
+    override def hashCode: Int = f.hashCode
+  }
+  private class LabeledFunction4[-T1, -T2, -T3, T4, +R](
+      private val f: (T1, T2, T3, T4) => R,
+      label: String
+  ) extends ((T1, T2, T3, T4) => R) {
+    override def apply(t1: T1, t2: T2, t3: T3, t4: T4): R = f(t1, t2, t3, t4)
+    override def toString: String = label
+    override def equals(o: Any): Boolean = o match {
+      case that: LabeledFunction4[T1, T2, T3, T4, R] @unchecked => this.f == that.f
+      case that: ((T1, T2, T3, T4) => R) @unchecked             => this.f == that
+      case _                                                    => false
+    }
+    override def hashCode: Int = f.hashCode
+  }
+}
diff --git a/main-command/src/main/scala/sbt/internal/LegacyWatched.scala b/main-command/src/main/scala/sbt/internal/LegacyWatched.scala
new file mode 100644
index 000000000..dc9860efd
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/LegacyWatched.scala
@@ -0,0 +1,85 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import sbt.BasicCommandStrings.{ ClearOnFailure, FailureWall }
+import sbt.Watched.ContinuousEventMonitor
+import sbt.internal.io.{ EventMonitor, WatchState }
+import sbt.internal.nio.{ FileEventMonitor, FileTreeRepository, WatchLogger }
+import sbt.{ State, Watched }
+
+import scala.annotation.tailrec
+import scala.concurrent.duration._
+import scala.util.control.NonFatal
+
+private[sbt] object LegacyWatched {
+  @deprecated("Replaced by Watched.command", "1.3.0")
+  def executeContinuously(watched: Watched, s: State, next: String, repeat: String): State = {
+    @tailrec def shouldTerminate: Boolean =
+      (System.in.available > 0) && (watched.terminateWatch(System.in.read()) || shouldTerminate)
+    val log = s.log
+    s get ContinuousEventMonitor match {
+      case None =>
+        val watchState = WatchState.empty(watched.watchService(), watched.watchSources(s))
+        // This is the first iteration, so run the task and create a new EventMonitor
+        val logger: WatchLogger = (a: Any) => log.debug(a.toString)
+        val repo = FileTreeRepository.legacy(logger, watched.watchService())
+        val fileEventMonitor = FileEventMonitor.antiEntropy(
+          repo,
+          watched.antiEntropy,
+          logger,
+          watched.antiEntropy,
+          10.minutes
+        )
+        val monitor = new EventMonitor {
+          override def awaitEvent(): Boolean = fileEventMonitor.poll(2.millis).nonEmpty
+          override def state(): WatchState = watchState
+          override def close(): Unit = watchState.close()
+        }
+        (ClearOnFailure :: next :: FailureWall :: repeat :: s)
+          .put(ContinuousEventMonitor, monitor: EventMonitor)
+      case Some(eventMonitor) =>
+        Watched.printIfDefined(watched watchingMessage eventMonitor.state)
+        @tailrec def impl(): State = {
+          val triggered = try eventMonitor.awaitEvent()
+          catch {
+            case NonFatal(e) =>
+              log.error(
+                "Error occurred obtaining files to watch.  Terminating continuous execution..."
+              )
+              s.handleError(e)
+              false
+          }
+          if (triggered) {
+            Watched.printIfDefined(watched triggeredMessage eventMonitor.state)
+            ClearOnFailure :: next :: FailureWall :: repeat :: s
+          } else if (shouldTerminate) {
+            while (System.in.available() > 0) System.in.read()
+            eventMonitor.close()
+            s.remove(ContinuousEventMonitor)
+          } else {
+            impl()
+          }
+        }
+        impl()
+    }
+  }
+
+}
+
+package io {
+  @deprecated("No longer used", "1.3.0")
+  private[sbt] trait EventMonitor extends AutoCloseable {
+
+    /** Block indefinitely until the monitor receives a file event or the user stops the watch. */
+    def awaitEvent(): Boolean
+
+    /** A snapshot of the WatchState that includes the number of build triggers and watch sources. */
+    def state(): WatchState
+  }
+}
diff --git a/main-command/src/main/scala/sbt/internal/NetworkChannel.scala b/main-command/src/main/scala/sbt/internal/NetworkChannel.scala
deleted file mode 100644
index 597f6e602..000000000
--- a/main-command/src/main/scala/sbt/internal/NetworkChannel.scala
+++ /dev/null
@@ -1,44 +0,0 @@
-package sbt
-package internal
-
-import sbt.internal.server._
-import BasicKeys._
-
-private[sbt] final class NetworkChannel extends CommandChannel {
-  private var server: Option[ServerInstance] = None
-
-  def run(s: State): State =
-    {
-      val port = (s get serverPort) match {
-        case Some(x) => x
-        case None    => 5001
-      }
-      def onCommand(command: internal.server.Command): Unit = {
-        command match {
-          case Execution(cmd) => append(Exec(CommandSource.Network, cmd))
-        }
-      }
-      server match {
-        case Some(x) => // do nothing
-        case _ =>
-          server = Some(Server.start("127.0.0.1", port, onCommand, s.log))
-      }
-      s
-    }
-
-  def shutdown(): Unit =
-    {
-      // interrupt and kill the thread
-      server.foreach(_.shutdown())
-      server = None
-    }
-
-  def publishStatus(cmdStatus: CommandStatus, lastSource: Option[CommandSource]): Unit = {
-    server.foreach(server =>
-      server.publish(
-        if (cmdStatus.canEnter) StatusEvent(Ready)
-        else StatusEvent(Processing("TODO current command", cmdStatus.state.remainingCommands))
-      )
-    )
-  }
-}
diff --git a/main-command/src/main/scala/sbt/internal/classpath/ClassLoaderCache.scala b/main-command/src/main/scala/sbt/internal/classpath/ClassLoaderCache.scala
new file mode 100644
index 000000000..16877ad08
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/classpath/ClassLoaderCache.scala
@@ -0,0 +1,268 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.classpath
+
+import java.io.File
+import java.lang.management.ManagementFactory
+import java.lang.ref.{ Reference, ReferenceQueue, SoftReference }
+import java.net.URLClassLoader
+import java.util.concurrent.atomic.{ AtomicInteger, AtomicReference }
+
+import sbt.internal.inc.classpath.{
+  AbstractClassLoaderCache,
+  ClassLoaderCache => IncClassLoaderCache
+}
+import sbt.internal.inc.{ AnalyzingCompiler, ZincUtil }
+import sbt.io.IO
+import xsbti.ScalaProvider
+import xsbti.compile.{ ClasspathOptions, ScalaInstance }
+
+import scala.annotation.tailrec
+import scala.collection.JavaConverters._
+import scala.util.control.NonFatal
+
+private object ClassLoaderCache {
+  private def threadID = new AtomicInteger(0)
+}
+private[sbt] class ClassLoaderCache(
+    val parent: ClassLoader,
+    private val miniProvider: Option[(File, ClassLoader)]
+) extends AbstractClassLoaderCache {
+  private[this] val parentHolder = new AtomicReference(parent)
+  def commonParent = parentHolder.get()
+  def setParent(parent: ClassLoader): Unit = parentHolder.set(parent)
+  def this(commonParent: ClassLoader) = this(commonParent, None)
+  def this(scalaProvider: ScalaProvider) =
+    this(scalaProvider.launcher.topLoader, {
+      scalaProvider.jars.find(_.getName == "scala-library.jar").flatMap { lib =>
+        val clazz = scalaProvider.getClass
+        try {
+          val loader = clazz.getDeclaredMethod("libraryLoaderOnly").invoke(scalaProvider)
+          Some(lib -> loader.asInstanceOf[ClassLoader])
+        } catch { case NonFatal(_) => None }
+      }
+    })
+  private val scalaProviderKey = miniProvider.map {
+    case (f, cl) =>
+      new Key((f -> IO.getModifiedTimeOrZero(f)) :: Nil, commonParent) {
+        override def toClassLoader: ClassLoader = cl
+      }
+  }
+  private class Key(val fileStamps: Seq[(File, Long)], val parent: ClassLoader) {
+    def this(files: List[File], parent: ClassLoader) =
+      this(files.map(f => f -> IO.getModifiedTimeOrZero(f)), parent)
+    def this(files: List[File]) = this(files, commonParent)
+    lazy val files: Seq[File] = fileStamps.map(_._1)
+    lazy val maxStamp: Long = fileStamps.maxBy(_._2)._2
+    class CachedClassLoader
+        extends URLClassLoader(fileStamps.map(_._1.toURI.toURL).toArray, parent) {
+      override def toString: String =
+        s"CachedClassloader {\n  parent: $parent\n  urls:\n" + getURLs.mkString("    ", "\n", "\n}")
+    }
+    def toClassLoader: ClassLoader = new CachedClassLoader
+    override def equals(o: Any): Boolean = o match {
+      case that: Key => this.fileStamps == that.fileStamps && this.parent == that.parent
+    }
+    override def hashCode(): Int = (fileStamps.hashCode * 31) ^ parent.hashCode
+    override def toString: String = s"Key(${fileStamps mkString ","}, $parent)"
+  }
+  private[this] val delegate =
+    new java.util.concurrent.ConcurrentHashMap[Key, Reference[ClassLoader]]()
+  private[this] val referenceQueue = new ReferenceQueue[ClassLoader]
+
+  private[this] def clearExpiredLoaders(): Unit = lock.synchronized {
+    val clear = (k: Key, ref: Reference[ClassLoader]) => {
+      ref.get() match {
+        case w: WrappedLoader => w.invalidate()
+        case _                =>
+      }
+      delegate.remove(k)
+      ()
+    }
+    def isInvalidated(classLoader: ClassLoader): Boolean = classLoader match {
+      case w: WrappedLoader => w.invalidated()
+      case _                => false
+    }
+    delegate.asScala.groupBy { case (k, _) => k.parent -> k.files.toSet }.foreach {
+      case (_, pairs) if pairs.size > 1 =>
+        val max = pairs.map(_._1.maxStamp).max
+        pairs.foreach { case (k, v) => if (k.maxStamp != max) clear(k, v) }
+      case _ =>
+    }
+    delegate.forEach((k, v) => if (isInvalidated(k.parent)) clear(k, v))
+  }
+  private[this] class CleanupThread(private[this] val id: Int)
+      extends Thread(s"classloader-cache-cleanup-$id") {
+    setDaemon(true)
+    start()
+    @tailrec
+    override final def run(): Unit = {
+      val stop = try {
+        referenceQueue.remove(1000) match {
+          case ClassLoaderReference(key, classLoader) =>
+            close(classLoader)
+            delegate.remove(key)
+            ()
+          case _ =>
+        }
+        clearExpiredLoaders()
+        false
+      } catch {
+        case _: InterruptedException => true
+      }
+      if (!stop) run()
+    }
+  }
+
+  /*
+   * We need to manage the cache differently depending on whether or not sbt is started up with
+   * -XX:MaxMetaspaceSize=XXX. The reason is that when the metaspace limit is reached, the jvm
+   * will run a few Full GCs that will clear SoftReferences so that it can cleanup any classes
+   * that only softly reachable. If the GC during this phase is able to collect a classloader, it
+   * will free the metaspace (or at least some of it) previously occupied by the loader. This can
+   * prevent sbt from crashing with an OOM: Metaspace. The issue with this is that when a loader
+   * is collected in this way, it will leak handles to its url classpath. To prevent the resource
+   * leak, we can store a reference to a wrapper loader. That reference, in turn, holds a
+   * strong reference to the underlying loader. Under heap memory pressure, the jvm will clear the
+   * soft reference for the wrapped loader and add it to the reference queue. We add a thread
+   * that reads from the reference queue and closes the underlying URLClassLoader, preventing the
+   * resource leak. When the system is under heap memory pressure, this eviction approach works
+   * well. The problem is that we cannot prevent OOM: MetaSpace because the jvm doesn't give us
+   * a long enough window to clear the ClassLoader references. The wrapper class will get cleared
+   * during the Metaspace Full GC window, but, even though we quickly clear the strong reference
+   * to the underlying classloader and close it, the jvm gives up and crashes with an OOM.
+   *
+   * To avoid these crashes, if the user starts with a limit on metaspace size via
+   * -XX:MetaSpaceSize=XXX, we will just store direct soft references to the URLClassLoader and
+   * leak url classpath handles when loaders are evicted by garbage collection. This is consistent
+   * with the behavior of sbt versions < 1.3.0. In general, these leaks are probably not a big deal
+   * except on windows where they prevent any files for which the leaked class loader has an open
+   * handle from being modified. On linux and mac, we probably leak some file descriptors but it's
+   * fairly uncommon for sbt to run out of file descriptors.
+   *
+   */
+  private[this] val metaspaceIsLimited =
+    ManagementFactory.getMemoryPoolMXBeans.asScala
+      .exists(b => (b.getName == "Metaspace") && (b.getUsage.getMax > 0))
+  private[this] val mkReference: (Key, ClassLoader) => Reference[ClassLoader] =
+    if (metaspaceIsLimited) { (_, cl) =>
+      (new SoftReference[ClassLoader](cl, referenceQueue): Reference[ClassLoader])
+    } else ClassLoaderReference.apply
+  private[this] val cleanupThread = new CleanupThread(ClassLoaderCache.threadID.getAndIncrement())
+  private[this] val lock = new Object
+
+  private def close(classLoader: ClassLoader): Unit = classLoader match {
+    case a: AutoCloseable => a.close()
+    case _                =>
+  }
+  private case class ClassLoaderReference(key: Key, classLoader: ClassLoader)
+      extends SoftReference[ClassLoader](
+        new WrappedLoader(classLoader),
+        referenceQueue
+      )
+  def apply(
+      files: List[(File, Long)],
+      parent: ClassLoader,
+      mkLoader: () => ClassLoader
+  ): ClassLoader = {
+    val key = new Key(files, parent)
+    get(key, mkLoader)
+  }
+  def apply(files: List[File], parent: ClassLoader): ClassLoader = {
+    val key = new Key(files, parent)
+    get(key, () => key.toClassLoader)
+  }
+  override def apply(files: List[File]): ClassLoader = {
+    files match {
+      case d :: s :: Nil
+          if d.getName.startsWith("dotty-library") || d.getName.startsWith("scala3-library") =>
+        apply(files, classOf[org.jline.terminal.Terminal].getClassLoader)
+      case _ =>
+        val key = new Key(files)
+        get(key, () => key.toClassLoader)
+    }
+  }
+  override def cachedCustomClassloader(
+      files: List[File],
+      mkLoader: () => ClassLoader
+  ): ClassLoader = {
+    val key = new Key(files)
+    get(key, mkLoader)
+  }
+  private[this] def get(key: Key, f: () => ClassLoader): ClassLoader = {
+    scalaProviderKey match {
+      case Some(k) if k == key => k.toClassLoader
+      case _ =>
+        def addLoader(): ClassLoader = {
+          val ref = mkReference(key, f())
+          val loader = ref.get
+          delegate.put(key, ref)
+          clearExpiredLoaders()
+          loader
+        }
+        lock.synchronized {
+          delegate.get(key) match {
+            case null => addLoader()
+            case ref =>
+              ref.get match {
+                case null => addLoader()
+                case l    => l
+              }
+          }
+        }
+    }
+  }
+  private def clear(lock: Object): Unit = {
+    delegate.asScala.foreach {
+      case (_, ClassLoaderReference(_, classLoader)) => close(classLoader)
+      case (_, r: Reference[ClassLoader]) =>
+        r.get match {
+          case null        =>
+          case classLoader => close(classLoader)
+        }
+      case (_, _) =>
+    }
+    delegate.clear()
+  }
+
+  /**
+   * Clears any ClassLoader instances from the internal cache and closes them. Calling this
+   * method will not stop the cleanup thread. Call [[close]] to fully clean up this cache.
+   */
+  def clear(): Unit = lock.synchronized(clear(lock))
+
+  /**
+   * Completely shuts down this cache. It stops the background thread for cleaning up classloaders
+   *
+   * Clears any ClassLoader instances from the internal cache and closes them. It also
+   * method will not stop the cleanup thread. Call [[close]] to fully clean up this cache.
+   */
+  override def close(): Unit = lock.synchronized {
+    cleanupThread.interrupt()
+    cleanupThread.join()
+    clear(lock)
+  }
+}
+
+private[sbt] object AlternativeZincUtil {
+  def scalaCompiler(
+      scalaInstance: ScalaInstance,
+      compilerBridgeJar: File,
+      classpathOptions: ClasspathOptions,
+      classLoaderCache: Option[IncClassLoaderCache]
+  ): AnalyzingCompiler = {
+    val bridgeProvider = ZincUtil.constantBridgeProvider(scalaInstance, compilerBridgeJar)
+    new AnalyzingCompiler(
+      scalaInstance,
+      bridgeProvider,
+      classpathOptions,
+      _ => (),
+      classLoaderCache
+    )
+  }
+}
diff --git a/main-command/src/main/scala/sbt/internal/client/BspClient.scala b/main-command/src/main/scala/sbt/internal/client/BspClient.scala
new file mode 100644
index 000000000..19b8e106a
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/client/BspClient.scala
@@ -0,0 +1,69 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.client
+
+import java.io.{ InputStream, OutputStream }
+import java.net.Socket
+import java.util.concurrent.atomic.AtomicBoolean
+
+import sbt.Exit
+import scala.util.control.NonFatal
+
+object BspClient {
+  private[sbt] def bspRun(sbtServer: Socket): Int = {
+    val lock = new AnyRef
+    val terminated = new AtomicBoolean(false)
+    transferTo(terminated, lock, sbtServer.getInputStream, System.out).start()
+    transferTo(terminated, lock, System.in, sbtServer.getOutputStream).start()
+    try {
+      lock.synchronized {
+        while (!terminated.get) lock.wait()
+      }
+      0
+    } catch { case _: Throwable => 1 } finally sbtServer.close()
+  }
+
+  private[sbt] def transferTo(
+      terminated: AtomicBoolean,
+      lock: AnyRef,
+      input: InputStream,
+      output: OutputStream
+  ): Thread = {
+    val thread = new Thread {
+      override def run(): Unit = {
+        val buffer = Array.ofDim[Byte](1024)
+        try {
+          while (!terminated.get) {
+            val size = input.read(buffer)
+            if (size == -1) {
+              terminated.set(true)
+            } else {
+              output.write(buffer, 0, size)
+              output.flush()
+            }
+          }
+          input.close()
+          output.close()
+        } catch {
+          case _: InterruptedException => terminated.set(true)
+          case NonFatal(_)             => ()
+        } finally {
+          lock.synchronized {
+            terminated.set(true)
+            lock.notify()
+          }
+        }
+      }
+    }
+    thread.setDaemon(true)
+    thread
+  }
+  def run(configuration: xsbti.AppConfiguration): Exit = {
+    Exit(NetworkClient.run(configuration, configuration.arguments.toList, redirectOutput = true))
+  }
+}
diff --git a/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala b/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala
new file mode 100644
index 000000000..d6b376dac
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala
@@ -0,0 +1,1274 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package client
+
+import java.io.{ File, IOException, InputStream, PrintStream }
+import java.lang.ProcessBuilder.Redirect
+import java.net.{ Socket, SocketException }
+import java.nio.file.Files
+import java.util.UUID
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+import java.util.concurrent.{ ConcurrentHashMap, LinkedBlockingQueue, TimeUnit }
+
+import sbt.BasicCommandStrings.{ DashDashDetachStdio, DashDashServer, Shutdown, TerminateAction }
+import sbt.internal.client.NetworkClient.Arguments
+import sbt.internal.langserver.{ LogMessageParams, MessageType, PublishDiagnosticsParams }
+import sbt.internal.protocol._
+import sbt.internal.util.{ ConsoleAppender, ConsoleOut, Signals, Terminal, Util }
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.protocol._
+import sbt.util.Level
+import sjsonnew.BasicJsonProtocol._
+import sjsonnew.shaded.scalajson.ast.unsafe.{ JObject, JValue }
+import sjsonnew.support.scalajson.unsafe.Converter
+
+import scala.annotation.tailrec
+import scala.collection.mutable
+import scala.concurrent.duration._
+import scala.util.control.NonFatal
+import scala.util.{ Failure, Properties, Success, Try }
+import Serialization.{
+  CancelAll,
+  attach,
+  cancelReadSystemIn,
+  cancelRequest,
+  promptChannel,
+  readSystemIn,
+  systemIn,
+  systemErr,
+  systemOut,
+  systemOutFlush,
+  systemErrFlush,
+  terminalCapabilities,
+  terminalCapabilitiesResponse,
+  terminalGetSize,
+  terminalPropertiesQuery,
+  terminalPropertiesResponse,
+  terminalSetEcho,
+  terminalSetRawMode,
+  terminalSetSize,
+  getTerminalAttributes,
+  setTerminalAttributes,
+}
+import NetworkClient.Arguments
+import java.util.concurrent.TimeoutException
+
+trait ConsoleInterface {
+  def appendLog(level: Level.Value, message: => String): Unit
+  def success(msg: String): Unit
+}
+
+/**
+ * A NetworkClient connects to a running an sbt instance or starts a
+ * new instance if there isn't already one running. Once connected,
+ * it can send commands for sbt to run, it can send completions to sbt
+ * and print the completions to stdout so that a shell can consume
+ * the completions or it can enter an interactive sbt shell session
+ * in which it relays io bytes between sbt and the terminal.
+ *
+ * @param arguments   the arguments for the forked sbt server if the client
+ *                    needs to start it. It also contains the sbt command
+ *                    arguments to send to the server if any are present.
+ * @param console     a logging instance. This can use a ConsoleAppender or
+ *                    just simply print to a PrintSream.
+ * @param inputStream the InputStream from which the client reads bytes. It
+ *                    is not hardcoded to System.in so that a NetworkClient
+ *                    can be remotely controlled by a java process, which
+ *                    is useful in test.
+ * @param errorStream the sink for messages that we always want to be printed.
+ *                    It is usually System.err but could be overridden in tests
+ *                    or set to a null OutputStream if the NetworkClient needs
+ *                    to be silent
+ * @param printStream the sink for standard out messages. It is typically
+ *                    System.out but in the case of completions, the bytes written
+ *                    to System.out are usually treated as completion results
+ *                    so we need to reroute standard out messages to System.err.
+ *                    It's also useful to override this in testing.
+ * @param useJNI      toggles whether or not to use the jni based implementations
+ *                    in org.scalasbt.ipcsocket. These are only available on
+ *                    64 bit linux, mac and windows. Any other platform will need
+ *                    to fall back on jna.
+ */
+class NetworkClient(
+    arguments: Arguments,
+    console: ConsoleInterface,
+    inputStream: InputStream,
+    errorStream: PrintStream,
+    printStream: PrintStream,
+    useJNI: Boolean,
+) extends AutoCloseable { self =>
+  def this(configuration: xsbti.AppConfiguration, arguments: Arguments) =
+    this(
+      arguments = arguments.withBaseDirectory(configuration.baseDirectory),
+      console = NetworkClient.consoleAppenderInterface(System.out),
+      inputStream = System.in,
+      errorStream = System.err,
+      printStream = System.out,
+      useJNI = false,
+    )
+  def this(configuration: xsbti.AppConfiguration, args: List[String]) =
+    this(
+      console = NetworkClient.consoleAppenderInterface(System.out),
+      arguments =
+        NetworkClient.parseArgs(args.toArray).withBaseDirectory(configuration.baseDirectory),
+      inputStream = System.in,
+      errorStream = System.err,
+      printStream = System.out,
+      useJNI = false,
+    )
+  private val status = new AtomicReference("Ready")
+  private val lock: AnyRef = new AnyRef {}
+  private val running = new AtomicBoolean(true)
+  private val pendingResults =
+    new ConcurrentHashMap[String, (LinkedBlockingQueue[Integer], Long, String)]
+  private val pendingCancellations = new ConcurrentHashMap[String, LinkedBlockingQueue[Boolean]]
+  private val pendingCompletions = new ConcurrentHashMap[String, CompletionResponse => Unit]
+  private val attached = new AtomicBoolean(false)
+  private val attachUUID = new AtomicReference[String](null)
+  private val connectionHolder = new AtomicReference[ServerConnection]
+  private val batchMode = new AtomicBoolean(false)
+  private val interactiveThread = new AtomicReference[Thread](null)
+  private val rebooting = new AtomicBoolean(false)
+  private lazy val noTab = arguments.completionArguments.contains("--no-tab")
+  private lazy val noStdErr = arguments.completionArguments.contains("--no-stderr") &&
+    System.getenv("SBTC_AUTO_COMPLETE") == null
+
+  private def mkSocket(file: File): (Socket, Option[String]) = ClientSocket.socket(file, useJNI)
+
+  private def portfile = arguments.baseDirectory / "project" / "target" / "active.json"
+
+  def connection: ServerConnection = connectionHolder.synchronized {
+    connectionHolder.get match {
+      case null => init(promptCompleteUsers = false, retry = true)
+      case c    => c
+    }
+  }
+
+  private[this] val stdinBytes = new LinkedBlockingQueue[Integer]
+  private[this] val inLock = new Object
+  private[this] val inputThread = new AtomicReference[RawInputThread]
+  private[this] val exitClean = new AtomicBoolean(true)
+  private[this] val sbtProcess = new AtomicReference[Process](null)
+  private class ConnectionRefusedException(t: Throwable) extends Throwable(t)
+  private class ServerFailedException extends Exception
+  private[this] def startInputThread(): Unit = inputThread.get match {
+    case null => inputThread.set(new RawInputThread)
+    case _    =>
+  }
+
+  private[sbt] def connectOrStartServerAndConnect(
+      promptCompleteUsers: Boolean,
+      retry: Boolean
+  ): (Socket, Option[String]) =
+    try {
+      if (!portfile.exists) {
+        if (promptCompleteUsers) {
+          val msg = if (noTab) "" else "No sbt server is running. Press <tab> to start one..."
+          errorStream.print(s"\n$msg")
+          if (noStdErr) System.exit(0)
+          else if (noTab) waitForServer(portfile, log = true, startServer = true)
+          else {
+            startInputThread()
+            stdinBytes.poll(5, TimeUnit.SECONDS) match {
+              case null => System.exit(0)
+              case i if i == 9 =>
+                errorStream.println("\nStarting server...")
+                waitForServer(portfile, !promptCompleteUsers, startServer = true)
+              case _ => System.exit(0)
+            }
+          }
+        } else {
+          waitForServer(portfile, log = true, startServer = true)
+        }
+      }
+      @tailrec def connect(attempt: Int): (Socket, Option[String]) = {
+        val res = try Some(mkSocket(portfile))
+        catch {
+          // This catches a pipe busy exception which can happen if two windows clients
+          // attempt to connect in rapid succession
+          case e: IOException if e.getMessage.contains("Couldn't open") && attempt < 10 =>
+            if (e.getMessage.contains("Access is denied") || e.getMessage.contains("(5)")) {
+              errorStream.println(s"Access denied for portfile $portfile")
+              throw new NetworkClient.AccessDeniedException
+            }
+            None
+          case e: IOException => throw new ConnectionRefusedException(e)
+        }
+        res match {
+          case Some(r) => r
+          case None    =>
+            // Use a random sleep to spread out the competing processes
+            Thread.sleep(new java.util.Random().nextInt(20).toLong)
+            connect(attempt + 1)
+        }
+      }
+      connect(0)
+    } catch {
+      case e: ConnectionRefusedException if retry =>
+        if (Files.deleteIfExists(portfile.toPath))
+          connectOrStartServerAndConnect(promptCompleteUsers, retry = false)
+        else throw e
+    }
+
+  // Open server connection based on the portfile
+  def init(promptCompleteUsers: Boolean, retry: Boolean): ServerConnection = {
+    val (sk, tkn) = connectOrStartServerAndConnect(promptCompleteUsers, retry)
+    val conn = new ServerConnection(sk) {
+      override def onNotification(msg: JsonRpcNotificationMessage): Unit = {
+        msg.method match {
+          case `Shutdown` =>
+            val (log, rebootCommands) = msg.params match {
+              case Some(jvalue) =>
+                Converter
+                  .fromJson[(Boolean, Option[(String, String)])](jvalue)
+                  .getOrElse((true, None))
+              case _ => (false, None)
+            }
+            if (rebootCommands.nonEmpty) {
+              rebooting.set(true)
+              attached.set(false)
+              connectionHolder.getAndSet(null) match {
+                case null =>
+                case c    => c.shutdown()
+              }
+              waitForServer(portfile, true, false)
+              init(promptCompleteUsers = false, retry = false)
+              attachUUID.set(sendJson(attach, s"""{"interactive": ${!batchMode.get}}"""))
+              rebooting.set(false)
+              rebootCommands match {
+                case Some((execId, cmd)) if execId.nonEmpty =>
+                  if (batchMode.get && !pendingResults.containsKey(execId) && cmd.nonEmpty) {
+                    console.appendLog(
+                      Level.Error,
+                      s"received request to re-run unknown command '$cmd' after reboot"
+                    )
+                  } else if (cmd.nonEmpty) {
+                    if (batchMode.get) sendCommand(ExecCommand(cmd, execId))
+                    else
+                      inLock.synchronized {
+                        val toSend = cmd.getBytes :+ '\r'.toByte
+                        toSend.foreach(b => sendNotification(systemIn, b.toString))
+                      }
+                  } else completeExec(execId, 0)
+                case _ =>
+              }
+            } else {
+              if (!rebooting.get() && running.compareAndSet(true, false) && log) {
+                if (!arguments.commandArguments.contains(Shutdown)) {
+                  console.appendLog(Level.Error, "sbt server disconnected")
+                  exitClean.set(false)
+                }
+              } else {
+                console.appendLog(Level.Info, s"${if (log) "sbt server " else ""}disconnected")
+              }
+              stdinBytes.offer(-1)
+              Option(inputThread.get).foreach(_.close())
+              Option(interactiveThread.get).foreach(_.interrupt)
+            }
+          case `readSystemIn` => startInputThread()
+          case `cancelReadSystemIn` =>
+            inputThread.get match {
+              case null =>
+              case t    => t.close()
+            }
+          case _ => self.onNotification(msg)
+        }
+      }
+      override def onRequest(msg: JsonRpcRequestMessage): Unit = self.onRequest(msg)
+      override def onResponse(msg: JsonRpcResponseMessage): Unit = self.onResponse(msg)
+      override def onShutdown(): Unit = if (!rebooting.get) {
+        if (exitClean.get != false) exitClean.set(!running.get)
+        running.set(false)
+        Option(interactiveThread.get).foreach(_.interrupt())
+      }
+    }
+    // initiate handshake
+    val execId = UUID.randomUUID.toString
+    val initCommand = InitCommand(tkn, Option(execId), Some(true))
+    conn.sendString(Serialization.serializeCommandAsJsonMessage(initCommand))
+    connectionHolder.set(conn)
+    conn
+  }
+
+  /**
+   * Forks another instance of sbt in the background.
+   * This instance must be shutdown explicitly via `sbt -client shutdown`
+   */
+  def waitForServer(portfile: File, log: Boolean, startServer: Boolean): Unit = {
+    val bootSocketName =
+      BootServerSocket.socketLocation(arguments.baseDirectory.toPath.toRealPath())
+
+    /*
+     * For unknown reasons, linux sometimes struggles to connect to the socket in some
+     * scenarios.
+     */
+    var socket: Option[Socket] =
+      if (!Properties.isLinux) Try(ClientSocket.localSocket(bootSocketName, useJNI)).toOption
+      else None
+    val term = Terminal.console
+    term.exitRawMode()
+    val process = socket match {
+      case None if startServer =>
+        if (log) console.appendLog(Level.Info, "server was not detected. starting an instance")
+
+        val props =
+          Seq(
+            term.getWidth,
+            term.getHeight,
+            term.isAnsiSupported,
+            term.isColorEnabled,
+            term.isSupershellEnabled
+          ).mkString(",")
+
+        val cmd = arguments.sbtLaunchJar match {
+          case Some(lj) =>
+            List("java") ++ arguments.sbtArguments ++
+              List("-jar", lj, DashDashDetachStdio, DashDashServer)
+          case _ =>
+            List(arguments.sbtScript) ++ arguments.sbtArguments ++
+              List(DashDashDetachStdio, DashDashServer)
+        }
+
+        // https://github.com/sbt/sbt/issues/6271
+        val nohup =
+          if (Util.isEmacs && !Util.isWindows) List("nohup")
+          else Nil
+
+        val processBuilder =
+          new ProcessBuilder((nohup ++ cmd): _*)
+            .directory(arguments.baseDirectory)
+            .redirectInput(Redirect.PIPE)
+        processBuilder.environment.put(Terminal.TERMINAL_PROPS, props)
+        val process = processBuilder.start()
+        sbtProcess.set(process)
+        Some(process)
+      case _ =>
+        if (log) {
+          console.appendLog(Level.Info, "sbt server is booting up")
+        }
+        None
+    }
+    if (!startServer) {
+      val deadline = 5.seconds.fromNow
+      while (socket.isEmpty && !deadline.isOverdue) {
+        socket = Try(ClientSocket.localSocket(bootSocketName, useJNI)).toOption
+        if (socket.isEmpty) Thread.sleep(20)
+      }
+    }
+    val hook = new Thread(() => Option(sbtProcess.get).foreach(_.destroyForcibly()))
+    Runtime.getRuntime.addShutdownHook(hook)
+    var gotInputBack = false
+    val readThreadAlive = new AtomicBoolean(true)
+    /*
+     * Socket.getInputStream.available doesn't always return a value greater than 0
+     * so it is necessary to read the process output from the socket on a background
+     * thread.
+     */
+    val readThread = new Thread("client-read-thread") {
+      setDaemon(true)
+      start()
+      override def run(): Unit = {
+        try {
+          while (readThreadAlive.get) {
+            if (socket.isEmpty) {
+              socket = Try(ClientSocket.localSocket(bootSocketName, useJNI)).toOption
+            }
+            socket.foreach { s =>
+              try {
+                s.getInputStream.read match {
+                  case -1 | 0            => readThreadAlive.set(false)
+                  case 2                 => gotInputBack = true
+                  case 5                 => term.enterRawMode(); startInputThread()
+                  case 3 if gotInputBack => readThreadAlive.set(false)
+                  case i if gotInputBack => stdinBytes.offer(i)
+                  case i                 => printStream.write(i)
+                }
+              } catch {
+                case e @ (_: IOException | _: InterruptedException) =>
+                  readThreadAlive.set(false)
+              }
+            }
+            if (socket.isEmpty && readThreadAlive.get) {
+              try Thread.sleep(10)
+              catch { case _: InterruptedException => }
+            }
+          }
+        } catch { case e: IOException => e.printStackTrace(System.err) }
+      }
+    }
+    @tailrec
+    def blockUntilStart(): Unit = {
+      val stop = try {
+        socket match {
+          case None =>
+            process.foreach { p =>
+              val output = p.getInputStream
+              while (output.available > 0) {
+                printStream.write(output.read())
+              }
+            }
+          case Some(s) =>
+            while (!gotInputBack && !stdinBytes.isEmpty && socket.isDefined) {
+              val out = s.getOutputStream
+              val b = stdinBytes.poll
+              out.write(b)
+              out.flush()
+            }
+        }
+        process.foreach { p =>
+          val error = p.getErrorStream
+          while (error.available > 0) {
+            errorStream.write(error.read())
+          }
+        }
+        false
+      } catch { case e: IOException => true }
+      Thread.sleep(10)
+      printStream.flush()
+      errorStream.flush()
+      /*
+       * If an earlier server process is launching, the process launched by this client
+       * will return with exit value 2. In that case, we can treat the process as alive
+       * even if it is actually dead.
+       */
+      val existsValidProcess =
+        process.fold(readThreadAlive.get)(p => p.isAlive || (Properties.isWin || p.exitValue == 2))
+      if (!portfile.exists && !stop && existsValidProcess) {
+        blockUntilStart()
+      } else {
+        socket.foreach { s =>
+          s.getInputStream.close()
+          s.getOutputStream.close()
+          s.close()
+        }
+        readThread.interrupt()
+        process.foreach { p =>
+          p.getOutputStream.close()
+          p.getErrorStream.close()
+          p.getInputStream.close()
+        }
+      }
+    }
+
+    try blockUntilStart()
+    catch { case t: Throwable => t.printStackTrace() } finally {
+      sbtProcess.set(null)
+      Util.ignoreResult(Runtime.getRuntime.removeShutdownHook(hook))
+    }
+    if (!portfile.exists()) throw new ServerFailedException
+    if (attached.get && !stdinBytes.isEmpty) Option(inputThread.get).foreach(_.drain())
+  }
+
+  /** Called on the response for a returning message. */
+  def onReturningReponse(msg: JsonRpcResponseMessage): Unit = {
+    def printResponse(): Unit = {
+      msg.result match {
+        case Some(result) =>
+          // ignore result JSON
+          console.success("completed")
+        case _ =>
+          msg.error match {
+            case Some(err) =>
+              // ignore err details
+              console.appendLog(Level.Error, "completed")
+            case _ => // ignore
+          }
+      }
+    }
+    printResponse()
+  }
+
+  private def getExitCode(jvalue: Option[JValue]): Integer = jvalue match {
+    case Some(o: JObject) =>
+      o.value
+        .collectFirst {
+          case v if v.field == "exitCode" =>
+            Converter.fromJson[Integer](v.value).getOrElse(Integer.valueOf(1))
+        }
+        .getOrElse(1)
+    case _ => 1
+  }
+  private def completeExec(execId: String, exitCode: => Int): Unit =
+    pendingResults.remove(execId) match {
+      case null =>
+      case (q, startTime, name) =>
+        val now = System.currentTimeMillis
+        val message = timing(startTime, now)
+        val ec = exitCode
+        if (batchMode.get || !attached.get) {
+          if (ec == 0) console.success(message)
+          else console.appendLog(Level.Error, message)
+        }
+        Util.ignoreResult(q.offer(ec))
+    }
+  def onResponse(msg: JsonRpcResponseMessage): Unit = {
+    completeExec(msg.id, getExitCode(msg.result))
+    pendingCancellations.remove(msg.id) match {
+      case null =>
+      case q    => q.offer(msg.toString.contains("Task cancelled"))
+    }
+    msg.id match {
+      case execId =>
+        if (attachUUID.get == msg.id) {
+          attachUUID.set(null)
+          attached.set(true)
+          Option(inputThread.get).foreach(_.drain())
+        }
+        pendingCompletions.remove(execId) match {
+          case null =>
+          case completions =>
+            completions(msg.result match {
+              case Some(o: JObject) =>
+                o.value
+                  .foldLeft(CompletionResponse(Vector.empty[String])) {
+                    case (resp, i) =>
+                      if (i.field == "items")
+                        resp.withItems(
+                          Converter
+                            .fromJson[Vector[String]](i.value)
+                            .getOrElse(Vector.empty[String])
+                        )
+                      else if (i.field == "cachedTestNames")
+                        resp.withCachedTestNames(
+                          Converter.fromJson[Boolean](i.value).getOrElse(true)
+                        )
+                      else if (i.field == "cachedMainClassNames")
+                        resp.withCachedMainClassNames(
+                          Converter.fromJson[Boolean](i.value).getOrElse(true)
+                        )
+                      else resp
+                  }
+              case _ => CompletionResponse(Vector.empty[String])
+            })
+        }
+    }
+  }
+
+  def onNotification(msg: JsonRpcNotificationMessage): Unit = {
+    def splitToMessage: Vector[(Level.Value, String)] =
+      (msg.method, msg.params) match {
+        case ("build/logMessage", Some(json)) =>
+          if (!attached.get) {
+            import sbt.internal.langserver.codec.JsonProtocol._
+            Converter.fromJson[LogMessageParams](json) match {
+              case Success(params) => splitLogMessage(params)
+              case Failure(_)      => Vector()
+            }
+          } else Vector()
+        case (`systemOut`, Some(json)) =>
+          Converter.fromJson[Array[Byte]](json) match {
+            case Success(bytes) if bytes.nonEmpty && attached.get =>
+              synchronized(printStream.write(bytes))
+            case _ =>
+          }
+          Vector.empty
+        case (`systemErr`, Some(json)) =>
+          Converter.fromJson[Array[Byte]](json) match {
+            case Success(bytes) if bytes.nonEmpty && attached.get =>
+              synchronized(errorStream.write(bytes))
+            case _ =>
+          }
+          Vector.empty
+        case (`systemOutFlush`, _) =>
+          synchronized(printStream.flush())
+          Vector.empty
+        case (`systemErrFlush`, _) =>
+          synchronized(errorStream.flush())
+          Vector.empty
+        case (`promptChannel`, _) =>
+          batchMode.set(false)
+          Vector.empty
+        case ("textDocument/publishDiagnostics", Some(json)) =>
+          import sbt.internal.langserver.codec.JsonProtocol._
+          Converter.fromJson[PublishDiagnosticsParams](json) match {
+            case Success(params) => splitDiagnostics(params); Vector()
+            case Failure(_)      => Vector()
+          }
+        case (`Shutdown`, Some(_))                => Vector.empty
+        case (msg, _) if msg.startsWith("build/") => Vector.empty
+        case _ =>
+          Vector(
+            (
+              Level.Warn,
+              s"unknown event: ${msg.method} " + Serialization.compactPrintJsonOpt(msg.params)
+            )
+          )
+      }
+    splitToMessage foreach {
+      case (level, msg) => console.appendLog(level, msg)
+    }
+  }
+
+  def splitLogMessage(params: LogMessageParams): Vector[(Level.Value, String)] = {
+    val level = messageTypeToLevel(params.`type`)
+    if (level == Level.Debug) Vector()
+    else Vector((level, params.message))
+  }
+
+  def messageTypeToLevel(severity: Long): Level.Value = {
+    severity match {
+      case MessageType.Error   => Level.Error
+      case MessageType.Warning => Level.Warn
+      case MessageType.Info    => Level.Info
+      case MessageType.Log     => Level.Debug
+    }
+  }
+
+  def splitDiagnostics(params: PublishDiagnosticsParams): Vector[(Level.Value, String)] = {
+    val uri = new URI(params.uri)
+    val f = IO.toFile(uri)
+
+    params.diagnostics map { d =>
+      val level = d.severity match {
+        case Some(severity) => messageTypeToLevel(severity)
+        case _              => Level.Error
+      }
+      val line = d.range.start.line + 1
+      val offset = d.range.start.character + 1
+      val msg = s"$f:$line:$offset: ${d.message}"
+      (level, msg)
+    }
+  }
+
+  def onRequest(msg: JsonRpcRequestMessage): Unit = {
+    import sbt.protocol.codec.JsonProtocol._
+    (msg.method, msg.params) match {
+      case (`terminalCapabilities`, Some(json)) =>
+        Converter.fromJson[TerminalCapabilitiesQuery](json) match {
+          case Success(terminalCapabilitiesQuery) =>
+            val response = TerminalCapabilitiesResponse(
+              terminalCapabilitiesQuery.boolean
+                .map(Terminal.console.getBooleanCapability(_)),
+              terminalCapabilitiesQuery.numeric
+                .map(c => Option(Terminal.console.getNumericCapability(c)).fold(-1)(_.toInt)),
+              terminalCapabilitiesQuery.string
+                .map(s => Option(Terminal.console.getStringCapability(s)).getOrElse("null")),
+            )
+            sendCommandResponse(
+              terminalCapabilitiesResponse,
+              response,
+              msg.id,
+            )
+          case Failure(_) =>
+        }
+      case (`terminalPropertiesQuery`, _) =>
+        val response = TerminalPropertiesResponse.apply(
+          width = Terminal.console.getWidth,
+          height = Terminal.console.getHeight,
+          isAnsiSupported = Terminal.console.isAnsiSupported,
+          isColorEnabled = Terminal.console.isColorEnabled,
+          isSupershellEnabled = Terminal.console.isSupershellEnabled,
+          isEchoEnabled = Terminal.console.isEchoEnabled
+        )
+        sendCommandResponse(terminalPropertiesResponse, response, msg.id)
+      case (`setTerminalAttributes`, Some(json)) =>
+        Converter.fromJson[TerminalSetAttributesCommand](json) match {
+          case Success(attributes) =>
+            val attrs = Map(
+              "iflag" -> attributes.iflag,
+              "oflag" -> attributes.oflag,
+              "cflag" -> attributes.cflag,
+              "lflag" -> attributes.lflag,
+              "cchars" -> attributes.cchars,
+            )
+            Terminal.console.setAttributes(attrs)
+            sendCommandResponse("", TerminalSetAttributesResponse(), msg.id)
+          case Failure(_) =>
+        }
+      case (`getTerminalAttributes`, _) =>
+        val attrs = Terminal.console.getAttributes
+        val response = TerminalAttributesResponse(
+          iflag = attrs.getOrElse("iflag", ""),
+          oflag = attrs.getOrElse("oflag", ""),
+          cflag = attrs.getOrElse("cflag", ""),
+          lflag = attrs.getOrElse("lflag", ""),
+          cchars = attrs.getOrElse("cchars", ""),
+        )
+        sendCommandResponse("", response, msg.id)
+      case (`terminalGetSize`, _) =>
+        val response = TerminalGetSizeResponse(
+          Terminal.console.getWidth,
+          Terminal.console.getHeight,
+        )
+        sendCommandResponse("", response, msg.id)
+      case (`terminalSetSize`, Some(json)) =>
+        Converter.fromJson[TerminalSetSizeCommand](json) match {
+          case Success(size) =>
+            Terminal.console.setSize(size.width, size.height)
+            sendCommandResponse("", TerminalSetSizeResponse(), msg.id)
+          case Failure(_) =>
+        }
+      case (`terminalSetEcho`, Some(json)) =>
+        Converter.fromJson[TerminalSetEchoCommand](json) match {
+          case Success(echo) =>
+            Terminal.console.setEchoEnabled(echo.toggle)
+            sendCommandResponse("", TerminalSetEchoResponse(), msg.id)
+          case Failure(_) =>
+        }
+      case (`terminalSetRawMode`, Some(json)) =>
+        Converter.fromJson[TerminalSetRawModeCommand](json) match {
+          case Success(raw) =>
+            if (raw.toggle) Terminal.console.enterRawMode()
+            else Terminal.console.exitRawMode()
+            sendCommandResponse("", TerminalSetRawModeResponse(), msg.id)
+          case Failure(_) =>
+        }
+      case _ =>
+    }
+  }
+
+  def connect(log: Boolean, promptCompleteUsers: Boolean): Boolean = {
+    if (log) console.appendLog(Level.Info, "entering *experimental* thin client - BEEP WHIRR")
+    try {
+      init(promptCompleteUsers, retry = true)
+      true
+    } catch {
+      case _: ServerFailedException =>
+        console.appendLog(Level.Error, "failed to connect to server")
+        false
+    }
+  }
+
+  private[this] val contHandler: () => Unit = () => {
+    if (Terminal.console.getLastLine.nonEmpty)
+      printStream.print(ConsoleAppender.DeleteLine + Terminal.console.getLastLine.get)
+  }
+  private[this] def withSignalHandler[R](handler: () => Unit, sig: String)(f: => R): R = {
+    val registration = Signals.register(handler, sig)
+    try f
+    finally registration.remove()
+  }
+  private[this] val cancelled = new AtomicBoolean(false)
+
+  def run(): Int =
+    withSignalHandler(contHandler, Signals.CONT) {
+      interactiveThread.set(Thread.currentThread)
+      val cleaned = arguments.commandArguments
+      val userCommands = cleaned.takeWhile(_ != TerminateAction)
+      val interactive = cleaned.isEmpty
+      val exit = cleaned.nonEmpty && userCommands.isEmpty
+      attachUUID.set(sendJson(attach, s"""{"interactive": $interactive}"""))
+      val handler: () => Unit = () => {
+        def exitAbruptly() = {
+          exitClean.set(false)
+          close()
+        }
+        if (cancelled.compareAndSet(false, true)) {
+          val cancelledTasks = {
+            val queue = sendCancelAllCommand()
+            Option(queue.poll(1, TimeUnit.SECONDS)).getOrElse(true)
+          }
+          if ((batchMode.get && pendingResults.isEmpty) || !cancelledTasks) exitAbruptly()
+          else cancelled.set(false)
+        } else exitAbruptly() // handles double ctrl+c to force a shutdown
+      }
+      withSignalHandler(handler, Signals.INT) {
+        def block(): Int = {
+          try this.synchronized(this.wait)
+          catch { case _: InterruptedException => }
+          if (exitClean.get) 0 else 1
+        }
+        console.appendLog(Level.Info, "terminate the server with `shutdown`")
+        if (interactive) {
+          console.appendLog(Level.Info, "disconnect from the server with `exit`")
+          block()
+        } else if (exit) 0
+        else {
+          batchMode.set(true)
+          val res = batchExecute(userCommands.toList)
+          if (!batchMode.get) block() else res
+        }
+      }
+    }
+
+  def batchExecute(userCommands: List[String]): Int = {
+    val cmd = userCommands mkString " "
+    printStream.println("> " + cmd)
+    sendAndWait(cmd, None)
+  }
+
+  def getCompletions(query: String): Seq[String] = {
+    val quoteCount = query.foldLeft(0) {
+      case (count, '"') => count + 1
+      case (count, _)   => count
+    }
+    val inQuote = quoteCount % 2 != 0
+    val (rawPrefix, prefix, rawSuffix, suffix) = if (quoteCount > 0) {
+      query.lastIndexOf('"') match {
+        case -1 => (query, query, None, None) // shouldn't happen
+        case i =>
+          val rawPrefix = query.substring(0, i)
+          val prefix = rawPrefix.replaceAllLiterally("\"", "").replaceAllLiterally("\\;", ";")
+          val rawSuffix = query.substring(i).replaceAllLiterally("\\;", ";")
+          val suffix = if (rawSuffix.length > 1) rawSuffix.substring(1) else ""
+          (rawPrefix, prefix, Some(rawSuffix), Some(suffix))
+      }
+    } else (query, query.replaceAllLiterally("\\;", ";"), None, None)
+    val tailSpace = query.endsWith(" ") || query.endsWith("\"")
+    val sanitizedQuery = suffix.foldLeft(prefix) { _ + _ }
+    def getCompletions(query: String, sendCommand: Boolean): Seq[String] = {
+      val result = new LinkedBlockingQueue[CompletionResponse]()
+      val json = s"""{"query":"$query","level":1}"""
+      val execId = sendJson("sbt/completion", json)
+      pendingCompletions.put(execId, result.put)
+      val response = result.poll(30, TimeUnit.SECONDS) match {
+        case null => throw new TimeoutException("no response from server within 30 seconds")
+        case r    => r
+      }
+      def fillCompletions(label: String, regex: String, command: String): Seq[String] = {
+        def updateCompletions(): Seq[String] = {
+          errorStream.println()
+          sendJson(attach, s"""{"interactive": false}""")
+          sendAndWait(query.replaceAll(regex + ".*", command).trim, None)
+          getCompletions(query, false)
+        }
+        if (noStdErr) Nil
+        else if (noTab) updateCompletions()
+        else {
+          errorStream.print(s"\nNo cached $label names found. Press '<tab>' to compile: ")
+          startInputThread()
+          stdinBytes.poll(5, TimeUnit.SECONDS) match {
+            case null        => Nil
+            case i if i == 9 => updateCompletions()
+            case _           => Nil
+          }
+        }
+      }
+      val testNameCompletions =
+        if (!response.cachedTestNames.getOrElse(true) && sendCommand)
+          fillCompletions("test", "test(Only|Quick)", "definedTestNames")
+        else Nil
+      val classNameCompletions =
+        if (!response.cachedMainClassNames.getOrElse(true) && sendCommand)
+          fillCompletions("main class", "runMain", "discoveredMainClasses")
+        else Nil
+      val completions = response.items
+      testNameCompletions ++ classNameCompletions ++ completions
+    }
+    getCompletions(sanitizedQuery, true) collect {
+      case c if inQuote                      => c
+      case c if tailSpace && c.contains(" ") => c.replaceAllLiterally(prefix, "")
+      case c if !tailSpace                   => c.split(" ").last
+    }
+  }
+
+  private def sendAndWait(cmd: String, limit: Option[Deadline]): Int = {
+    val queue = sendExecCommand(cmd)
+    var result: Integer = null
+    while (running.get && result == null && limit.fold(true)(!_.isOverdue())) {
+      try {
+        result = limit match {
+          case Some(l) => queue.poll((l - Deadline.now).toMillis, TimeUnit.MILLISECONDS)
+          case _       => queue.take
+        }
+      } catch {
+        case _: InterruptedException if cmd == Shutdown => result = 0
+        case _: InterruptedException                    => result = if (exitClean.get) 0 else 1
+      }
+    }
+    if (result == null) 1 else result
+  }
+
+  def sendExecCommand(commandLine: String): LinkedBlockingQueue[Integer] = {
+    val execId = UUID.randomUUID.toString
+    val queue = new LinkedBlockingQueue[Integer]
+    sendCommand(ExecCommand(commandLine, execId))
+    pendingResults.put(execId, (queue, System.currentTimeMillis, commandLine))
+    queue
+  }
+
+  def sendCancelAllCommand(): LinkedBlockingQueue[Boolean] = {
+    val queue = new LinkedBlockingQueue[Boolean]
+    val execId = sendJson(cancelRequest, s"""{"id":"$CancelAll"}""")
+    pendingCancellations.put(execId, queue)
+    queue
+  }
+
+  def sendCommand(command: CommandMessage): Unit = {
+    try {
+      val s = Serialization.serializeCommandAsJsonMessage(command)
+      connection.sendString(s)
+      lock.synchronized {
+        status.set("Processing")
+      }
+    } catch {
+      case e: SocketException if command.toString.contains("exit") => running.set(false)
+      case e: IOException =>
+        errorStream.println(s"Caught exception writing command to server: $e")
+        running.set(false)
+    }
+  }
+  def sendCommandResponse(method: String, command: EventMessage, id: String): Unit = {
+    try {
+      val s = new String(Serialization.serializeEventMessage(command))
+      val msg = s"""{ "jsonrpc": "2.0", "id": "$id", "result": $s }"""
+      connection.sendString(msg)
+    } catch {
+      case e: IOException =>
+        errorStream.println(s"Caught exception writing command to server: $e")
+        running.set(false)
+    }
+  }
+  def sendJson(method: String, params: String): String = {
+    val uuid = UUID.randomUUID.toString
+    sendJson(method, params, uuid)
+    uuid
+  }
+  def sendJson(method: String, params: String, uuid: String): Unit = {
+    val msg = s"""{ "jsonrpc": "2.0", "id": "$uuid", "method": "$method", "params": $params }"""
+    connection.sendString(msg)
+  }
+
+  def sendNotification(method: String, params: String): Unit = {
+    connection.sendString(s"""{ "jsonrpc": "2.0", "method": "$method", "params": $params }""")
+  }
+
+  override def close(): Unit =
+    try {
+      running.set(false)
+      stdinBytes.offer(-1)
+      val mainThread = interactiveThread.getAndSet(null)
+      if (mainThread != null && mainThread != Thread.currentThread) mainThread.interrupt
+      connectionHolder.get match {
+        case null =>
+        case c =>
+          try sendExecCommand("exit")
+          finally c.shutdown()
+      }
+      Option(inputThread.get).foreach(_.interrupt())
+    } catch {
+      case t: Throwable => t.printStackTrace(); throw t
+    }
+
+  private[this] class RawInputThread extends Thread("sbt-read-input-thread") with AutoCloseable {
+    setDaemon(true)
+    start()
+    val stopped = new AtomicBoolean(false)
+    override final def run(): Unit = {
+      def read(): Unit = {
+        val b = inputStream.read
+        inLock.synchronized(stdinBytes.offer(b))
+        if (attached.get()) drain()
+      }
+      try read()
+      catch { case _: InterruptedException | NonFatal(_) => stopped.set(true) } finally {
+        inputThread.set(null)
+      }
+    }
+
+    def drain(): Unit = inLock.synchronized {
+      while (!stdinBytes.isEmpty) {
+        val byte = stdinBytes.poll()
+        sendNotification(systemIn, byte.toString)
+      }
+    }
+
+    override def close(): Unit = {
+      RawInputThread.this.interrupt()
+    }
+  }
+
+  // copied from Aggregation
+  private def timing(startTime: Long, endTime: Long): String = {
+    import java.text.DateFormat
+    val format = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM)
+    val nowString = format.format(new java.util.Date(endTime))
+    val total = math.max(0, (endTime - startTime + 500) / 1000)
+    val totalString = s"$total s" +
+      (if (total <= 60) ""
+       else {
+         val maybeHours = total / 3600 match {
+           case 0 => ""
+           case h => f"$h%02d:"
+         }
+         val mins = f"${total % 3600 / 60}%02d"
+         val secs = f"${total % 60}%02d"
+         s" ($maybeHours$mins:$secs)"
+       })
+    s"Total time: $totalString, completed $nowString"
+  }
+}
+
+object NetworkClient {
+  private[sbt] val CancelAll = "__CancelAll"
+  private def consoleAppenderInterface(printStream: PrintStream): ConsoleInterface = {
+    val appender = ConsoleAppender("thin", ConsoleOut.printStreamOut(printStream))
+    new ConsoleInterface {
+      override def appendLog(level: Level.Value, message: => String): Unit =
+        appender.appendLog(level, message)
+      override def success(msg: String): Unit = appender.success(msg)
+    }
+  }
+  private def simpleConsoleInterface(doPrintln: String => Unit): ConsoleInterface =
+    new ConsoleInterface {
+      import scala.Console.{ GREEN, RED, RESET, YELLOW }
+      override def appendLog(level: Level.Value, message: => String): Unit = synchronized {
+        val prefix = level match {
+          case Level.Error => s"[$RED$level$RESET]"
+          case Level.Warn  => s"[$YELLOW$level$RESET]"
+          case _           => s"[$RESET$level$RESET]"
+        }
+        message.linesIterator.foreach(line => doPrintln(s"$prefix $line"))
+      }
+      override def success(msg: String): Unit = doPrintln(s"[${GREEN}success$RESET] $msg")
+    }
+  private[client] class Arguments(
+      val baseDirectory: File,
+      val sbtArguments: Seq[String],
+      val commandArguments: Seq[String],
+      val completionArguments: Seq[String],
+      val sbtScript: String,
+      val bsp: Boolean,
+      val sbtLaunchJar: Option[String],
+  ) {
+    def withBaseDirectory(file: File): Arguments =
+      new Arguments(
+        file,
+        sbtArguments,
+        commandArguments,
+        completionArguments,
+        sbtScript,
+        bsp,
+        sbtLaunchJar
+      )
+  }
+  private[client] val completions = "--completions"
+  private[client] val noTab = "--no-tab"
+  private[client] val noStdErr = "--no-stderr"
+  private[client] val sbtBase = "--sbt-base-directory"
+  private[client] def parseArgs(args: Array[String]): Arguments = {
+    var sbtScript = if (Properties.isWin) "sbt.bat" else "sbt"
+    var launchJar: Option[String] = None
+    var bsp = false
+    val commandArgs = new mutable.ArrayBuffer[String]
+    val sbtArguments = new mutable.ArrayBuffer[String]
+    val completionArguments = new mutable.ArrayBuffer[String]
+    val SysProp = "-D([^=]+)=(.*)".r
+    val sanitized = args.flatMap {
+      case a if a.startsWith("\"") => Array(a)
+      case a                       => a.split(" ")
+    }
+    var i = 0
+    while (i < sanitized.length) {
+      sanitized(i) match {
+        case a if completionArguments.nonEmpty => completionArguments += a
+        case a if commandArgs.nonEmpty         => commandArgs += a
+        case a if a == noStdErr || a == noTab || a.startsWith(completions) =>
+          completionArguments += a
+        case a if a.startsWith("--sbt-script=") =>
+          sbtScript = a
+            .split("--sbt-script=")
+            .lastOption
+            .map(_.replaceAllLiterally("%20", " "))
+            .getOrElse(sbtScript)
+        case "--sbt-script" if i + 1 < sanitized.length =>
+          i += 1
+          sbtScript = sanitized(i).replaceAllLiterally("%20", " ")
+        case a if a.startsWith("--sbt-launch-jar=") =>
+          launchJar = a
+            .split("--sbt-launch-jar=")
+            .lastOption
+            .map(_.replaceAllLiterally("%20", " "))
+        case "--sbt-launch-jar" if i + 1 < sanitized.length =>
+          i += 1
+          launchJar = Option(sanitized(i).replaceAllLiterally("%20", " "))
+        case "-bsp" | "--bsp"        => bsp = true
+        case a if !a.startsWith("-") => commandArgs += a
+        case a @ SysProp(key, value) =>
+          System.setProperty(key, value)
+          sbtArguments += a
+        case a => sbtArguments += a
+      }
+      i += 1
+    }
+    val base = new File("").getCanonicalFile
+    if (!sbtArguments.contains("-Dsbt.io.virtual=true")) sbtArguments += "-Dsbt.io.virtual=true"
+    new Arguments(
+      base,
+      sbtArguments.toSeq,
+      commandArgs.toSeq,
+      completionArguments.toSeq,
+      sbtScript,
+      bsp,
+      launchJar
+    )
+  }
+
+  def client(
+      baseDirectory: File,
+      args: Array[String],
+      inputStream: InputStream,
+      printStream: PrintStream,
+      errorStream: PrintStream,
+      useJNI: Boolean
+  ): Int = {
+    val client =
+      simpleClient(
+        NetworkClient.parseArgs(args).withBaseDirectory(baseDirectory),
+        inputStream,
+        printStream,
+        errorStream,
+        useJNI,
+      )
+    try {
+      if (client.connect(log = true, promptCompleteUsers = false)) client.run()
+      else 1
+    } catch { case _: Exception => 1 } finally client.close()
+  }
+  def client(
+      baseDirectory: File,
+      args: Arguments,
+      inputStream: InputStream,
+      errorStream: PrintStream,
+      terminal: Terminal,
+      useJNI: Boolean
+  ): Int = {
+    val printStream = if (args.bsp) errorStream else terminal.printStream
+    val client =
+      simpleClient(
+        args.withBaseDirectory(baseDirectory),
+        inputStream,
+        printStream,
+        errorStream,
+        useJNI,
+      )
+    clientImpl(client, args.bsp)
+  }
+  private def clientImpl(client: NetworkClient, isBsp: Boolean): Int = {
+    try {
+      if (isBsp) {
+        val (socket, _) =
+          client.connectOrStartServerAndConnect(promptCompleteUsers = false, retry = true)
+        BspClient.bspRun(socket)
+      } else {
+        if (client.connect(log = true, promptCompleteUsers = false)) client.run()
+        else 1
+      }
+    } catch { case _: Exception => 1 } finally client.close()
+  }
+  def client(
+      baseDirectory: File,
+      args: Array[String],
+      inputStream: InputStream,
+      errorStream: PrintStream,
+      terminal: Terminal,
+      useJNI: Boolean
+  ): Int = client(baseDirectory, parseArgs(args), inputStream, errorStream, terminal, useJNI)
+
+  private def simpleClient(
+      arguments: Arguments,
+      inputStream: InputStream,
+      errorStream: PrintStream,
+      useJNI: Boolean,
+      terminal: Terminal
+  ): NetworkClient = {
+    val doPrint: String => Unit = line => {
+      if (terminal.getLastLine.isDefined) terminal.printStream.println()
+      terminal.printStream.println(line)
+    }
+    val interface = NetworkClient.simpleConsoleInterface(doPrint)
+    val printStream = terminal.printStream
+    new NetworkClient(arguments, interface, inputStream, errorStream, printStream, useJNI)
+  }
+  private def simpleClient(
+      arguments: Arguments,
+      inputStream: InputStream,
+      printStream: PrintStream,
+      errorStream: PrintStream,
+      useJNI: Boolean,
+  ): NetworkClient = {
+    val interface = NetworkClient.simpleConsoleInterface(printStream.println)
+    new NetworkClient(arguments, interface, inputStream, errorStream, printStream, useJNI)
+  }
+  def main(args: Array[String]): Unit = {
+    val (jnaArg, restOfArgs) = args.partition(_ == "--jna")
+    val useJNI = jnaArg.isEmpty
+    val base = new File("").getCanonicalFile
+    if (restOfArgs.exists(_.startsWith(NetworkClient.completions)))
+      System.exit(complete(base, restOfArgs, useJNI, System.in, System.out))
+    else {
+      val hook = new Thread(() => {
+        System.out.print(ConsoleAppender.ClearScreenAfterCursor)
+        System.out.flush()
+      })
+      Runtime.getRuntime.addShutdownHook(hook)
+      if (Util.isNonCygwinWindows) sbt.internal.util.JLine3.forceWindowsJansi()
+      val parsed = parseArgs(restOfArgs)
+      System.exit(Terminal.withStreams(isServer = false, isSubProcess = false) {
+        val term = Terminal.console
+        try client(base, parsed, term.inputStream, System.err, term, useJNI)
+        catch { case _: AccessDeniedException => 1 } finally {
+          Runtime.getRuntime.removeShutdownHook(hook)
+          hook.run()
+        }
+      })
+    }
+  }
+  def complete(
+      baseDirectory: File,
+      args: Array[String],
+      useJNI: Boolean,
+      in: InputStream,
+      out: PrintStream
+  ): Int = {
+    val cmd: String = args.find(_.startsWith(NetworkClient.completions)) match {
+      case Some(c) =>
+        c.split('=').lastOption match {
+          case Some(query) =>
+            query.indexOf(" ") match {
+              case -1 => throw new IllegalArgumentException(query)
+              case i  => query.substring(i + 1)
+            }
+          case _ => throw new IllegalArgumentException(c)
+        }
+      case _ => throw new IllegalStateException("should be unreachable")
+    }
+    val quiet = args.exists(_ == "--quiet")
+    val errorStream = if (quiet) new PrintStream(_ => {}, false) else System.err
+    val sbtArgs = args.takeWhile(!_.startsWith(NetworkClient.completions))
+    val arguments = NetworkClient.parseArgs(sbtArgs)
+    val noTab = args.contains("--no-tab")
+    try {
+      val client =
+        simpleClient(
+          arguments.withBaseDirectory(baseDirectory),
+          inputStream = in,
+          errorStream = errorStream,
+          printStream = errorStream,
+          useJNI = useJNI,
+        )
+      try {
+        val results =
+          if (client.connect(log = false, promptCompleteUsers = true)) client.getCompletions(cmd)
+          else Nil
+        out.println(results.sorted.distinct mkString "\n")
+        0
+      } catch { case _: Exception => 1 } finally client.close()
+    } catch { case _: AccessDeniedException => 1 }
+  }
+
+  def run(configuration: xsbti.AppConfiguration, arguments: List[String]): Int =
+    run(configuration, arguments, false)
+  def run(
+      configuration: xsbti.AppConfiguration,
+      arguments: List[String],
+      redirectOutput: Boolean
+  ): Int = {
+    val term = Terminal.console
+    val err = new PrintStream(term.errorStream)
+    val out = if (redirectOutput) err else new PrintStream(term.outputStream)
+    val args = parseArgs(arguments.toArray).withBaseDirectory(configuration.baseDirectory)
+    val useJNI = BootServerSocket.requiresJNI || System.getProperty("sbt.ipcsocket.jni", "false") == "true"
+    val client = simpleClient(args, term.inputStream, out, err, useJNI = useJNI)
+    clientImpl(client, args.bsp)
+  }
+  private class AccessDeniedException extends Throwable
+}
diff --git a/main-command/src/main/scala/sbt/internal/client/ServerConnection.scala b/main-command/src/main/scala/sbt/internal/client/ServerConnection.scala
new file mode 100644
index 000000000..23e8837af
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/client/ServerConnection.scala
@@ -0,0 +1,106 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package client
+
+import java.io.IOException
+import java.net.{ Socket, SocketTimeoutException }
+import java.util.concurrent.atomic.AtomicBoolean
+
+import sbt.protocol._
+import sbt.internal.protocol._
+import sbt.internal.util.ReadJsonFromInputStream
+
+abstract class ServerConnection(connection: Socket) {
+
+  private val running = new AtomicBoolean(true)
+  private val closed = new AtomicBoolean(false)
+  private val retByte: Byte = '\r'.toByte
+  private val delimiter: Byte = '\n'.toByte
+
+  private val out = connection.getOutputStream
+
+  val thread = new Thread(s"sbt-serverconnection-${connection.getPort}") {
+    setDaemon(true)
+    override def run(): Unit = {
+      try {
+        val in = connection.getInputStream
+        connection.setSoTimeout(5000)
+        while (running.get) {
+          try {
+            val frame = ReadJsonFromInputStream(in, running, None)
+            if (running.get) {
+              Serialization
+                .deserializeJsonMessage(frame)
+                .fold(
+                  { errorDesc =>
+                    val s = frame.mkString("") // new String(: Array[Byte], "UTF-8")
+                    println(s"Got invalid chunk from server: $s \n" + errorDesc)
+                  },
+                  _ match {
+                    case msg: JsonRpcRequestMessage      => onRequest(msg)
+                    case msg: JsonRpcResponseMessage     => onResponse(msg)
+                    case msg: JsonRpcNotificationMessage => onNotification(msg)
+                  }
+                )
+            }
+          } catch {
+            case _: SocketTimeoutException => // its ok
+            case e: IOException            => running.set(false)
+          }
+        }
+      } finally {
+        shutdown()
+      }
+    }
+  }
+  thread.start()
+
+  def sendString(message: String): Unit = this.synchronized {
+    val a = message.getBytes("UTF-8")
+    writeLine(s"""Content-Length: ${a.length + 2}""".getBytes("UTF-8"))
+    writeLine(Array())
+    writeLine(a)
+  }
+
+  def writeLine(a: Array[Byte]): Unit =
+    try {
+      def writeEndLine(): Unit = {
+        out.write(retByte.toInt)
+        out.write(delimiter.toInt)
+        out.flush
+      }
+      if (a.nonEmpty) {
+        out.write(a)
+      }
+      writeEndLine
+    } catch {
+      case e: IOException =>
+        shutdown()
+        throw e
+    }
+
+  def onRequest(msg: JsonRpcRequestMessage): Unit
+  def onResponse(msg: JsonRpcResponseMessage): Unit
+  def onNotification(msg: JsonRpcNotificationMessage): Unit
+
+  def onShutdown(): Unit
+
+  def shutdown(): Unit = if (closed.compareAndSet(false, true)) {
+    if (!running.compareAndSet(true, false)) {
+      System.err.println("\nsbt server connection closed.")
+    }
+    try {
+      out.close()
+      connection.close()
+    } catch { case e: IOException => e.printStackTrace() }
+    onShutdown
+  }
+
+}
diff --git a/main-command/src/main/scala/sbt/internal/server/ClientConnection.scala b/main-command/src/main/scala/sbt/internal/server/ClientConnection.scala
deleted file mode 100644
index 26b8188fb..000000000
--- a/main-command/src/main/scala/sbt/internal/server/ClientConnection.scala
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2016 Lightbend Inc. <http://www.typesafe.com>
- */
-package sbt
-package internal
-package server
-
-import java.net.{ SocketTimeoutException, Socket }
-import java.util.concurrent.atomic.AtomicBoolean
-
-abstract class ClientConnection(connection: Socket) {
-
-  private val running = new AtomicBoolean(true)
-  private val delimiter: Byte = '\n'.toByte
-
-  private val out = connection.getOutputStream
-
-  val thread = new Thread(s"sbt-client-${connection.getPort}") {
-    override def run(): Unit = {
-      try {
-        val readBuffer = new Array[Byte](4096)
-        val in = connection.getInputStream
-        connection.setSoTimeout(5000)
-        var buffer: Vector[Byte] = Vector.empty
-        var bytesRead = 0
-        while (bytesRead != -1 && running.get) {
-          try {
-            bytesRead = in.read(readBuffer)
-            val bytes = readBuffer.toVector.take(bytesRead)
-            buffer = buffer ++ bytes
-
-            // handle un-framing
-            val delimPos = bytes.indexOf(delimiter)
-            if (delimPos > 0) {
-              val chunk = buffer.take(delimPos)
-              buffer = buffer.drop(delimPos + 1)
-
-              Serialization.deserialize(chunk).fold(
-                errorDesc => println("Got invalid chunk from client: " + errorDesc),
-                onCommand
-              )
-            }
-
-          } catch {
-            case _: SocketTimeoutException => // its ok
-          }
-        }
-
-      } finally {
-        shutdown()
-      }
-    }
-  }
-  thread.start()
-
-  def publish(event: Array[Byte]): Unit = {
-    out.write(event)
-    out.write(delimiter)
-    out.flush()
-  }
-
-  def onCommand(command: Command): Unit
-
-  def shutdown(): Unit = {
-    println("Shutting down client connection")
-    running.set(false)
-    out.close()
-  }
-
-}
diff --git a/main-command/src/main/scala/sbt/internal/server/Serialization.scala b/main-command/src/main/scala/sbt/internal/server/Serialization.scala
deleted file mode 100644
index 99142383f..000000000
--- a/main-command/src/main/scala/sbt/internal/server/Serialization.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2016 Lightbend Inc. <http://www.typesafe.com>
- */
-package sbt
-package internal
-package server
-
-import sjsonnew.{ JsonFormat, BasicJsonProtocol }
-import sjsonnew.support.scalajson.unsafe.{ Converter, CompactPrinter }
-import scala.json.ast.unsafe.JValue
-import sjsonnew.support.scalajson.unsafe.Parser
-import java.nio.ByteBuffer
-import scala.util.{ Success, Failure }
-
-object Serialization {
-
-  def serialize(event: Event): Array[Byte] =
-    {
-      import ServerCodec._
-      val msg = toMessage(event)
-      val json: JValue = Converter.toJson[EventMessage](msg).get
-      CompactPrinter(json).getBytes("UTF-8")
-    }
-  def toMessage(event: Event): EventMessage =
-    event match {
-      case LogEvent(level, message) =>
-        EventMessage(`type` = "logEvent",
-          status = None, commandQueue = Vector(),
-          level = Some(level), message = Some(message), success = None, commandLine = None)
-      case StatusEvent(Ready) =>
-        EventMessage(`type` = "statusEvent",
-          status = Some("ready"), commandQueue = Vector(),
-          level = None, message = None, success = None, commandLine = None)
-      case StatusEvent(Processing(command, commandQueue)) =>
-        EventMessage(`type` = "statusEvent",
-          status = Some("processing"), commandQueue = commandQueue.toVector,
-          level = None, message = None, success = None, commandLine = None)
-      case ExecutionEvent(command, status) =>
-        EventMessage(`type` = "executionEvent",
-          status = None, commandQueue = Vector(),
-          level = None, message = None, success = Some(status), commandLine = Some(command))
-    }
-
-  /**
-   * @return A command or an invalid input description
-   */
-  def deserialize(bytes: Seq[Byte]): Either[String, Command] =
-    {
-      val buffer = ByteBuffer.wrap(bytes.toArray)
-      Parser.parseFromByteBuffer(buffer) match {
-        case Success(json) =>
-          import ServerCodec._
-          Converter.fromJson[CommandMessage](json) match {
-            case Success(command) =>
-              command.`type` match {
-                case "exec" =>
-                  command.commandLine match {
-                    case Some(cmd) => Right(Execution(cmd))
-                    case None      => Left("Missing or invalid command_line field")
-                  }
-                case cmd => Left(s"Unknown command type $cmd")
-              }
-            case Failure(e) => Left(e.getMessage)
-          }
-        case Failure(e) =>
-          Left(s"Parse error: ${e.getMessage}")
-      }
-    }
-}
-
-object ServerCodec extends ServerCodec
-trait ServerCodec extends codec.EventMessageFormats with codec.CommandMessageFormats with BasicJsonProtocol
diff --git a/main-command/src/main/scala/sbt/internal/server/Server.scala b/main-command/src/main/scala/sbt/internal/server/Server.scala
index f102cb736..6baf8bc1a 100644
--- a/main-command/src/main/scala/sbt/internal/server/Server.scala
+++ b/main-command/src/main/scala/sbt/internal/server/Server.scala
@@ -1,82 +1,259 @@
 /*
- * Copyright (C) 2016 Lightbend Inc. <http://www.typesafe.com>
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 package server
 
-import java.net.{ SocketTimeoutException, InetAddress, ServerSocket, SocketException }
-import java.util.concurrent.atomic.AtomicBoolean
+import java.io.{ File, IOException }
+import java.net.{ InetAddress, ServerSocket, Socket, SocketException, SocketTimeoutException }
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+import java.nio.file.attribute.{ AclEntry, AclEntryPermission, AclEntryType, UserPrincipal }
+import java.security.SecureRandom
+import java.math.BigInteger
+
+import scala.concurrent.{ Future, Promise }
+import scala.util.{ Failure, Success, Try }
+import sbt.internal.protocol.{ PortFile, TokenFile }
 import sbt.util.Logger
-import scala.collection.mutable
+import sbt.io.IO
+import sbt.io.syntax._
+import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Converter }
+import sbt.internal.protocol.codec._
+import sbt.internal.util.ErrorHandling
+import sbt.internal.util.Util.isWindows
+import org.scalasbt.ipcsocket._
+import sbt.internal.bsp.BuildServerConnection
+import xsbti.AppConfiguration
 
 private[sbt] sealed trait ServerInstance {
   def shutdown(): Unit
-  def publish(event: Event): Unit
+  def ready: Future[Unit]
+  def authenticate(challenge: String): Boolean
 }
 
 private[sbt] object Server {
-  def start(host: String, port: Int, onIncommingCommand: Command => Unit, log: Logger): ServerInstance =
-    new ServerInstance {
+  sealed trait JsonProtocol
+      extends sjsonnew.BasicJsonProtocol
+      with PortFileFormats
+      with TokenFileFormats
+  object JsonProtocol extends JsonProtocol
 
-      val lock = new AnyRef {}
-      val clients: mutable.ListBuffer[ClientConnection] = mutable.ListBuffer.empty
-      val running = new AtomicBoolean(true)
+  def start(
+      connection: ServerConnection,
+      onIncomingSocket: (Socket, ServerInstance) => Unit,
+      log: Logger
+  ): ServerInstance =
+    new ServerInstance { self =>
+      import connection._
+      val running = new AtomicBoolean(false)
+      val p: Promise[Unit] = Promise[Unit]()
+      val ready: Future[Unit] = p.future
+      private[this] val rand = new SecureRandom
+      private[this] var token: String = nextToken
+      private[this] val serverSocketHolder = new AtomicReference[ServerSocket]
 
       val serverThread = new Thread("sbt-socket-server") {
-
         override def run(): Unit = {
-          val serverSocket = new ServerSocket(port, 50, InetAddress.getByName(host))
-          serverSocket.setSoTimeout(5000)
-
-          log.info(s"sbt server started at $host:$port")
-          while (running.get()) {
-            try {
-              val socket = serverSocket.accept()
-              log.info(s"new client connected from: ${socket.getPort}")
-
-              val connection = new ClientConnection(socket) {
-                override def onCommand(command: Command): Unit = {
-                  onIncommingCommand(command)
+          Try {
+            connection.connectionType match {
+              case ConnectionType.Local if isWindows =>
+                // Named pipe already has an exclusive lock.
+                addServerError(
+                  new Win32NamedPipeServerSocket(
+                    pipeName,
+                    connection.useJni,
+                    connection.windowsServerSecurityLevel
+                  )
+                )
+              case ConnectionType.Local =>
+                val maxSocketLength =
+                  UnixDomainSocketLibraryProvider.maxSocketLength(connection.useJni) - 1
+                val path = socketfile.getAbsolutePath
+                if (path.length > maxSocketLength)
+                  sys.error(
+                    "socket file absolute path too long; " +
+                      "either switch to another connection type " +
+                      "or define a short \"SBT_GLOBAL_SERVER_DIR\" value. " +
+                      s"Current path: ${path}"
+                  )
+                tryClient(new UnixDomainSocket(path, connection.useJni))
+                prepareSocketfile()
+                addServerError(new UnixDomainServerSocket(path, connection.useJni))
+              case ConnectionType.Tcp =>
+                tryClient(new Socket(InetAddress.getByName(host), port))
+                addServerError(new ServerSocket(port, 50, InetAddress.getByName(host)))
+            }
+          } match {
+            case Failure(e) => p.failure(e)
+            case Success(serverSocket) =>
+              serverSocket.setSoTimeout(5000)
+              serverSocketHolder.getAndSet(serverSocket) match {
+                case null =>
+                case s    => s.close()
+              }
+              log.info(s"sbt server started at ${connection.shortName}")
+              writePortfile()
+              if (connection.bspEnabled) {
+                log.debug("Writing bsp connection file")
+                BuildServerConnection.writeConnectionFile(
+                  appConfiguration.provider.id.version,
+                  appConfiguration.baseDirectory
+                )
+              }
+              running.set(true)
+              p.success(())
+              while (running.get()) {
+                try {
+                  val socket = serverSocket.accept()
+                  onIncomingSocket(socket, self)
+                } catch {
+                  case e: IOException if e.getMessage.contains("connect") =>
+                  case _: SocketTimeoutException                          => // its ok
+                  case _: SocketException if !running.get                 => // the server is shutting down
                 }
               }
-
-              lock.synchronized {
-                clients += connection
+              serverSocketHolder.get match {
+                case null =>
+                case s    => s.close()
               }
-
-            } catch {
-              case _: SocketTimeoutException => // its ok
-            }
-
           }
         }
       }
       serverThread.start()
 
-      /** Publish an event to all connected clients */
-      def publish(event: Event): Unit = {
-        // TODO do not do this on the calling thread
-        val bytes = Serialization.serialize(event)
-        lock.synchronized {
-          val toDel: mutable.ListBuffer[ClientConnection] = mutable.ListBuffer.empty
-          clients.foreach { client =>
-            try {
-              client.publish(bytes)
-            } catch {
-              case e: SocketException =>
-                log.debug(e.getMessage)
-                toDel += client
-            }
+      // Try the socket as a client to make sure that the server is not already up.
+      // f tries to connect to the server, and flip the result.
+      def tryClient(f: => Socket): Unit = {
+        if (portfile.exists) {
+          Try { f } match {
+            case Failure(_) => ()
+            case Success(socket) =>
+              socket.close()
+              throw new AlreadyRunningException()
           }
-          clients --= toDel.toList
+        } else ()
+      }
+
+      def addServerError(f: => ServerSocket): ServerSocket =
+        ErrorHandling.translate(s"server failed to start on ${connection.shortName}. ") {
+          f
         }
+
+      override def authenticate(challenge: String): Boolean = synchronized {
+        if (token == challenge) {
+          token = nextToken
+          writeTokenfile()
+          true
+        } else false
+      }
+
+      /** Generates 128-bit non-negative integer, and represent it as decimal string. */
+      private[this] def nextToken: String = {
+        new BigInteger(128, rand).toString
       }
 
       override def shutdown(): Unit = {
-        log.info("shutting down server")
+        log.info("shutting down sbt server")
+        if (portfile.exists) {
+          IO.delete(portfile)
+        }
+        if (tokenfile.exists) {
+          IO.delete(tokenfile)
+        }
         running.set(false)
+        serverSocketHolder.getAndSet(null) match {
+          case null =>
+          case s    => s.close()
+        }
+      }
+
+      private[this] def writeTokenfile(): Unit = {
+        import JsonProtocol._
+
+        val uri = connection.shortName
+        val t = TokenFile(uri, token)
+        val jsonToken = Converter.toJson(t).get
+
+        if (tokenfile.exists) {
+          IO.delete(tokenfile)
+        }
+        IO.touch(tokenfile)
+        ownerOnly(tokenfile)
+        IO.write(tokenfile, CompactPrinter(jsonToken), IO.utf8, true)
+      }
+
+      /** Set the persmission of the file such that the only the owner can read/write it. */
+      private[this] def ownerOnly(file: File): Unit = {
+        def acl(owner: UserPrincipal) = {
+          val builder = AclEntry.newBuilder
+          builder.setPrincipal(owner)
+          builder.setPermissions(AclEntryPermission.values(): _*)
+          builder.setType(AclEntryType.ALLOW)
+          builder.build
+        }
+        file match {
+          case _ if IO.isPosix =>
+            IO.chmod("rw-------", file)
+          case _ if IO.hasAclFileAttributeView =>
+            val view = file.aclFileAttributeView
+            view.setAcl(java.util.Collections.singletonList(acl(view.getOwner)))
+          case _ => ()
+        }
+      }
+
+      // This file exists through the lifetime of the server.
+      private[this] def writePortfile(): Unit = {
+        import JsonProtocol._
+
+        val uri = connection.shortName
+        val p =
+          auth match {
+            case _ if auth(ServerAuthentication.Token) =>
+              writeTokenfile()
+              PortFile(uri, Option(tokenfile.toString), Option(IO.toURI(tokenfile).toString))
+            case _ =>
+              PortFile(uri, None, None)
+          }
+        val json = Converter.toJson(p).get
+        IO.write(portfile, CompactPrinter(json))
+      }
+
+      private[sbt] def prepareSocketfile(): Unit = {
+        if (socketfile.exists) {
+          IO.delete(socketfile)
+        }
+        IO.createDirectory(socketfile.getParentFile)
       }
     }
-
 }
+
+private[sbt] case class ServerConnection(
+    connectionType: ConnectionType,
+    host: String,
+    port: Int,
+    auth: Set[ServerAuthentication],
+    portfile: File,
+    tokenfile: File,
+    socketfile: File,
+    pipeName: String,
+    appConfiguration: AppConfiguration,
+    windowsServerSecurityLevel: Int,
+    useJni: Boolean,
+    bspEnabled: Boolean,
+) {
+  def shortName: String = {
+    connectionType match {
+      case ConnectionType.Local if isWindows => s"local:$pipeName"
+      case ConnectionType.Local              => s"local://$socketfile"
+      case ConnectionType.Tcp                => s"tcp://$host:$port"
+      // case ConnectionType.Ssh                => s"ssh://$host:$port"
+    }
+  }
+}
+
+private[sbt] class AlreadyRunningException extends IOException("sbt server is already running.")
diff --git a/main-command/src/main/scala/sbt/internal/server/ServerHandler.scala b/main-command/src/main/scala/sbt/internal/server/ServerHandler.scala
new file mode 100644
index 000000000..4cfbd9e3f
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/server/ServerHandler.scala
@@ -0,0 +1,84 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import sjsonnew.JsonFormat
+import sbt.internal.protocol._
+import sbt.util.Logger
+import sbt.protocol.{ CompletionParams => CP, SettingQuery => Q }
+import sbt.internal.langserver.{ CancelRequestParams => CRP }
+
+/**
+ * ServerHandler allows plugins to extend sbt server.
+ * It's a wrapper around curried function ServerCallback => JsonRpcRequestMessage => Unit.
+ */
+final class ServerHandler(val handler: ServerCallback => ServerIntent) {
+  override def toString: String = s"Serverhandler(...)"
+}
+
+object ServerHandler {
+  def apply(handler: ServerCallback => ServerIntent): ServerHandler =
+    new ServerHandler(handler)
+
+  lazy val fallback: ServerHandler = ServerHandler({ handler =>
+    ServerIntent(
+      onRequest = { case x  => handler.log.debug(s"Unhandled request received: ${x.method}: $x") },
+      onResponse = { case x => handler.log.debug(s"Unhandled responce received") },
+      onNotification = {
+        case x => handler.log.debug(s"Unhandled notification received: ${x.method}: $x")
+      },
+    )
+  })
+}
+
+final class ServerIntent(
+    val onRequest: PartialFunction[JsonRpcRequestMessage, Unit],
+    val onResponse: PartialFunction[JsonRpcResponseMessage, Unit],
+    val onNotification: PartialFunction[JsonRpcNotificationMessage, Unit]
+) {
+  override def toString: String = s"ServerIntent(...)"
+}
+
+object ServerIntent {
+  def apply(
+      onRequest: PartialFunction[JsonRpcRequestMessage, Unit],
+      onResponse: PartialFunction[JsonRpcResponseMessage, Unit],
+      onNotification: PartialFunction[JsonRpcNotificationMessage, Unit]
+  ): ServerIntent =
+    new ServerIntent(onRequest, onResponse, onNotification)
+
+  def request(onRequest: PartialFunction[JsonRpcRequestMessage, Unit]): ServerIntent =
+    new ServerIntent(onRequest, PartialFunction.empty, PartialFunction.empty)
+
+  def response(onResponse: PartialFunction[JsonRpcResponseMessage, Unit]): ServerIntent =
+    new ServerIntent(PartialFunction.empty, onResponse, PartialFunction.empty)
+  def notify(onNotification: PartialFunction[JsonRpcNotificationMessage, Unit]): ServerIntent =
+    new ServerIntent(PartialFunction.empty, PartialFunction.empty, onNotification)
+}
+
+/**
+ * Interface to invoke JSON-RPC response.
+ */
+trait ServerCallback {
+  def jsonRpcRespond[A: JsonFormat](event: A, execId: Option[String]): Unit
+  def jsonRpcRespondError(execId: Option[String], code: Long, message: String): Unit
+  def jsonRpcNotify[A: JsonFormat](method: String, params: A): Unit
+  def appendExec(exec: Exec): Boolean
+  def appendExec(commandLine: String, requestId: Option[String]): Boolean
+  def log: Logger
+  def name: String
+
+  private[sbt] def authOptions: Set[ServerAuthentication]
+  private[sbt] def authenticate(token: String): Boolean
+  private[sbt] def setInitialized(value: Boolean): Unit
+  private[sbt] def onSettingQuery(execId: Option[String], req: Q): Unit
+  private[sbt] def onCompletionRequest(execId: Option[String], cp: CP): Unit
+  private[sbt] def onCancellationRequest(execId: Option[String], crp: CRP): Unit
+}
diff --git a/main-command/src/main/scala/sbt/internal/server/protocol.scala b/main-command/src/main/scala/sbt/internal/server/protocol.scala
deleted file mode 100644
index 7c16b0fc3..000000000
--- a/main-command/src/main/scala/sbt/internal/server/protocol.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2016 Lightbend Inc. <http://www.typesafe.com>
- */
-package sbt
-package internal
-package server
-
-/*
- * These classes are the protocol for client-server interaction,
- * commands can come from the client side, while events are emitted
- * from sbt to inform the client of state changes etc.
- */
-private[sbt] sealed trait Event
-
-private[sbt] final case class LogEvent(level: String, message: String) extends Event
-
-sealed trait Status
-private[sbt] final case object Ready extends Status
-private[sbt] final case class Processing(command: String, commandQueue: Seq[String]) extends Status
-
-private[sbt] final case class StatusEvent(status: Status) extends Event
-private[sbt] final case class ExecutionEvent(command: String, success: Boolean) extends Event
-
-private[sbt] sealed trait Command
-
-private[sbt] final case class Execution(cmd: String) extends Command
diff --git a/main-command/src/main/scala/sbt/internal/ui/UITask.scala b/main-command/src/main/scala/sbt/internal/ui/UITask.scala
new file mode 100644
index 000000000..1ed500047
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/ui/UITask.scala
@@ -0,0 +1,117 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.ui
+
+import java.io.File
+import java.nio.channels.ClosedChannelException
+import java.util.concurrent.atomic.AtomicBoolean
+
+import sbt.BasicCommandStrings.{ Cancel, TerminateAction, Shutdown }
+import sbt.BasicKeys.{ historyPath, colorShellPrompt }
+import sbt.State
+import sbt.internal.CommandChannel
+import sbt.internal.util.ConsoleAppender.{ ClearPromptLine, ClearScreenAfterCursor, DeleteLine }
+import sbt.internal.util._
+import sbt.internal.util.complete.{ Parser }
+
+import scala.annotation.tailrec
+
+private[sbt] trait UITask extends Runnable with AutoCloseable {
+  private[sbt] val channel: CommandChannel
+  private[sbt] val reader: UITask.Reader
+  private[this] final def handleInput(s: Either[String, String]): Boolean = s match {
+    case Left(m)    => channel.onFastTrackTask(m)
+    case Right(cmd) => channel.onCommand(cmd)
+  }
+  private[this] val isStopped = new AtomicBoolean(false)
+  override def run(): Unit = {
+    @tailrec def impl(): Unit = if (!isStopped.get) {
+      val res = reader.readLine()
+      if (!handleInput(res) && !isStopped.get) impl()
+    }
+    try impl()
+    catch { case _: InterruptedException | _: ClosedChannelException => isStopped.set(true) }
+  }
+  override def close(): Unit = {
+    isStopped.set(true)
+    reader.close()
+  }
+}
+
+private[sbt] object UITask {
+  case object NoShellPrompt extends (State => String) {
+    override def apply(state: State): String = ""
+  }
+  trait Reader extends AutoCloseable {
+    def readLine(): Either[String, String]
+    override def close(): Unit = {}
+  }
+  object Reader {
+    // Avoid filling the stack trace since it isn't helpful here
+    object interrupted extends InterruptedException
+    def terminalReader(parser: Parser[_])(
+        terminal: Terminal,
+        state: State
+    ): Reader = new Reader {
+      val closed = new AtomicBoolean(false)
+      def readLine(): Either[String, String] =
+        try {
+          val clear = terminal.ansi(ClearPromptLine, "")
+          val res = {
+            val thread = Thread.currentThread
+            if (thread.isInterrupted || closed.get) throw interrupted
+            val reader = LineReader.createReader(history(state), parser, terminal)
+            if (thread.isInterrupted || closed.get) throw interrupted
+            (try reader.readLine(clear + terminal.prompt.mkPrompt())
+            finally reader.close) match {
+              case None if terminal == Terminal.console && System.console == null =>
+                // No stdin is attached to the process so just ignore the result and
+                // block until the thread is interrupted.
+                this.synchronized(this.wait())
+                Right("") // should be unreachable
+              // JLine returns null on ctrl+d when there is no other input. This interprets
+              // ctrl+d with no imput as an exit
+              case None => Left(TerminateAction)
+              case Some(s: String) =>
+                s.trim() match {
+                  // We need to put the empty string on the fast track queue so that we can
+                  // reprompt the user if another command is running on the server.
+                  case ""                                                => Left("")
+                  case cmd @ (`Shutdown` | `TerminateAction` | `Cancel`) => Left(cmd)
+                  case cmd                                               => Right(cmd)
+                }
+            }
+          }
+          terminal.setPrompt(Prompt.Pending)
+          res
+        } catch { case e: InterruptedException => Left("") }
+      override def close(): Unit = closed.set(true)
+    }
+  }
+  private[this] def history(s: State): Option[File] =
+    s.get(historyPath).getOrElse(Some(new File(s.baseDir, ".history")))
+  private[sbt] def shellPrompt(terminal: Terminal, s: State): String =
+    s.get(sbt.BasicKeys.shellPrompt) match {
+      case Some(NoShellPrompt) | None =>
+        s.get(colorShellPrompt) match {
+          case Some(pf) => pf(terminal.isColorEnabled, s)
+          case None =>
+            def color(s: String): String = if (terminal.isColorEnabled) s"$s" else ""
+            s"${color(DeleteLine)}> ${color(ClearScreenAfterCursor)}"
+        }
+      case Some(p) => p(s)
+    }
+  private[sbt] class AskUserTask(
+      state: State,
+      override val channel: CommandChannel,
+  ) extends UITask {
+    override private[sbt] lazy val reader: UITask.Reader = {
+      UITask.Reader.terminalReader(state.combinedParser)(channel.terminal, state)
+    }
+  }
+}
diff --git a/main-command/src/main/scala/sbt/internal/ui/UserThread.scala b/main-command/src/main/scala/sbt/internal/ui/UserThread.scala
new file mode 100644
index 000000000..94f239bc0
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/ui/UserThread.scala
@@ -0,0 +1,108 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+package ui
+
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+import java.util.concurrent.Executors
+
+import sbt.State
+import scala.concurrent.duration._
+import sbt.internal.util.JoinThread._
+import sbt.internal.util.{ ConsoleAppender, ProgressEvent, ProgressState, Prompt }
+
+private[sbt] class UserThread(val channel: CommandChannel) extends AutoCloseable {
+  private[this] val uiThread = new AtomicReference[(UITask, Thread)]
+  private[sbt] final def onProgressEvent(pe: ProgressEvent): Unit = {
+    lastProgressEvent.set(pe)
+    ProgressState.updateProgressState(pe, channel.terminal)
+  }
+  private[this] val executor =
+    Executors.newSingleThreadExecutor(r => new Thread(r, s"sbt-$name-ui-thread"))
+  private[this] val lastProgressEvent = new AtomicReference[ProgressEvent]
+  private[this] val isClosed = new AtomicBoolean(false)
+
+  private[sbt] def reset(state: State): Unit = if (!isClosed.get) {
+    uiThread.synchronized {
+      val task = channel.makeUIThread(state)
+      def submit(): Unit = {
+        val thread: Thread = new Thread(s"sbt-$name-ui-thread") {
+          setDaemon(true)
+          override def run(): Unit =
+            try task.run()
+            finally {
+              uiThread.getAndSet(null) match {
+                case prev @ (_, th) if th != this => uiThread.set(prev)
+                case _                            =>
+              }
+            }
+        }
+        uiThread.getAndSet((task, thread)) match {
+          case null => thread.start()
+          case (prevTask, prevThread) if prevTask.getClass != task.getClass =>
+            prevTask.close()
+            prevThread.joinFor(1.second)
+            thread.start()
+          case t => uiThread.set(t)
+        }
+      }
+      uiThread.get match {
+        case null                                                => submit()
+        case (prevTask, _) if prevTask.getClass == task.getClass =>
+        case (t, thread) =>
+          stopThreadImpl()
+          submit()
+      }
+    }
+    Option(lastProgressEvent.get).foreach(onProgressEvent)
+  }
+
+  private[sbt] def stopThreadImpl(): Unit = uiThread.synchronized {
+    uiThread.getAndSet(null) match {
+      case null =>
+      case (t, thread) =>
+        t.close()
+        thread.joinFor(1.second)
+    }
+  }
+  private[sbt] def stopThread(): Unit = uiThread.synchronized(stopThreadImpl())
+
+  private[sbt] def onConsolePromptEvent(consolePromptEvent: ConsolePromptEvent): Unit =
+    // synchronize to ensure that the state isn't modified during the call to reset
+    // at the bottom
+    synchronized {
+      if (terminal.isAnsiSupported) {
+        channel.terminal.withPrintStream { ps =>
+          ps.print(ConsoleAppender.ClearScreenAfterCursor)
+          ps.flush()
+        }
+      }
+      val state = consolePromptEvent.state
+      terminal.prompt match {
+        case Prompt.Running | Prompt.Pending =>
+          terminal.setPrompt(Prompt.AskUser(() => UITask.shellPrompt(terminal, state)))
+        case _ =>
+      }
+      onProgressEvent(ProgressEvent("Info", Vector(), None, None, None))
+      reset(state)
+    }
+
+  private[sbt] def onConsoleUnpromptEvent(
+      consoleUnpromptEvent: ConsoleUnpromptEvent
+  ): Unit = {
+    terminal.setPrompt(Prompt.Pending)
+    if (consoleUnpromptEvent.lastSource.fold(true)(_.channelName != name)) {
+      terminal.progressState.reset()
+    } else stopThread()
+  }
+
+  override def close(): Unit = if (isClosed.compareAndSet(false, true)) executor.shutdown()
+  private def terminal = channel.terminal
+  private def name: String = channel.name
+}
diff --git a/main-command/src/main/scala/sbt/internal/util/JoinThread.scala b/main-command/src/main/scala/sbt/internal/util/JoinThread.scala
new file mode 100644
index 000000000..4c3d109f4
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/util/JoinThread.scala
@@ -0,0 +1,31 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import scala.annotation.tailrec
+import scala.concurrent.duration._
+import java.util.concurrent.TimeoutException
+
+object JoinThread {
+  implicit class ThreadOps(val t: Thread) extends AnyVal {
+    def joinFor(duration: FiniteDuration): Unit = {
+      val deadline = duration.fromNow
+      @tailrec def impl(): Unit = {
+        try {
+          t.interrupt()
+          t.join(10)
+        } catch { case e: InterruptedException => }
+        if (t.isAlive && !deadline.isOverdue) impl()
+      }
+      impl()
+      if (t.isAlive) {
+        throw new TimeoutException(s"Unable to join thread $t after $duration")
+      }
+    }
+  }
+}
diff --git a/main-command/src/main/scala/sbt/internal/util/ReadJsonFromInputStream.scala b/main-command/src/main/scala/sbt/internal/util/ReadJsonFromInputStream.scala
new file mode 100644
index 000000000..693f2df5f
--- /dev/null
+++ b/main-command/src/main/scala/sbt/internal/util/ReadJsonFromInputStream.scala
@@ -0,0 +1,106 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.util
+
+import java.io.InputStream
+import java.nio.channels.ClosedChannelException
+import java.util.concurrent.atomic.AtomicBoolean
+import scala.util.Try
+
+private[sbt] object ReadJsonFromInputStream {
+  def apply(
+      inputStream: InputStream,
+      running: AtomicBoolean,
+      onHeader: Option[String => Unit]
+  ): Seq[Byte] = {
+    val newline = '\n'.toInt
+    val carriageReturn = '\r'.toInt
+    val contentLength = "Content-Length: "
+    var index = 0
+    /*
+     * This is the buffer into which we copy headers. The value of 128 bytes is
+     * somewhat arbitrary but chosen to ensure that there is enough space
+     * for any reasonable header. Any header exceeding 128 bytes will
+     * be truncated. The only header we care about at the moment is
+     * content-length, so this should be fine. If we ever start doing anything
+     * with headers, we may need to adjust this buffer size.
+     */
+    var headerBuffer = new Array[Byte](128)
+    def expandHeaderBuffer(): Unit = {
+      val newHeaderBuffer = new Array[Byte](headerBuffer.size * 2)
+      headerBuffer.view.zipWithIndex.foreach { case (b, i) => newHeaderBuffer(i) = b }
+      headerBuffer = newHeaderBuffer
+    }
+    def getLine(): String = {
+      val line = new String(headerBuffer, 0, index, "UTF-8")
+      index = 0
+      onHeader.foreach(oh => oh(line))
+      line
+    }
+    var content: Seq[Byte] = Seq.empty[Byte]
+    var consecutiveLineEndings = 0
+    var onCarriageReturn = false
+    do {
+      val byte = inputStream.read
+      byte match {
+        case `newline` =>
+          val line = getLine()
+          if (onCarriageReturn) consecutiveLineEndings += 1
+          onCarriageReturn = false
+          if (line.startsWith(contentLength)) {
+            Try(line.drop(contentLength.length).toInt) foreach { len =>
+              def drainHeaders(): Unit =
+                do {
+                  inputStream.read match {
+                    case `newline` if onCarriageReturn =>
+                      getLine()
+                      onCarriageReturn = false
+                      consecutiveLineEndings += 1
+                    case `carriageReturn` => onCarriageReturn = true
+                    case -1               => running.set(false)
+                    case c =>
+                      if (c == newline) getLine()
+                      else {
+                        if (index >= headerBuffer.length) expandHeaderBuffer()
+                        headerBuffer(index) = c.toByte
+                        index += 1
+                      }
+                      onCarriageReturn = false
+                      consecutiveLineEndings = 0
+                  }
+                } while (consecutiveLineEndings < 2 && running.get)
+              drainHeaders()
+              if (running.get) {
+                val buf = new Array[Byte](len)
+                var offset = 0
+                do {
+                  offset += inputStream.read(buf, offset, len - offset)
+                } while (offset < len && running.get)
+                if (running.get) content = buf.toSeq
+              }
+            }
+          } else if (line.startsWith("{")) {
+            // Assume this is a json object with no headers
+            content = line.getBytes.toSeq
+          }
+        case i if i < 0 =>
+          running.set(false)
+          throw new ClosedChannelException
+        case `carriageReturn` => onCarriageReturn = true
+        case c =>
+          onCarriageReturn = false
+          if (index >= headerBuffer.length) expandHeaderBuffer()
+          headerBuffer(index) = c.toByte
+          index += 1
+
+      }
+    } while (content.isEmpty && running.get)
+    content
+  }
+
+}
diff --git a/main-command/src/main/scala/xsbt/IPC.scala b/main-command/src/main/scala/xsbt/IPC.scala
index ba6a3333f..9c353613d 100644
--- a/main-command/src/main/scala/xsbt/IPC.scala
+++ b/main-command/src/main/scala/xsbt/IPC.scala
@@ -1,59 +1,66 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package xsbt
 
 import java.io.{ BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter }
 import java.net.{ InetAddress, ServerSocket, Socket }
 
+import scala.annotation.tailrec
 import scala.util.control.NonFatal
 
 object IPC {
   private val portMin = 1025
   private val portMax = 65536
-  private val loopback = InetAddress.getByName(null) // loopback
+  private val loopback = InetAddress.getByName(null)
 
-  def client[T](port: Int)(f: IPC => T): T =
-    ipc(new Socket(loopback, port))(f)
+  def client[T](port: Int)(f: IPC => T): T = ipc(new Socket(loopback, port))(f)
+
+  def pullServer[T](f: Server => T): T = {
+    val server = makeServer
+    try f(new Server(server))
+    finally server.close()
+  }
 
-  def pullServer[T](f: Server => T): T =
-    {
-      val server = makeServer
-      try { f(new Server(server)) }
-      finally { server.close() }
-    }
   def unmanagedServer: Server = new Server(makeServer)
-  def makeServer: ServerSocket =
-    {
-      val random = new java.util.Random
-      def nextPort = random.nextInt(portMax - portMin + 1) + portMin
-      def createServer(attempts: Int): ServerSocket =
-        if (attempts > 0)
-          try { new ServerSocket(nextPort, 1, loopback) }
-          catch { case NonFatal(e) => createServer(attempts - 1) }
-        else
-          sys.error("Could not connect to socket: maximum attempts exceeded")
-      createServer(10)
-    }
+
+  def makeServer: ServerSocket = {
+    val random = new java.util.Random
+    def nextPort = random.nextInt(portMax - portMin + 1) + portMin
+
+    def createServer(attempts: Int): ServerSocket =
+      if (attempts > 0) {
+        try new ServerSocket(nextPort, 1, loopback)
+        catch { case NonFatal(_) => createServer(attempts - 1) }
+      } else sys.error("Could not connect to socket: maximum attempts exceeded")
+
+    createServer(10)
+  }
+
   def server[T](f: IPC => Option[T]): T = serverImpl(makeServer, f)
+
   def server[T](port: Int)(f: IPC => Option[T]): T =
     serverImpl(new ServerSocket(port, 1, loopback), f)
-  private def serverImpl[T](server: ServerSocket, f: IPC => Option[T]): T =
-    {
-      def listen(): T =
-        {
-          ipc(server.accept())(f) match {
-            case Some(done) => done
-            case None       => listen()
-          }
-        }
 
-      try { listen() }
-      finally { server.close() }
+  private def serverImpl[T](server: ServerSocket, f: IPC => Option[T]): T = {
+    @tailrec def listen(): T = {
+      ipc(server.accept())(f) match {
+        case Some(done) => done
+        case None       => listen()
+      }
     }
+
+    try listen()
+    finally server.close()
+  }
+
   private def ipc[T](s: Socket)(f: IPC => T): T =
-    try { f(new IPC(s)) }
-    finally { s.close() }
+    try f(new IPC(s))
+    finally s.close()
 
   final class Server private[IPC] (s: ServerSocket) {
     def port = s.getLocalPort
@@ -62,6 +69,7 @@ object IPC {
     def connection[T](f: IPC => T): T = IPC.ipc(s.accept())(f)
   }
 }
+
 final class IPC private (s: Socket) {
   def port = s.getLocalPort
   private val in = new BufferedReader(new InputStreamReader(s.getInputStream))
diff --git a/main-command/src/test/scala/sbt/MultiParserSpec.scala b/main-command/src/test/scala/sbt/MultiParserSpec.scala
new file mode 100644
index 000000000..88aea432d
--- /dev/null
+++ b/main-command/src/test/scala/sbt/MultiParserSpec.scala
@@ -0,0 +1,143 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import scala.concurrent.duration._
+import org.scalatest.FlatSpec
+import sbt.internal.util.complete.Parser
+
+object MultiParserSpec {
+  val parser: Parser[Seq[String]] = BasicCommands.multiParserImpl(None)
+  implicit class StringOps(val s: String) {
+    def parse: Seq[String] = Parser.parse(s, parser) match {
+      case Right(x) => x
+      case Left(x)  => sys.error(s)
+    }
+    def parseEither: Either[String, Seq[String]] = Parser.parse(s, parser)
+  }
+}
+import sbt.MultiParserSpec._
+class MultiParserSpec extends FlatSpec {
+  "parsing" should "parse single commands" in {
+    assert(";foo".parse == Seq("foo"))
+    assert(";   foo".parse == Seq("foo"))
+  }
+  it should "parse multiple commands" in {
+    assert(";foo;bar".parse == Seq("foo", "bar"))
+  }
+  it should "parse single command with leading spaces" in {
+    assert(";     foo".parse == Seq("foo"))
+    assert("     ;     foo".parse == Seq("foo"))
+    assert("      foo;".parse == Seq("foo"))
+  }
+  it should "parse single command with trailing spaces" in {
+    assert(";     foo      ".parse == Seq("foo"))
+    assert(";foo      ".parse == Seq("foo"))
+    assert("foo;      ".parse == Seq("foo"))
+    assert("    foo;    ".parse == Seq("foo"))
+    assert("      foo   ;    ".parse == Seq("foo"))
+  }
+  it should "parse multiple commands with leading spaces" in {
+    assert(";     foo;bar".parse == Seq("foo", "bar"))
+    assert(";     foo;    bar".parse == Seq("foo", "bar"))
+    assert(";foo; bar".parse == Seq("foo", "bar"))
+    assert("; foo ; bar ; baz".parse == Seq("foo", "bar", "baz"))
+  }
+  it should "parse command with string literal" in {
+    assert("; foo \"barbaz\"".parse == Seq("foo \"barbaz\""))
+    assert("; foo \"bar;baz\"".parse == Seq("foo \"bar;baz\""))
+    assert("; foo \"barbaz\"; bar".parse == Seq("foo \"barbaz\"", "bar"))
+    assert("; foo \"barbaz\"; bar \"blah\"".parse == Seq("foo \"barbaz\"", "bar \"blah\""))
+    assert("; foo \"bar;baz\"; bar".parse == Seq("foo \"bar;baz\"", "bar"))
+    assert("; foo \"bar;baz\"; bar \"buzz\"".parse == Seq("foo \"bar;baz\"", "bar \"buzz\""))
+    assert(
+      "; foo \"bar;baz\"; bar \"buzz;two\"".parse == Seq("foo \"bar;baz\"", "bar \"buzz;two\"")
+    )
+    assert("""; foo "bar;\"baz\""; bar""".parse == Seq("""foo "bar;\"baz\""""", "bar"))
+    assert(
+      """; setStringValue "foo;bar"; checkStringValue "foo;bar"""".parse ==
+        Seq("""setStringValue "foo;bar"""", """checkStringValue "foo;bar"""")
+    )
+  }
+  it should "parse commands without leading ';'" in {
+    assert(
+      "setStringValue foo; setStringValue bar".parse == Seq(
+        "setStringValue foo",
+        "setStringValue bar"
+      )
+    )
+    assert("foo; bar".parse == Seq("foo", "bar"))
+    assert("foo bar ;bar".parse == Seq("foo bar", "bar"))
+    assert("foo \"a;b\"; bar".parse == Seq("foo \"a;b\"", "bar"))
+    assert(" foo ; bar \"b;c\"".parse == Seq("foo", "bar \"b;c\""))
+  }
+  it should "not parse single commands without leading ';'" in {
+    assert("foo".parseEither == Left("Expected ';'\nfoo\n   ^"))
+    assert("foo bar baz".parseEither == Left("Expected ';'\nfoo bar baz\n           ^"))
+  }
+  it should "not parse empty commands" in {
+    assert(";;;".parseEither.isLeft)
+    assert("; ; ;".parseEither.isLeft)
+  }
+  it should "parse commands with trailing semi-colon" in {
+    assert("foo;bar;".parse == Seq("foo", "bar"))
+    assert("foo;   bar    ;".parse == Seq("foo", "bar"))
+  }
+  val consecutive = "{ { val x = 1}; { val x = 2 } }"
+  val oneBrace = "set foo := { val x = 1; x + 1 }"
+  val twoBrace = "set foo := { val x = { val y = 2; y + 2 }; x + 1 }"
+  val threeBrace = "set foo := { val x = { val y = 2; { val z = 3; y + 2 } }; x + 1 }"
+  val doubleBrace = "set foo := { val x = { val y = 2; y + 2 }; { x + 1 } }"
+  val tripleBrace = "set foo := { val x = { val y = 2; y + 2 }; val y = { x + 1 }; { z + y } }"
+  val emptyBraces = "{{{{}}}}"
+  it should "parse commands with braces" in {
+    assert(s"$consecutive;".parse == consecutive :: Nil)
+    assert(s"$oneBrace;".parse == oneBrace :: Nil)
+    assert(s"$twoBrace;".parse == twoBrace :: Nil)
+    assert(s"$threeBrace;".parse == threeBrace :: Nil)
+    assert(s"$doubleBrace;".parse == doubleBrace :: Nil)
+    assert(s"$tripleBrace;".parse == tripleBrace :: Nil)
+    assert(s"$emptyBraces;".parse == emptyBraces :: Nil)
+  }
+  it should "parse multiple commands with braces" in {
+    assert(s"compile; $consecutive".parse == "compile" :: consecutive :: Nil)
+    assert(s"compile; $consecutive ; test".parse == "compile" :: consecutive :: "test" :: Nil)
+  }
+  it should "not parse unclosed braces" in {
+    val extraRight = "{ { val x = 1}}{ val x = 2 } }"
+    assert(s"compile; $extraRight".parseEither.isLeft)
+    val extraLeft = "{{{ val x = 1}{ val x = 2 } }"
+    assert(s"compile; $extraLeft".parseEither.isLeft)
+    val unmatchedEmptyBraces = "{{{{}}}"
+    assert(s"compile; $unmatchedEmptyBraces".parseEither.isLeft)
+  }
+  it should "handle cosmetic whitespace" in {
+    val commands = (1 to 100).map(_ => "compile")
+    val multiLine = commands.mkString("      \n      ;", "       \n       ;", "    \n        ")
+    val start = System.nanoTime
+    assert(multiLine.parse == commands)
+    val elapsed = System.nanoTime - start
+    // Make sure this took less than 10 seconds. It takes about 30 milliseconds to run with
+    // 100 commands and 3 milliseconds with 3 commands. With a bad parser, it will run indefinitely.
+    assert(elapsed.nanoseconds < 10.seconds)
+  }
+  it should "exclude alias" in {
+    val alias = """alias scalacFoo = ; set scalacOptions ++= Seq("-foo")"""
+    assert(alias.parseEither.isLeft)
+    assert(s"   $alias".parseEither.isLeft)
+    assert(s"   $alias;".parseEither.isLeft)
+    assert(s";$alias".parseEither.isLeft)
+    assert(s";   $alias".parseEither.isLeft)
+    assert(s";$alias;".parseEither.isLeft)
+    assert(s";   $alias;".parseEither.isLeft)
+    assert(s"foo; $alias".parseEither.isLeft)
+    assert(s"; foo;$alias".parseEither.isLeft)
+    assert(s"; foo;$alias; ".parseEither.isLeft)
+    assert(s"; foo;   $alias; ".parseEither.isLeft)
+  }
+}
diff --git a/main-command/src/test/scala/sbt/internal/ClassLoaderCacheTest.scala b/main-command/src/test/scala/sbt/internal/ClassLoaderCacheTest.scala
new file mode 100644
index 000000000..eec114f40
--- /dev/null
+++ b/main-command/src/test/scala/sbt/internal/ClassLoaderCacheTest.scala
@@ -0,0 +1,55 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.io.File
+import java.nio.file.Files
+
+import org.scalatest.{ FlatSpec, Matchers }
+import sbt.internal.classpath.ClassLoaderCache
+import sbt.io.IO
+
+object ClassLoaderCacheTest {
+  implicit class CacheOps(val c: ClassLoaderCache) {
+    def get(classpath: Seq[File]): ClassLoader = c(classpath.toList)
+  }
+}
+class ClassLoaderCacheTest extends FlatSpec with Matchers {
+  import ClassLoaderCacheTest._
+  private def withCache[R](f: ClassLoaderCache => R): R = {
+    val cache = new ClassLoaderCache(ClassLoader.getSystemClassLoader)
+    try f(cache)
+    finally cache.close()
+  }
+  "ClassLoaderCache" should "make a new loader when full" in withCache { cache =>
+    val classPath = Seq.empty[File]
+    val firstLoader = cache.get(classPath)
+    cache.clear()
+    val secondLoader = cache.get(classPath)
+    assert(firstLoader != secondLoader)
+  }
+  it should "not make a new loader when it already exists" in withCache { cache =>
+    val classPath = Seq.empty[File]
+    val firstLoader = cache.get(classPath)
+    val secondLoader = cache.get(classPath)
+    assert(firstLoader == secondLoader)
+  }
+  "Snapshots" should "be invalidated" in IO.withTemporaryDirectory { dir =>
+    val snapshotJar = Files.createFile(dir.toPath.resolve("foo-SNAPSHOT.jar")).toFile
+    val regularJar = Files.createFile(dir.toPath.resolve("regular.jar")).toFile
+    withCache { cache =>
+      val jarClassPath = snapshotJar :: regularJar :: Nil
+      val initLoader = cache.get(jarClassPath)
+      IO.setModifiedTimeOrFalse(snapshotJar, System.currentTimeMillis + 5000L)
+      val secondLoader = cache.get(jarClassPath)
+      assert(initLoader != secondLoader)
+      assert(cache.get(jarClassPath) == secondLoader)
+      assert(cache.get(jarClassPath) != initLoader)
+    }
+  }
+}
diff --git a/main-settings/src/main/scala/sbt/Append.scala b/main-settings/src/main/scala/sbt/Append.scala
index b44ce8090..68aa27d9b 100644
--- a/main-settings/src/main/scala/sbt/Append.scala
+++ b/main-settings/src/main/scala/sbt/Append.scala
@@ -1,64 +1,125 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import java.io.File
-import Def.Classpath
-import scala.annotation.implicitNotFound
+
+import scala.annotation.{ compileTimeOnly, implicitNotFound }
+
+import sbt.Def.{ Classpath, Initialize }
+import sbt.internal.io.Source
 import sbt.internal.util.Attributed
+import sbt.io.{ AllPassFilter, NothingFilter }
 
 object Append {
-  @implicitNotFound(msg = "No implicit for Append.Value[${A}, ${B}] found,\n  so ${B} cannot be appended to ${A}")
+  @implicitNotFound("No Append.Value[${A}, ${B}] found, so ${B} cannot be appended to ${A}")
   trait Value[A, B] {
     def appendValue(a: A, b: B): A
   }
-  @implicitNotFound(msg = "No implicit for Append.Values[${A}, ${B}] found,\n  so ${B} cannot be appended to ${A}")
+
+  @implicitNotFound("No Append.Values[${A}, ${B}] found, so ${B} cannot be appended to ${A}")
   trait Values[A, -B] {
     def appendValues(a: A, b: B): A
   }
+
   trait Sequence[A, -B, T] extends Value[A, T] with Values[A, B]
 
-  implicit def appendSeq[T, V <: T]: Sequence[Seq[T], Seq[V], V] = new Sequence[Seq[T], Seq[V], V] {
-    def appendValues(a: Seq[T], b: Seq[V]): Seq[T] = a ++ b
-    def appendValue(a: Seq[T], b: V): Seq[T] = a :+ b
-  }
-  implicit def appendSeqImplicit[T, V](implicit ev: V => T): Sequence[Seq[T], Seq[V], V] = new Sequence[Seq[T], Seq[V], V] {
-    def appendValues(a: Seq[T], b: Seq[V]): Seq[T] = a ++ (b map { x => (x: T) })
-    def appendValue(a: Seq[T], b: V): Seq[T] = a :+ (b: T)
-  }
-  implicit def appendList[T, V <: T]: Sequence[List[T], List[V], V] = new Sequence[List[T], List[V], V] {
-    def appendValues(a: List[T], b: List[V]): List[T] = a ::: b
-    def appendValue(a: List[T], b: V): List[T] = a :+ b
-  }
-  implicit def appendListImplicit[T, V](implicit ev: V => T): Sequence[List[T], List[V], V] = new Sequence[List[T], List[V], V] {
-    def appendValues(a: List[T], b: List[V]): List[T] = a ::: (b map { x => (x: T) })
-    def appendValue(a: List[T], b: V): List[T] = a :+ (b: T)
-  }
-  implicit def appendString: Value[String, String] = new Value[String, String] {
-    def appendValue(a: String, b: String) = a + b
-  }
-  implicit def appendInt = new Value[Int, Int] {
-    def appendValue(a: Int, b: Int) = a + b
-  }
-  implicit def appendLong = new Value[Long, Long] {
-    def appendValue(a: Long, b: Long) = a + b
-  }
-  implicit def appendDouble = new Value[Double, Double] {
-    def appendValue(a: Double, b: Double) = a + b
-  }
-  implicit def appendClasspath: Sequence[Classpath, Seq[File], File] = new Sequence[Classpath, Seq[File], File] {
-    def appendValues(a: Classpath, b: Seq[File]): Classpath = a ++ Attributed.blankSeq(b)
-    def appendValue(a: Classpath, b: File): Classpath = a :+ Attributed.blank(b)
-  }
-  implicit def appendSet[T, V <: T]: Sequence[Set[T], Set[V], V] = new Sequence[Set[T], Set[V], V] {
-    def appendValues(a: Set[T], b: Set[V]): Set[T] = a ++ b
-    def appendValue(a: Set[T], b: V): Set[T] = a + b
-  }
-  implicit def appendMap[A, B, X <: A, Y <: B]: Sequence[Map[A, B], Map[X, Y], (X, Y)] = new Sequence[Map[A, B], Map[X, Y], (X, Y)] {
-    def appendValues(a: Map[A, B], b: Map[X, Y]): Map[A, B] = a ++ b
-    def appendValue(a: Map[A, B], b: (X, Y)): Map[A, B] = a + b
-  }
+  implicit def appendSeq[T, V <: T]: Sequence[Seq[T], Seq[V], V] =
+    new Sequence[Seq[T], Seq[V], V] {
+      def appendValues(a: Seq[T], b: Seq[V]): Seq[T] = a ++ (b: Seq[T])
+      def appendValue(a: Seq[T], b: V): Seq[T] = a :+ (b: T)
+    }
+
+  implicit def appendSeqImplicit[T, V](implicit ev: V => T): Sequence[Seq[T], Seq[V], V] =
+    new Sequence[Seq[T], Seq[V], V] {
+      def appendValues(a: Seq[T], b: Seq[V]): Seq[T] = a ++ b.map(x => (x: T))
+      def appendValue(a: Seq[T], b: V): Seq[T] = a :+ (b: T)
+    }
+
+  @compileTimeOnly("This can be used in += only.")
+  implicit def appendTaskValueSeq[T, V <: T]: Value[Seq[Task[T]], Initialize[Task[V]]] =
+    (_, _) => ??? // SAM conversion.  This implementation is rewritten by sbt's macros too.
+
+  @compileTimeOnly("This can be used in += only.")
+  implicit def appendTaskKeySeq[T, V <: T]: Value[Seq[Task[T]], TaskKey[V]] = (_, _) => ??? // SAM
+
+  implicit def appendList[T, V <: T]: Sequence[List[T], List[V], V] =
+    new Sequence[List[T], List[V], V] {
+      def appendValues(a: List[T], b: List[V]): List[T] = a ::: (b: List[T])
+      def appendValue(a: List[T], b: V): List[T] = a :+ (b: T)
+    }
+
+  implicit def appendListImplicit[T, V](implicit ev: V => T): Sequence[List[T], List[V], V] =
+    new Sequence[List[T], List[V], V] {
+      def appendValues(a: List[T], b: List[V]): List[T] = a ::: b.map(x => (x: T))
+      def appendValue(a: List[T], b: V): List[T] = a :+ (b: T)
+    }
+
+  implicit def appendVectorImplicit[T, V](implicit ev: V => T): Sequence[Vector[T], Seq[V], V] =
+    new Sequence[Vector[T], Seq[V], V] {
+      def appendValues(a: Vector[T], b: Seq[V]): Vector[T] = a ++ b.map(x => (x: T))
+      def appendValue(a: Vector[T], b: V): Vector[T] = a :+ (b: T)
+    }
+
+  // psst... these are implemented with SAM conversions
+  implicit def appendString: Value[String, String] = _ + _
+  implicit def appendInt: Value[Int, Int] = _ + _
+  implicit def appendLong: Value[Long, Long] = _ + _
+  implicit def appendDouble: Value[Double, Double] = _ + _
+
+  implicit def appendClasspath: Sequence[Classpath, Seq[File], File] =
+    new Sequence[Classpath, Seq[File], File] {
+      def appendValues(a: Classpath, b: Seq[File]): Classpath = a ++ Attributed.blankSeq(b)
+      def appendValue(a: Classpath, b: File): Classpath = a :+ Attributed.blank(b)
+    }
+
+  implicit def appendSet[T, V <: T]: Sequence[Set[T], Set[V], V] =
+    new Sequence[Set[T], Set[V], V] {
+      def appendValues(a: Set[T], b: Set[V]): Set[T] = a ++ (b.toSeq: Seq[T]).toSet
+      def appendValue(a: Set[T], b: V): Set[T] = a + (b: T)
+    }
+
+  implicit def appendMap[A, B, X <: A, Y <: B]: Sequence[Map[A, B], Map[X, Y], (X, Y)] =
+    new Sequence[Map[A, B], Map[X, Y], (X, Y)] {
+      def appendValues(a: Map[A, B], b: Map[X, Y]): Map[A, B] =
+        (a.toSeq ++ (b.toSeq: Seq[(A, B)])).toMap
+      def appendValue(a: Map[A, B], b: (X, Y)): Map[A, B] = a + (b: (A, B))
+    }
+
   implicit def appendOption[T]: Sequence[Seq[T], Option[T], Option[T]] =
     new Sequence[Seq[T], Option[T], Option[T]] {
       def appendValue(a: Seq[T], b: Option[T]): Seq[T] = b.fold(a)(a :+ _)
       def appendValues(a: Seq[T], b: Option[T]): Seq[T] = b.fold(a)(a :+ _)
     }
+
+  implicit def appendSource: Sequence[Seq[Source], Seq[File], File] =
+    new Sequence[Seq[Source], Seq[File], File] {
+      def appendValue(a: Seq[Source], b: File): Seq[Source] = appendValues(a, Seq(b))
+      def appendValues(a: Seq[Source], b: Seq[File]): Seq[Source] =
+        a ++ b.map { f =>
+          // Globs only accept their own base if the depth parameter is set to -1. The conversion
+          // from Source to Glob never sets the depth to -1, which causes individual files
+          // added via `watchSource += ...` to not trigger a build when they are modified. Since
+          // watchSources will be deprecated in 1.3.0, I'm hoping that most people will migrate
+          // their builds to the new system, but this will work for most builds in the interim.
+          if (f.isFile && f.getParentFile != null)
+            new Source(f.getParentFile, f.getName, NothingFilter, recursive = false)
+          else new Source(f, AllPassFilter, NothingFilter)
+        }
+    }
+
+  // Implemented with SAM conversion short-hand
+  implicit def appendFunction[A, B]: Value[A => A, A => A] = _.andThen(_)
+
+  implicit def appendSideEffectToFunc[A, B]: Value[A => B, () => Unit] = (f, sideEffect) => {
+    f.andThen { b =>
+      sideEffect()
+      b
+    }
+  }
 }
diff --git a/main-settings/src/main/scala/sbt/ConfigKey.scala b/main-settings/src/main/scala/sbt/ConfigKey.scala
index 6dd75823c..09f847bc4 100644
--- a/main-settings/src/main/scala/sbt/ConfigKey.scala
+++ b/main-settings/src/main/scala/sbt/ConfigKey.scala
@@ -1,6 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 final case class ConfigKey(name: String)
 object ConfigKey {
-  implicit def configurationToKey(c: sbt.librarymanagement.Configuration): ConfigKey = ConfigKey(c.name)
+  implicit def configurationToKey(c: sbt.librarymanagement.Configuration): ConfigKey =
+    ConfigKey(c.name)
 }
diff --git a/main-settings/src/main/scala/sbt/Def.scala b/main-settings/src/main/scala/sbt/Def.scala
index 7f08e50bb..df78134ea 100644
--- a/main-settings/src/main/scala/sbt/Def.scala
+++ b/main-settings/src/main/scala/sbt/Def.scala
@@ -1,52 +1,199 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import sbt.internal.util.Types.const
-import sbt.internal.util.{ Attributed, AttributeKey, Init, Show }
-import sbt.internal.util.complete.Parser
 import java.io.File
-import Scope.{ ThisScope, GlobalScope }
-import KeyRanks.{ DTask, Invisible }
+import java.net.URI
+
+import scala.annotation.tailrec
+import sbt.KeyRanks.{ DTask, Invisible }
+import sbt.Scope.{ GlobalScope, ThisScope }
+import sbt.internal.util.Types.const
+import sbt.internal.util.complete.Parser
+import sbt.internal.util.{ Terminal => ITerminal, _ }
+import Util._
+import sbt.util.Show
+import xsbti.VirtualFile
 
 /** A concrete settings system that uses `sbt.Scope` for the scope type. */
-object Def extends Init[Scope] with TaskMacroExtra {
+object Def extends Init[Scope] with TaskMacroExtra with InitializeImplicits {
   type Classpath = Seq[Attributed[File]]
+  type VirtualClasspath = Seq[Attributed[VirtualFile]]
 
   def settings(ss: SettingsDefinition*): Seq[Setting[_]] = ss.flatMap(_.settings)
 
   val triggeredBy = AttributeKey[Seq[Task[_]]]("triggered-by")
   val runBefore = AttributeKey[Seq[Task[_]]]("run-before")
-  val resolvedScoped = SettingKey[ScopedKey[_]]("resolved-scoped", "The ScopedKey for the referencing setting or task.", KeyRanks.DSetting)
-  private[sbt] val taskDefinitionKey = AttributeKey[ScopedKey[_]]("task-definition-key", "Internal: used to map a task back to its ScopedKey.", Invisible)
+  val resolvedScoped = SettingKey[ScopedKey[_]](
+    "resolved-scoped",
+    "The ScopedKey for the referencing setting or task.",
+    KeyRanks.DSetting
+  )
+  private[sbt] val taskDefinitionKey = AttributeKey[ScopedKey[_]](
+    "task-definition-key",
+    "Internal: used to map a task back to its ScopedKey.",
+    Invisible
+  )
 
   lazy val showFullKey: Show[ScopedKey[_]] = showFullKey(None)
+
   def showFullKey(keyNameColor: Option[String]): Show[ScopedKey[_]] =
-    new Show[ScopedKey[_]] { def apply(key: ScopedKey[_]) = displayFull(key, keyNameColor) }
+    Show[ScopedKey[_]]((key: ScopedKey[_]) => displayFull(key, keyNameColor))
 
-  def showRelativeKey(current: ProjectRef, multi: Boolean, keyNameColor: Option[String] = None): Show[ScopedKey[_]] = new Show[ScopedKey[_]] {
-    def apply(key: ScopedKey[_]) =
-      Scope.display(key.scope, colored(key.key.label, keyNameColor), ref => displayRelative(current, multi, ref))
+  @deprecated("Use showRelativeKey2 which doesn't take the unused multi param", "1.1.1")
+  def showRelativeKey(
+      current: ProjectRef,
+      multi: Boolean,
+      keyNameColor: Option[String] = None
+  ): Show[ScopedKey[_]] =
+    showRelativeKey2(current, keyNameColor)
+
+  def showRelativeKey2(
+      current: ProjectRef,
+      keyNameColor: Option[String] = None,
+  ): Show[ScopedKey[_]] =
+    Show[ScopedKey[_]](
+      key => {
+        val color: String => String = withColor(_, keyNameColor)
+        key.scope.extra.toOption
+          .flatMap(_.get(Scope.customShowString).map(color))
+          .getOrElse {
+            Scope.display(key.scope, color(key.key.label), ref => displayRelative2(current, ref))
+          }
+      }
+    )
+
+  private[sbt] def showShortKey(
+      keyNameColor: Option[String],
+  ): Show[ScopedKey[_]] = {
+    def displayShort(
+        project: Reference
+    ): String = {
+      val trailing = " /"
+      project match {
+        case BuildRef(_)      => "ThisBuild" + trailing
+        case ProjectRef(_, x) => x + trailing
+        case _                => Reference.display(project) + trailing
+      }
+    }
+    Show[ScopedKey[_]](
+      key =>
+        Scope.display(
+          key.scope,
+          withColor(key.key.label, keyNameColor),
+          ref => displayShort(ref)
+        )
+    )
   }
-  def displayRelative(current: ProjectRef, multi: Boolean, project: Reference): String = project match {
-    case BuildRef(current.build)      => "{.}/"
-    case `current`                    => if (multi) current.project + "/" else ""
-    case ProjectRef(current.build, x) => x + "/"
-    case _                            => Reference.display(project) + "/"
+
+  @deprecated("Use showBuildRelativeKey2 which doesn't take the unused multi param", "1.1.1")
+  def showBuildRelativeKey(
+      currentBuild: URI,
+      multi: Boolean,
+      keyNameColor: Option[String] = None,
+  ): Show[ScopedKey[_]] =
+    showBuildRelativeKey2(currentBuild, keyNameColor)
+
+  def showBuildRelativeKey2(
+      currentBuild: URI,
+      keyNameColor: Option[String] = None,
+  ): Show[ScopedKey[_]] =
+    Show[ScopedKey[_]](
+      key =>
+        Scope.display(
+          key.scope,
+          withColor(key.key.label, keyNameColor),
+          ref => displayBuildRelative(currentBuild, ref)
+        )
+    )
+
+  /**
+   * Returns a String expression for the given [[Reference]] (BuildRef, [[ProjectRef]], etc)
+   * relative to the current project.
+   */
+  def displayRelativeReference(current: ProjectRef, project: Reference): String =
+    displayRelative(current, project, false)
+
+  @deprecated("Use displayRelative2 which doesn't take the unused multi param", "1.1.1")
+  def displayRelative(current: ProjectRef, multi: Boolean, project: Reference): String =
+    displayRelative2(current, project)
+
+  def displayRelative2(current: ProjectRef, project: Reference): String =
+    displayRelative(current, project, true)
+
+  /**
+   * Constructs the String of a given [[Reference]] relative to current.
+   * Note that this no longer takes "multi" parameter, and omits the subproject id at all times.
+   */
+  private[sbt] def displayRelative(
+      current: ProjectRef,
+      project: Reference,
+      trailingSlash: Boolean
+  ): String = {
+    import Reference.{ display => displayRef }
+    @tailrec def loop(ref: Reference): String = ref match {
+      case ProjectRef(b, p) => if (b == current.build) loop(LocalProject(p)) else displayRef(ref)
+      case BuildRef(b)      => if (b == current.build) loop(ThisBuild) else displayRef(ref)
+      case RootProject(b)   => if (b == current.build) loop(LocalRootProject) else displayRef(ref)
+      case LocalProject(p)  => if (p == current.project) "" else p
+      case ThisBuild        => "ThisBuild"
+      case LocalRootProject => "<root>"
+      case ThisProject      => "<this>"
+    }
+    val str = loop(project)
+    if (trailingSlash && !str.isEmpty) s"$str /"
+    else str
   }
+
+  @deprecated("Use variant without multi", "1.1.1")
+  def displayBuildRelative(currentBuild: URI, multi: Boolean, project: Reference): String =
+    displayBuildRelative(currentBuild, project)
+
+  def displayBuildRelative(currentBuild: URI, project: Reference): String =
+    project match {
+      case BuildRef(`currentBuild`)      => "ThisBuild /"
+      case ProjectRef(`currentBuild`, x) => x + " /"
+      case _                             => Reference.display(project) + " /"
+    }
+
   def displayFull(scoped: ScopedKey[_]): String = displayFull(scoped, None)
-  def displayFull(scoped: ScopedKey[_], keyNameColor: Option[String]): String = Scope.display(scoped.scope, colored(scoped.key.label, keyNameColor))
-  def displayMasked(scoped: ScopedKey[_], mask: ScopeMask): String = Scope.displayMasked(scoped.scope, scoped.key.label, mask)
 
-  def colored(s: String, color: Option[String]): String = color match {
-    case Some(c) => c + s + scala.Console.RESET
-    case None    => s
+  def displayFull(scoped: ScopedKey[_], keyNameColor: Option[String]): String =
+    Scope.display(scoped.scope, withColor(scoped.key.label, keyNameColor))
+
+  def displayMasked(scoped: ScopedKey[_], mask: ScopeMask): String =
+    Scope.displayMasked(scoped.scope, scoped.key.label, mask)
+
+  def displayMasked(scoped: ScopedKey[_], mask: ScopeMask, showZeroConfig: Boolean): String =
+    Scope.displayMasked(scoped.scope, scoped.key.label, mask, showZeroConfig)
+
+  def withColor(s: String, color: Option[String]): String =
+    withColor(s, color, useColor = ITerminal.isColorEnabled)
+  def withColor(s: String, color: Option[String], useColor: Boolean): String = color match {
+    case Some(c) if useColor => c + s + scala.Console.RESET
+    case _                   => s
   }
 
   override def deriveAllowed[T](s: Setting[T], allowDynamic: Boolean): Option[String] =
     super.deriveAllowed(s, allowDynamic) orElse
-      (if (s.key.scope != ThisScope) Some(s"Scope cannot be defined for ${definedSettingString(s)}") else None) orElse
-      s.dependencies.find(k => k.scope != ThisScope).map(k => s"Scope cannot be defined for dependency ${k.key.label} of ${definedSettingString(s)}")
+      (if (s.key.scope != ThisScope)
+         s"Scope cannot be defined for ${definedSettingString(s)}".some
+       else none) orElse
+      s.dependencies
+        .find(k => k.scope != ThisScope)
+        .map(
+          k =>
+            s"Scope cannot be defined for dependency ${k.key.label} of ${definedSettingString(s)}"
+        )
 
-  override def intersect(s1: Scope, s2: Scope)(implicit delegates: Scope => Seq[Scope]): Option[Scope] =
+  override def intersect(s1: Scope, s2: Scope)(
+      implicit delegates: Scope => Seq[Scope]
+  ): Option[Scope] =
     if (s2 == GlobalScope) Some(s1) // s1 is more specific
     else if (s1 == GlobalScope) Some(s2) // s2 is more specific
     else super.intersect(s1, s2)
@@ -60,7 +207,8 @@ object Def extends Init[Scope] with TaskMacroExtra {
    * A default Parser for splitting input into space-separated arguments.
    * `argLabel` is an optional, fixed label shown for an argument during tab completion.
    */
-  def spaceDelimited(argLabel: String = "<arg>"): Parser[Seq[String]] = sbt.internal.util.complete.Parsers.spaceDelimited(argLabel)
+  def spaceDelimited(argLabel: String = "<arg>"): Parser[Seq[String]] =
+    sbt.internal.util.complete.Parsers.spaceDelimited(argLabel)
 
   /** Lifts the result of a setting initialization into a Task. */
   def toITask[T](i: Initialize[T]): Initialize[Task[T]] = map(i)(std.TaskExtra.inlineTask)
@@ -69,52 +217,167 @@ object Def extends Init[Scope] with TaskMacroExtra {
   def toISParser[T](p: Initialize[Parser[T]]): Initialize[State => Parser[T]] = p(toSParser)
   def toIParser[T](p: Initialize[InputTask[T]]): Initialize[State => Parser[Task[T]]] = p(_.parser)
 
-  import language.experimental.macros
-  import std.TaskMacro.{ inputTaskMacroImpl, inputTaskDynMacroImpl, taskDynMacroImpl, taskMacroImpl }
   import std.SettingMacro.{ settingDynMacroImpl, settingMacroImpl }
-  import std.{ InputEvaluated, MacroPrevious, MacroValue, MacroTaskValue, ParserInput }
+  import std.TaskMacro.{
+    inputTaskDynMacroImpl,
+    inputTaskMacroImpl,
+    taskDynMacroImpl,
+    taskIfMacroImpl,
+    taskMacroImpl
+  }
+  import std._
+
+  import language.experimental.macros
 
   def task[T](t: T): Def.Initialize[Task[T]] = macro taskMacroImpl[T]
   def taskDyn[T](t: Def.Initialize[Task[T]]): Def.Initialize[Task[T]] = macro taskDynMacroImpl[T]
   def setting[T](t: T): Def.Initialize[T] = macro settingMacroImpl[T]
   def settingDyn[T](t: Def.Initialize[T]): Def.Initialize[T] = macro settingDynMacroImpl[T]
   def inputTask[T](t: T): Def.Initialize[InputTask[T]] = macro inputTaskMacroImpl[T]
-  def inputTaskDyn[T](t: Def.Initialize[Task[T]]): Def.Initialize[InputTask[T]] = macro inputTaskDynMacroImpl[T]
+  def inputTaskDyn[T](t: Def.Initialize[Task[T]]): Def.Initialize[InputTask[T]] =
+    macro inputTaskDynMacroImpl[T]
+  def taskIf[T](a: T): Def.Initialize[Task[T]] = macro taskIfMacroImpl[T]
+
+  private[sbt] def selectITask[A, B](
+      fab: Initialize[Task[Either[A, B]]],
+      fin: Initialize[Task[A => B]]
+  ): Initialize[Task[B]] =
+    fab.zipWith(fin)((ab, in) => TaskExtra.select(ab, in))
+
+  import Scoped.syntax._
+
+  // derived from select
+  private[sbt] def branchS[A, B, C](
+      x: Def.Initialize[Task[Either[A, B]]]
+  )(l: Def.Initialize[Task[A => C]])(r: Def.Initialize[Task[B => C]]): Def.Initialize[Task[C]] = {
+    val lhs = {
+      val innerLhs: Def.Initialize[Task[Either[A, Either[B, C]]]] =
+        x.map((fab: Either[A, B]) => fab.right.map(Left(_)))
+      val innerRhs: Def.Initialize[Task[A => Either[B, C]]] =
+        l.map((fn: A => C) => fn.andThen(Right(_)))
+      selectITask(innerLhs, innerRhs)
+    }
+    selectITask(lhs, r)
+  }
+
+  // derived from select
+  def ifS[A](
+      x: Def.Initialize[Task[Boolean]]
+  )(t: Def.Initialize[Task[A]])(e: Def.Initialize[Task[A]]): Def.Initialize[Task[A]] = {
+    val condition: Def.Initialize[Task[Either[Unit, Unit]]] =
+      x.map((p: Boolean) => if (p) Left(()) else Right(()))
+    val left: Def.Initialize[Task[Unit => A]] =
+      t.map((a: A) => { _ => a })
+    val right: Def.Initialize[Task[Unit => A]] =
+      e.map((a: A) => { _ => a })
+    branchS(condition)(left)(right)
+  }
+
+  /** Returns `PromiseWrap[A]`, which is a wrapper around `scala.concurrent.Promise`.
+   * When a task is typed promise (e.g. `Def.Initialize[Task[PromiseWrap[A]]]`),an implicit
+   * method called `await` is injected which will run in a thread outside of concurrent restriction budget.
+   */
+  def promise[A]: PromiseWrap[A] = new PromiseWrap[A]()
 
   // The following conversions enable the types Initialize[T], Initialize[Task[T]], and Task[T] to
   //  be used in task and setting macros as inputs with an ultimate result of type T
 
-  implicit def macroValueI[T](in: Initialize[T]): MacroValue[T] = ???
-  implicit def macroValueIT[T](in: Initialize[Task[T]]): MacroValue[T] = ???
-  implicit def macroValueIInT[T](in: Initialize[InputTask[T]]): InputEvaluated[T] = ???
-  implicit def taskMacroValueIT[T](in: Initialize[Task[T]]): MacroTaskValue[T] = ???
-  implicit def macroPrevious[T](in: TaskKey[T]): MacroPrevious[T] = ???
+  implicit def macroValueI[T](@deprecated("unused", "") in: Initialize[T]): MacroValue[T] = ???
 
-  // The following conversions enable the types Parser[T], Initialize[Parser[T]], and Initialize[State => Parser[T]] to
-  //  be used in the inputTask macro as an input with an ultimate result of type T
-  implicit def parserInitToInput[T](p: Initialize[Parser[T]]): ParserInput[T] = ???
-  implicit def parserInitStateToInput[T](p: Initialize[State => Parser[T]]): ParserInput[T] = ???
+  implicit def macroValueIT[T](@deprecated("unused", "") in: Initialize[Task[T]]): MacroValue[T] =
+    ???
+
+  implicit def macroValueIInT[T](
+      @deprecated("unused", "") in: Initialize[InputTask[T]]
+  ): InputEvaluated[T] = ???
+
+  implicit def taskMacroValueIT[T](
+      @deprecated("unused", "") in: Initialize[Task[T]]
+  ): MacroTaskValue[T] = ???
+
+  implicit def macroPrevious[T](@deprecated("unused", "") in: TaskKey[T]): MacroPrevious[T] = ???
+
+  // The following conversions enable the types Parser[T], Initialize[Parser[T]], and
+  // Initialize[State => Parser[T]] to be used in the inputTask macro as an input with an ultimate
+  // result of type T
+  implicit def parserInitToInput[T](
+      @deprecated("unused", "") p: Initialize[Parser[T]]
+  ): ParserInput[T] = ???
+
+  implicit def parserInitStateToInput[T](
+      @deprecated("unused", "") p: Initialize[State => Parser[T]]
+  ): ParserInput[T] = ???
 
   def settingKey[T](description: String): SettingKey[T] = macro std.KeyMacro.settingKeyImpl[T]
   def taskKey[T](description: String): TaskKey[T] = macro std.KeyMacro.taskKeyImpl[T]
   def inputKey[T](description: String): InputKey[T] = macro std.KeyMacro.inputKeyImpl[T]
 
-  private[sbt] def dummy[T: Manifest](name: String, description: String): (TaskKey[T], Task[T]) = (TaskKey[T](name, description, DTask), dummyTask(name))
-  private[sbt] def dummyTask[T](name: String): Task[T] =
-    {
-      import std.TaskExtra.{ task => newTask, _ }
-      val base: Task[T] = newTask(sys.error("Dummy task '" + name + "' did not get converted to a full task.")) named name
-      base.copy(info = base.info.set(isDummyTask, true))
-    }
-  private[sbt] def isDummy(t: Task[_]): Boolean = t.info.attributes.get(isDummyTask) getOrElse false
-  private[sbt] val isDummyTask = AttributeKey[Boolean]("is-dummy-task", "Internal: used to identify dummy tasks.  sbt injects values for these tasks at the start of task execution.", Invisible)
+  class InitOps[T](private val x: Initialize[T]) extends AnyVal {
+    def toTaskable: Taskable[T] = x
+  }
+
+  class InitTaskOps[T](private val x: Initialize[Task[T]]) extends AnyVal {
+    def toTaskable: Taskable[T] = x
+  }
+
+  /** This works around Scala 2.12.12's
+   * "a pure expression does nothing in statement position"
+   *
+   * {{{
+   * Def.unit(copyResources.value)
+   * Def.unit(compile.value)
+   * }}}
+   */
+  def unit(a: Any): Unit = ()
+
+  private[sbt] def dummy[T: Manifest](name: String, description: String): (TaskKey[T], Task[T]) =
+    (TaskKey[T](name, description, DTask), dummyTask(name))
+
+  private[sbt] def dummyTask[T](name: String): Task[T] = {
+    import std.TaskExtra.{ task => newTask, _ }
+    val base: Task[T] = newTask(
+      sys.error("Dummy task '" + name + "' did not get converted to a full task.")
+    ) named name
+    base.copy(info = base.info.set(isDummyTask, true))
+  }
+
+  private[sbt] def isDummy(t: Task[_]): Boolean =
+    t.info.attributes.get(isDummyTask) getOrElse false
+
+  private[sbt] val isDummyTask = AttributeKey[Boolean](
+    "is-dummy-task",
+    "Internal: used to identify dummy tasks.  sbt injects values for these tasks at the start of task execution.",
+    Invisible
+  )
+
   private[sbt] val (stateKey, dummyState) = dummy[State]("state", "Current build state.")
-  private[sbt] val (streamsManagerKey, dummyStreamsManager) = Def.dummy[std.Streams[ScopedKey[_]]]("streams-manager", "Streams manager, which provides streams for different contexts.")
+
+  private[sbt] val (streamsManagerKey, dummyStreamsManager) = Def.dummy[std.Streams[ScopedKey[_]]](
+    "streams-manager",
+    "Streams manager, which provides streams for different contexts."
+  )
 }
-// these need to be mixed into the sbt package object because the target doesn't involve Initialize or anything in Def
+
+// these need to be mixed into the sbt package object
+// because the target doesn't involve Initialize or anything in Def
 trait TaskMacroExtra {
-  implicit def macroValueT[T](in: Task[T]): std.MacroValue[T] = ???
-  implicit def macroValueIn[T](in: InputTask[T]): std.InputEvaluated[T] = ???
-  implicit def parserToInput[T](in: Parser[T]): std.ParserInput[T] = ???
-  implicit def stateParserToInput[T](in: State => Parser[T]): std.ParserInput[T] = ???
+  implicit def macroValueT[T](@deprecated("unused", "") in: Task[T]): std.MacroValue[T] = ???
+
+  implicit def macroValueIn[T](@deprecated("unused", "") in: InputTask[T]): std.InputEvaluated[T] =
+    ???
+
+  implicit def parserToInput[T](@deprecated("unused", "") in: Parser[T]): std.ParserInput[T] = ???
+
+  implicit def stateParserToInput[T](
+      @deprecated("unused", "") in: State => Parser[T]
+  ): std.ParserInput[T] = ???
+}
+
+sealed trait InitializeImplicits0 { self: Def.type =>
+  implicit def initOps[T](x: Def.Initialize[T]): Def.InitOps[T] = new Def.InitOps(x)
+}
+
+sealed trait InitializeImplicits extends InitializeImplicits0 { self: Def.type =>
+  implicit def initTaskOps[T](x: Def.Initialize[Task[T]]): Def.InitTaskOps[T] =
+    new Def.InitTaskOps(x)
 }
diff --git a/main-settings/src/main/scala/sbt/DelegateIndex.scala b/main-settings/src/main/scala/sbt/DelegateIndex.scala
index 66df26abe..e187ce931 100644
--- a/main-settings/src/main/scala/sbt/DelegateIndex.scala
+++ b/main-settings/src/main/scala/sbt/DelegateIndex.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 sealed trait DelegateIndex {
@@ -7,11 +14,21 @@ sealed trait DelegateIndex {
   //	def extra(ref: ProjectRef, e: AttributeMap): Seq[ScopeAxis[AttributeMap]]
 }
 private final class DelegateIndex0(refs: Map[ProjectRef, ProjectDelegates]) extends DelegateIndex {
-  def project(ref: ProjectRef): Seq[ScopeAxis[ResolvedReference]] = refs.get(ref) match { case Some(pd) => pd.refs; case None => Nil }
+  def project(ref: ProjectRef): Seq[ScopeAxis[ResolvedReference]] = refs.get(ref) match {
+    case Some(pd) => pd.refs; case None => Nil
+  }
   def config(ref: ProjectRef, conf: ConfigKey): Seq[ScopeAxis[ConfigKey]] =
     refs.get(ref) match {
-      case Some(pd) => pd.confs.get(conf) match { case Some(cs) => cs; case None => Select(conf) :: Global :: Nil }
-      case None     => Select(conf) :: Global :: Nil
+      case Some(pd) =>
+        pd.confs.get(conf) match {
+          case Some(cs) => cs
+          case None     => (Select(conf): ScopeAxis[ConfigKey]) :: (Zero: ScopeAxis[ConfigKey]) :: Nil
+        }
+      case None => (Select(conf): ScopeAxis[ConfigKey]) :: (Zero: ScopeAxis[ConfigKey]) :: Nil
     }
 }
-private final class ProjectDelegates(val ref: ProjectRef, val refs: Seq[ScopeAxis[ResolvedReference]], val confs: Map[ConfigKey, Seq[ScopeAxis[ConfigKey]]])
\ No newline at end of file
+private final class ProjectDelegates(
+    val ref: ProjectRef,
+    val refs: Seq[ScopeAxis[ResolvedReference]],
+    val confs: Map[ConfigKey, Seq[ScopeAxis[ConfigKey]]]
+)
diff --git a/main-settings/src/main/scala/sbt/InputTask.scala b/main-settings/src/main/scala/sbt/InputTask.scala
index cd48e4940..faea5bd00 100644
--- a/main-settings/src/main/scala/sbt/InputTask.scala
+++ b/main-settings/src/main/scala/sbt/InputTask.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import sbt.internal.util.complete.Parser
@@ -5,6 +12,7 @@ import Def.{ Initialize, ScopedKey }
 import std.TaskExtra._
 import sbt.internal.util.{ ~>, AttributeKey, Types }
 import sbt.internal.util.Types._
+import sbt.internal.util.Util._
 
 /** Parses input and produces a task to run.  Constructed using the companion object. */
 final class InputTask[T] private (val parser: State => Parser[Task[T]]) {
@@ -14,14 +22,16 @@ final class InputTask[T] private (val parser: State => Parser[Task[T]]) {
   def partialInput(in: String): InputTask[T] =
     new InputTask[T](s => Parser(parser(s))(in))
 
-  def fullInput(in: String): InputTask[T] = new InputTask[T](s =>
-    Parser.parse(in, parser(s)) match {
-      case Right(v) => Parser.success(v)
-      case Left(msg) =>
-        val indented = msg.lines.map("   " + _).mkString("\n")
-        Parser.failure(s"Invalid programmatic input:\n$indented")
-    }
-  )
+  def fullInput(in: String): InputTask[T] =
+    new InputTask[T](
+      s =>
+        Parser.parse(in, parser(s)) match {
+          case Right(v) => Parser.success(v)
+          case Left(msg) =>
+            val indented = msg.linesIterator.map("   " + _).mkString("\n")
+            Parser.failure(s"Invalid programmatic input:\n$indented")
+        }
+    )
 }
 
 object InputTask {
@@ -31,21 +41,28 @@ object InputTask {
 
     import std.FullInstance._
     def toTask(in: String): Initialize[Task[T]] = flatten(
-      (Def.stateKey zipWith i)((sTask, it) =>
-        sTask map (s =>
-          Parser.parse(in, it.parser(s)) match {
-            case Right(t) => Def.value(t)
-            case Left(msg) =>
-              val indented = msg.lines.map("   " + _).mkString("\n")
-              sys.error(s"Invalid programmatic input:\n$indented")
-          }
-        )
+      (Def.stateKey zipWith i)(
+        (sTask, it) =>
+          sTask map (
+              s =>
+                Parser.parse(in, it.parser(s)) match {
+                  case Right(t) => Def.value(t)
+                  case Left(msg) =>
+                    val indented = msg.linesIterator.map("   " + _).mkString("\n")
+                    sys.error(s"Invalid programmatic input:\n$indented")
+                }
+            )
       )
     )
   }
 
-  implicit def inputTaskParsed[T](in: InputTask[T]): std.ParserInputTask[T] = ???
-  implicit def inputTaskInitParsed[T](in: Initialize[InputTask[T]]): std.ParserInputTask[T] = ???
+  implicit def inputTaskParsed[T](
+      @deprecated("unused", "") in: InputTask[T]
+  ): std.ParserInputTask[T] = ???
+
+  implicit def inputTaskInitParsed[T](
+      @deprecated("unused", "") in: Initialize[InputTask[T]]
+  ): std.ParserInputTask[T] = ???
 
   def make[T](p: State => Parser[Task[T]]): InputTask[T] = new InputTask[T](p)
 
@@ -57,53 +74,64 @@ object InputTask {
 
   def free[I, T](p: State => Parser[I])(c: I => Task[T]): InputTask[T] = free(s => p(s) map c)
 
-  def separate[I, T](p: State => Parser[I])(action: Initialize[I => Task[T]]): Initialize[InputTask[T]] =
+  def separate[I, T](
+      p: State => Parser[I]
+  )(action: Initialize[I => Task[T]]): Initialize[InputTask[T]] =
     separate(Def value p)(action)
 
-  def separate[I, T](p: Initialize[State => Parser[I]])(action: Initialize[I => Task[T]]): Initialize[InputTask[T]] =
+  def separate[I, T](
+      p: Initialize[State => Parser[I]]
+  )(action: Initialize[I => Task[T]]): Initialize[InputTask[T]] =
     p.zipWith(action)((parser, act) => free(parser)(act))
 
   /** Constructs an InputTask that accepts no user input. */
   def createFree[T](action: Initialize[Task[T]]): Initialize[InputTask[T]] =
-    action { tsk => free(emptyParser)(const(tsk)) }
+    action { tsk =>
+      free(emptyParser)(const(tsk))
+    }
 
   /**
    * Constructs an InputTask from:
    *  a) a Parser constructed using other Settings, but not Tasks
    *  b) a dynamically constructed Task that uses Settings, Tasks, and the result of parsing.
    */
-  def createDyn[I, T](p: Initialize[State => Parser[I]])(action: Initialize[Task[I => Initialize[Task[T]]]]): Initialize[InputTask[T]] =
+  def createDyn[I, T](
+      p: Initialize[State => Parser[I]]
+  )(action: Initialize[Task[I => Initialize[Task[T]]]]): Initialize[InputTask[T]] =
     separate(p)(std.FullInstance.flattenFun[I, T](action))
 
   /** A dummy parser that consumes no input and produces nothing useful (unit).*/
-  def emptyParser: State => Parser[Unit] = Types.const(sbt.internal.util.complete.DefaultParsers.success(()))
+  def emptyParser: State => Parser[Unit] =
+    Types.const(sbt.internal.util.complete.DefaultParsers.success(()))
 
   /** Implementation detail that is public because it is used by a macro.*/
-  def parserAsInput[T](p: Parser[T]): Initialize[State => Parser[T]] = Def.valueStrict(Types.const(p))
+  def parserAsInput[T](p: Parser[T]): Initialize[State => Parser[T]] =
+    Def.valueStrict(Types.const(p))
 
   /** Implementation detail that is public because it is used by a macro.*/
-  def initParserAsInput[T](i: Initialize[Parser[T]]): Initialize[State => Parser[T]] = i(Types.const)
+  def initParserAsInput[T](i: Initialize[Parser[T]]): Initialize[State => Parser[T]] =
+    i(Types.const[State, Parser[T]])
 
   @deprecated("Use another InputTask constructor or the `Def.inputTask` macro.", "0.13.0")
-  def apply[I, T](p: Initialize[State => Parser[I]])(action: TaskKey[I] => Initialize[Task[T]]): Initialize[InputTask[T]] =
-    {
-      val dummyKey = localKey[Task[I]]
-      val (marker, dummy) = dummyTask[I]
-      val it = action(TaskKey(dummyKey)) mapConstant subResultForDummy(dummyKey, dummy)
-      val act = it { tsk => (value: I) => subForDummy(marker, value, tsk) }
-      separate(p)(act)
+  def apply[I, T](
+      p: Initialize[State => Parser[I]]
+  )(action: TaskKey[I] => Initialize[Task[T]]): Initialize[InputTask[T]] = {
+    val dummyKey = localKey[Task[I]]
+    val (marker, dummy) = dummyTask[I]
+    val it = action(TaskKey(dummyKey)) mapConstant subResultForDummy(dummyKey, dummy)
+    val act = it { tsk => (value: I) =>
+      subForDummy(marker, value, tsk)
     }
-
-  @deprecated("Use another InputTask constructor or the `Def.inputTask` macro.", "0.13.0")
-  def apply[I, T](p: State => Parser[I])(action: TaskKey[I] => Initialize[Task[T]]): Initialize[InputTask[T]] =
-    apply(Def.value(p))(action)
+    separate(p)(act)
+  }
 
   /**
    * The proper solution is to have a Manifest context bound and accept slight source incompatibility,
    * The affected InputTask construction methods are all deprecated and so it is better to keep complete
    * compatibility.  Because the AttributeKey is local, it uses object equality and the manifest is not used.
    */
-  private[this] def localKey[T]: AttributeKey[T] = AttributeKey.local[Unit].asInstanceOf[AttributeKey[T]]
+  private[this] def localKey[T]: AttributeKey[T] =
+    AttributeKey.local[Unit].asInstanceOf[AttributeKey[T]]
 
   private[this] def subResultForDummy[I](dummyKey: AttributeKey[Task[I]], dummyTask: Task[I]) =
     new (ScopedKey ~> Option) {
@@ -116,34 +144,36 @@ object InputTask {
           None
     }
 
-  private[this] def dummyTask[I]: (AttributeKey[Option[I]], Task[I]) =
-    {
-      val key = localKey[Option[I]]
-      val f: () => I = () => sys.error(s"Internal sbt error: InputTask stub was not substituted properly.")
-      val t: Task[I] = Task(Info[I]().set(key, None), Pure(f, false))
-      (key, t)
-    }
-  private[this] def subForDummy[I, T](marker: AttributeKey[Option[I]], value: I, task: Task[T]): Task[T] =
-    {
-      val seen = new java.util.IdentityHashMap[Task[_], Task[_]]
-      lazy val f: Task ~> Task = new (Task ~> Task) {
-        def apply[A](t: Task[A]): Task[A] =
-          {
-            val t0 = seen.get(t)
-            if (t0 == null) {
-              val newAction =
-                if (t.info.get(marker).isDefined)
-                  Pure(() => value.asInstanceOf[A], inline = true)
-                else
-                  t.work.mapTask(f)
-              val newTask = Task(t.info, newAction)
-              seen.put(t, newTask)
-              newTask
-            } else
-              t0.asInstanceOf[Task[A]]
-          }
-      }
-      f(task)
-    }
-}
+  private[this] def dummyTask[I]: (AttributeKey[Option[I]], Task[I]) = {
+    val key = localKey[Option[I]]
+    val f: () => I = () =>
+      sys.error(s"Internal sbt error: InputTask stub was not substituted properly.")
+    val t: Task[I] = Task(Info[I]().set(key, none), Pure(f, false))
+    (key, t)
+  }
 
+  private[this] def subForDummy[I, T](
+      marker: AttributeKey[Option[I]],
+      value: I,
+      task: Task[T]
+  ): Task[T] = {
+    val seen = new java.util.IdentityHashMap[Task[_], Task[_]]
+    lazy val f: Task ~> Task = new (Task ~> Task) {
+      def apply[A](t: Task[A]): Task[A] = {
+        val t0 = seen.get(t)
+        if (t0 == null) {
+          val newAction =
+            if (t.info.get(marker).isDefined)
+              (Pure[A](() => value.asInstanceOf[A], inline = true): Action[A])
+            else
+              t.work.mapTask(f)
+          val newTask = Task(t.info, newAction)
+          seen.put(t, newTask)
+          newTask
+        } else
+          t0.asInstanceOf[Task[A]]
+      }
+    }
+    f(task)
+  }
+}
diff --git a/main-settings/src/main/scala/sbt/KeyRanks.scala b/main-settings/src/main/scala/sbt/KeyRanks.scala
index 327fd2bc6..252dd10cd 100644
--- a/main-settings/src/main/scala/sbt/KeyRanks.scala
+++ b/main-settings/src/main/scala/sbt/KeyRanks.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 object KeyRanks {
diff --git a/main-settings/src/main/scala/sbt/Previous.scala b/main-settings/src/main/scala/sbt/Previous.scala
index 28cc03043..acd6ba18f 100644
--- a/main-settings/src/main/scala/sbt/Previous.scala
+++ b/main-settings/src/main/scala/sbt/Previous.scala
@@ -1,99 +1,174 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import Def.{ Initialize, ScopedKey, streamsManagerKey }
-import Previous._
-import sbt.internal.util.{ ~>, IMap, RMap }
-
-import java.io.{ InputStream, OutputStream }
+import sbt.Def.{ Initialize, ScopedKey }
+import sbt.Previous._
+import sbt.Scope.Global
+import sbt.SlashSyntax0._
+import sbt.internal.util._
+import sbt.std.TaskExtra._
+import sbt.util.StampedFormat
+import sjsonnew.JsonFormat
 
 import scala.util.control.NonFatal
 
-import sbinary.{ DefaultProtocol, Format }
-import DefaultProtocol.{ StringFormat, withStamp }
-
 /**
  * Reads the previous value of tasks on-demand.  The read values are cached so that they are only read once per task execution.
  * `referenced` provides the `Format` to use for each key.
  */
-private[sbt] final class Previous(streams: Streams, referenced: IMap[ScopedTaskKey, Referenced]) {
-  private[this] val map = referenced.mapValues(toValue)
-  private[this] def toValue = new (Referenced ~> ReferencedValue) { def apply[T](x: Referenced[T]) = new ReferencedValue(x) }
+private[sbt] final class Previous(streams: Streams, referenced: IMap[Previous.Key, Referenced]) {
+  private[this] var map = IMap.empty[Previous.Key, ReferencedValue]
+  // We can't use mapValues to transform the map because mapValues is lazy and evaluates the
+  // transformation function every time a value is fetched from the map, defeating the entire
+  // purpose of ReferencedValue.
+  for (referenced.TPair(k, v) <- referenced.toTypedSeq) map = map.put(k, new ReferencedValue(v))
 
   private[this] final class ReferencedValue[T](referenced: Referenced[T]) {
-    import referenced.{ stamped, task }
-    lazy val previousValue: Option[T] = {
-      val in = streams(task).readBinary(task, StreamName)
-      try read(in, stamped) finally in.close()
-    }
+    lazy val previousValue: Option[T] = referenced.read(streams)
   }
 
-  /** Used by the .previous runtime implemention to get the previous value for task `key`. */
-  private def get[T](key: ScopedKey[Task[T]]): Option[T] =
+  /** Used by the .previous runtime implementation to get the previous value for task `key`. */
+  private def get[T](key: Key[T]): Option[T] =
     map.get(key).flatMap(_.previousValue)
 }
 object Previous {
-  private[sbt]type ScopedTaskKey[T] = ScopedKey[Task[T]]
+  import sjsonnew.BasicJsonProtocol.StringJsonFormat
+  private[sbt] type ScopedTaskKey[T] = ScopedKey[Task[T]]
+  private type AnyTaskKey = ScopedTaskKey[Any]
   private type Streams = sbt.std.Streams[ScopedKey[_]]
 
   /** The stream where the task value is persisted. */
   private final val StreamName = "previous"
+  private[sbt] final val DependencyDirectory = "previous-dependencies"
 
   /** Represents a reference task.previous*/
-  private[sbt] final class Referenced[T](val task: ScopedKey[Task[T]], val format: Format[T]) {
-    lazy val stamped = withStamp(task.key.manifest.toString)(format)
+  private[sbt] final class Referenced[T](val key: Key[T], val format: JsonFormat[T]) {
+    def this(task: ScopedTaskKey[T], format: JsonFormat[T]) = this(Key(task, task), format)
+    @deprecated("unused", "1.3.0")
+    private[sbt] def task: ScopedKey[Task[T]] = key.task
+    lazy val stamped: JsonFormat[T] =
+      StampedFormat.withStamp(key.task.key.manifest.toString)(format)
     def setTask(newTask: ScopedKey[Task[T]]) = new Referenced(newTask, format)
+    private[sbt] def read(streams: Streams): Option[T] =
+      try Option(streams(key.cacheKey).cacheStoreFactory.make(StreamName).read[T]()(stamped))
+      catch { case NonFatal(_) => None }
   }
 
-  private[sbt] val references = SettingKey[References]("previous-references", "Collects all static references to previous values of tasks.", KeyRanks.Invisible)
-  private[sbt] val cache = TaskKey[Previous]("previous-cache", "Caches previous values of tasks read from disk for the duration of a task execution.", KeyRanks.Invisible)
+  private[sbt] val references = SettingKey[References](
+    "previous-references",
+    "Collects all static references to previous values of tasks.",
+    KeyRanks.Invisible
+  )
+  private[sbt] val cache = TaskKey[Previous](
+    "previous-cache",
+    "Caches previous values of tasks read from disk for the duration of a task execution.",
+    KeyRanks.Invisible
+  )
+
+  private[sbt] class Key[T](val task: ScopedKey[Task[T]], val enclosing: AnyTaskKey) {
+    override def equals(o: Any): Boolean = o match {
+      case that: Key[_] => this.task == that.task && this.enclosing == that.enclosing
+      case _            => false
+    }
+    override def hashCode(): Int = (task.## * 31) ^ enclosing.##
+    def cacheKey: AnyTaskKey = {
+      if (task == enclosing) task.asInstanceOf[ScopedKey[Task[Any]]]
+      else {
+        val am = enclosing.scope.extra match {
+          case Select(a) => a.put(scopedKeyAttribute, task.asInstanceOf[AnyTaskKey])
+          case _         => AttributeMap.empty.put(scopedKeyAttribute, task.asInstanceOf[AnyTaskKey])
+        }
+        Def.ScopedKey(enclosing.scope.copy(extra = Select(am)), enclosing.key)
+      }
+    }.asInstanceOf[AnyTaskKey]
+  }
+  private[sbt] object Key {
+    def apply[T, U](key: ScopedKey[Task[T]], enclosing: ScopedKey[Task[U]]): Key[T] =
+      new Key(key, enclosing.asInstanceOf[AnyTaskKey])
+  }
 
   /** Records references to previous task value. This should be completely populated after settings finish loading. */
   private[sbt] final class References {
-    private[this] var map = IMap.empty[ScopedTaskKey, Referenced]
+    private[this] var map = IMap.empty[Key, Referenced]
 
-    // TODO: this arbitrarily chooses a Format.
+    @deprecated("unused", "1.3.0")
+    def recordReference[T](key: ScopedKey[Task[T]], format: JsonFormat[T]): Unit =
+      recordReference(Key(key, key), format)
+    // TODO: this arbitrarily chooses a JsonFormat.
     // The need to choose is a fundamental problem with this approach, but this should at least make a stable choice.
-    def recordReference[T](key: ScopedKey[Task[T]], format: Format[T]): Unit = synchronized {
+    def recordReference[T](key: Key[T], format: JsonFormat[T]): Unit = synchronized {
       map = map.put(key, new Referenced(key, format))
     }
-    def getReferences: IMap[ScopedTaskKey, Referenced] = synchronized { map }
+    def getReferences: IMap[Key, Referenced] = synchronized { map }
   }
 
   /** Persists values of tasks t where there is some task referencing it via t.previous. */
-  private[sbt] def complete(referenced: References, results: RMap[Task, Result], streams: Streams): Unit =
-    {
-      val map = referenced.getReferences
-      def impl[T](key: ScopedKey[_], result: T): Unit =
-        for (i <- map.get(key.asInstanceOf[ScopedTaskKey[T]])) {
-          val out = streams.apply(i.task).binary(StreamName)
-          try write(out, i.stamped, result) finally out.close()
-        }
+  private[sbt] def complete(
+      referenced: References,
+      results: RMap[Task, Result],
+      streams: Streams
+  ): Unit = {
+    val map = referenced.getReferences
+    val reverse = map.keys.groupBy(_.task)
 
-      for {
-        results.TPair(Task(info, _), Value(result)) <- results.toTypedSeq
-        key <- info.attributes get Def.taskDefinitionKey
-      } impl(key, result)
+    // We first collect all of the successful tasks and write their scoped key into a map
+    // along with their values.
+    val successfulTaskResults = (for {
+      results.TPair(task, Value(v)) <- results.toTypedSeq
+      key <- task.info.attributes.get(Def.taskDefinitionKey).asInstanceOf[Option[AnyTaskKey]]
+    } yield key -> v).toMap
+    // We then traverse the successful results and look up all of the referenced values for
+    // each of these tasks. This can be a many to one relationship if multiple tasks refer
+    // the previous value of another task. For each reference we find, we check if the task has
+    // been successfully evaluated. If so, we write it to the appropriate previous cache for
+    // the completed task.
+    for {
+      (k, v) <- successfulTaskResults
+      keys <- reverse.get(k)
+      key <- keys if successfulTaskResults.contains(key.enclosing)
+      ref <- map.get(key.asInstanceOf[Key[Any]])
+    } {
+      val out = streams(key.cacheKey).cacheStoreFactory.make(StreamName)
+      try out.write(v)(ref.stamped)
+      catch { case NonFatal(_) => }
     }
-
-  private def read[T](stream: InputStream, format: Format[T]): Option[T] =
-    try Some(format.reads(stream))
-    catch { case NonFatal(e) => None }
-
-  private def write[T](stream: OutputStream, format: Format[T], value: T): Unit =
-    try format.writes(stream, value)
-    catch { case NonFatal(e) => () }
+  }
+  private[sbt] val scopedKeyAttribute = AttributeKey[AnyTaskKey](
+    "previous-scoped-key-attribute",
+    "Specifies a scoped key for a task on which .previous is called. Used to " +
+      "set the cache directory for the task-specific previous value: see Previous.runtimeInEnclosingTask."
+  )
 
   /** Public as a macro implementation detail.  Do not call directly. */
-  def runtime[T](skey: TaskKey[T])(implicit format: Format[T]): Initialize[Task[Option[T]]] =
-    {
-      val inputs = (cache in Global) zip Def.validated(skey, selfRefOk = true) zip (references in Global)
-      inputs {
-        case ((prevTask, resolved), refs) =>
-          refs.recordReference(resolved, format) // always evaluated on project load
-          import std.TaskExtra._
-          prevTask.map(_ get resolved) // evaluated if this task is evaluated
-      }
+  def runtime[T](skey: TaskKey[T])(implicit format: JsonFormat[T]): Initialize[Task[Option[T]]] = {
+    val inputs = (Global / cache) zip Def.validated(skey, selfRefOk = true) zip (Global / references)
+    inputs {
+      case ((prevTask, resolved), refs) =>
+        val key = Key(resolved, resolved)
+        refs.recordReference(key, format) // always evaluated on project load
+        prevTask.map(_.get(key)) // evaluated if this task is evaluated
     }
+  }
 
-  private[sbt] def cacheSetting = (streamsManagerKey, references) map { (s, refs) => new Previous(s, refs.getReferences) }
+  /** Public as a macro implementation detail.  Do not call directly. */
+  def runtimeInEnclosingTask[T](skey: TaskKey[T])(
+      implicit format: JsonFormat[T]
+  ): Initialize[Task[Option[T]]] = {
+    val inputs = (Global / cache)
+      .zip(Def.validated(skey, selfRefOk = true))
+      .zip(Global / references)
+      .zip(Def.resolvedScoped)
+    inputs {
+      case (((prevTask, resolved), refs), inTask: ScopedKey[Task[_]] @unchecked) =>
+        val key = Key(resolved, inTask)
+        refs.recordReference(key, format) // always evaluated on project load
+        prevTask.map(_.get(key)) // evaluated if this task is evaluated
+    }
+  }
 }
diff --git a/main-settings/src/main/scala/sbt/PromiseWrap.scala b/main-settings/src/main/scala/sbt/PromiseWrap.scala
new file mode 100644
index 000000000..ec9a50817
--- /dev/null
+++ b/main-settings/src/main/scala/sbt/PromiseWrap.scala
@@ -0,0 +1,22 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import scala.concurrent.{ Promise => XPromise }
+
+final class PromiseWrap[A] {
+  private[sbt] val underlying: XPromise[A] = XPromise()
+  def complete(result: Result[A]): Unit =
+    result match {
+      case Inc(cause)   => underlying.failure(cause)
+      case Value(value) => underlying.success(value)
+    }
+  def success(value: A): Unit = underlying.success(value)
+  def failure(cause: Throwable): Unit = underlying.failure(cause)
+  def isCompleted: Boolean = underlying.isCompleted
+}
diff --git a/main-settings/src/main/scala/sbt/Reference.scala b/main-settings/src/main/scala/sbt/Reference.scala
index 80055fc1a..74267ba89 100644
--- a/main-settings/src/main/scala/sbt/Reference.scala
+++ b/main-settings/src/main/scala/sbt/Reference.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
@@ -18,21 +22,30 @@ sealed trait ResolvedReference extends Reference
 
 /** Identifies a build. */
 sealed trait BuildReference extends Reference
+
 /** Identifies the build for the current context. */
 final case object ThisBuild extends BuildReference
+
 /** Uniquely identifies a build by a URI. */
 final case class BuildRef(build: URI) extends BuildReference with ResolvedReference
 
 /** Identifies a project. */
 sealed trait ProjectReference extends Reference
+
 /** Uniquely references a project by a URI and a project identifier String. */
-final case class ProjectRef(build: URI, project: String) extends ProjectReference with ResolvedReference
+final case class ProjectRef(build: URI, project: String)
+    extends ProjectReference
+    with ResolvedReference
+
 /** Identifies a project in the current build context. */
 final case class LocalProject(project: String) extends ProjectReference
+
 /** Identifies the root project in the specified build. */
 final case class RootProject(build: URI) extends ProjectReference
+
 /** Identifies the root project in the current build context. */
 final case object LocalRootProject extends ProjectReference
+
 /** Identifies the project for the current context. */
 final case object ThisProject extends ProjectReference
 
@@ -40,27 +53,22 @@ object ProjectRef {
   def apply(base: File, id: String): ProjectRef = ProjectRef(IO toURI base, id)
 }
 object RootProject {
+
   /** Reference to the root project at 'base'.*/
   def apply(base: File): RootProject = RootProject(IO toURI base)
 }
 object Reference {
-  implicit val resolvedReferenceOrdering: Ordering[ResolvedReference] = new Ordering[ResolvedReference] {
-    def compare(a: ResolvedReference, b: ResolvedReference): Int = (a, b) match {
-      case (ba: BuildRef, bb: BuildRef)     => buildRefOrdering.compare(ba, bb)
-      case (pa: ProjectRef, pb: ProjectRef) => projectRefOrdering.compare(pa, pb)
-      case (_: BuildRef, _: ProjectRef)     => -1
-      case (_: ProjectRef, _: BuildRef)     => 1
-    }
-  }
-  implicit val buildRefOrdering: Ordering[BuildRef] = new Ordering[BuildRef] {
-    def compare(a: BuildRef, b: BuildRef): Int = a.build compareTo b.build
+  implicit val resolvedReferenceOrdering: Ordering[ResolvedReference] = {
+    case (ba: BuildRef, bb: BuildRef)     => buildRefOrdering.compare(ba, bb)
+    case (pa: ProjectRef, pb: ProjectRef) => projectRefOrdering.compare(pa, pb)
+    case (_: BuildRef, _: ProjectRef)     => -1
+    case (_: ProjectRef, _: BuildRef)     => 1
   }
+  implicit val buildRefOrdering: Ordering[BuildRef] = (a, b) => a.build compareTo b.build
 
-  implicit val projectRefOrdering: Ordering[ProjectRef] = new Ordering[ProjectRef] {
-    def compare(a: ProjectRef, b: ProjectRef): Int = {
-      val bc = a.build compareTo b.build
-      if (bc == 0) a.project compareTo b.project else bc
-    }
+  implicit val projectRefOrdering: Ordering[ProjectRef] = (a, b) => {
+    val bc = a.build compareTo b.build
+    if (bc == 0) a.project compareTo b.project else bc
   }
 
   def display(ref: Reference): String =
@@ -80,13 +88,14 @@ object Reference {
       case LocalRootProject    => "{<this>}<root>"
       case LocalProject(id)    => "{<this>}" + id
       case RootProject(uri)    => "{" + uri + " }<root>"
-      case ProjectRef(uri, id) => "{" + uri + "}" + id
+      case ProjectRef(uri, id) => s"""ProjectRef(uri("$uri"), "$id")"""
     }
 
   def buildURI(ref: ResolvedReference): URI = ref match {
     case BuildRef(b)      => b
     case ProjectRef(b, _) => b
   }
+
   /** Extracts the build URI from a Reference if one has been explicitly defined.*/
   def uri(ref: Reference): Option[URI] = ref match {
     case RootProject(b)   => Some(b)
@@ -94,13 +103,4 @@ object Reference {
     case BuildRef(b)      => Some(b)
     case _                => None
   }
-
-  @deprecated("Explicitly wrap the URI in a call to RootProject.", "0.13.0")
-  implicit def uriToRef(u: URI): ProjectReference = RootProject(u)
-
-  @deprecated("Explicitly wrap the File in a call to RootProject.", "0.13.0")
-  implicit def fileToRef(f: File): ProjectReference = RootProject(f)
-
-  @deprecated("Explicitly wrap the String in a call to LocalProject.", "0.13.0")
-  implicit def stringToReference(s: String): ProjectReference = LocalProject(s)
 }
diff --git a/main-settings/src/main/scala/sbt/Remove.scala b/main-settings/src/main/scala/sbt/Remove.scala
index ac33e0b67..e09555f5b 100644
--- a/main-settings/src/main/scala/sbt/Remove.scala
+++ b/main-settings/src/main/scala/sbt/Remove.scala
@@ -1,22 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import scala.annotation.implicitNotFound
 
 object Remove {
-  @implicitNotFound(msg = "No implicit for Remove.Value[${A}, ${B}] found,\n  so ${B} cannot be removed from ${A}")
+  @implicitNotFound(
+    msg = "No implicit for Remove.Value[${A}, ${B}] found,\n  so ${B} cannot be removed from ${A}"
+  )
   trait Value[A, B] extends Any {
     def removeValue(a: A, b: B): A
   }
-  @implicitNotFound(msg = "No implicit for Remove.Values[${A}, ${B}] found,\n  so ${B} cannot be removed from ${A}")
+  @implicitNotFound(
+    msg = "No implicit for Remove.Values[${A}, ${B}] found,\n  so ${B} cannot be removed from ${A}"
+  )
   trait Values[A, -B] extends Any {
     def removeValues(a: A, b: B): A
   }
   trait Sequence[A, -B, T] extends Value[A, T] with Values[A, B]
 
-  implicit def removeSeq[T, V <: T]: Sequence[Seq[T], Seq[V], V] = new Sequence[Seq[T], Seq[V], V] {
-    def removeValue(a: Seq[T], b: V): Seq[T] = a filterNot b.==
-    def removeValues(a: Seq[T], b: Seq[V]): Seq[T] = a diff b
-  }
+  implicit def removeSeq[T, V <: T]: Sequence[Seq[T], Seq[V], V] =
+    new Sequence[Seq[T], Seq[V], V] {
+      def removeValue(a: Seq[T], b: V): Seq[T] = a filterNot b.==
+      def removeValues(a: Seq[T], b: Seq[V]): Seq[T] = a diff (b: Seq[T])
+    }
   implicit def removeOption[T]: Sequence[Seq[T], Option[T], Option[T]] =
     new Sequence[Seq[T], Option[T], Option[T]] {
       def removeValue(a: Seq[T], b: Option[T]): Seq[T] = b.fold(a)(a filterNot _.==)
diff --git a/main-settings/src/main/scala/sbt/Scope.scala b/main-settings/src/main/scala/sbt/Scope.scala
index 3541ea444..4fa31f51c 100644
--- a/main-settings/src/main/scala/sbt/Scope.scala
+++ b/main-settings/src/main/scala/sbt/Scope.scala
@@ -1,26 +1,63 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.net.URI
 
 import sbt.internal.util.{ AttributeKey, AttributeMap, Dag }
+import sbt.internal.util.Util._
 
 import sbt.io.IO
 
-final case class Scope(project: ScopeAxis[Reference], config: ScopeAxis[ConfigKey], task: ScopeAxis[AttributeKey[_]], extra: ScopeAxis[AttributeMap]) {
-  def in(project: Reference, config: ConfigKey): Scope = copy(project = Select(project), config = Select(config))
-  def in(config: ConfigKey, task: AttributeKey[_]): Scope = copy(config = Select(config), task = Select(task))
-  def in(project: Reference, task: AttributeKey[_]): Scope = copy(project = Select(project), task = Select(task))
-  def in(project: Reference, config: ConfigKey, task: AttributeKey[_]): Scope = copy(project = Select(project), config = Select(config), task = Select(task))
+final case class Scope(
+    project: ScopeAxis[Reference],
+    config: ScopeAxis[ConfigKey],
+    task: ScopeAxis[AttributeKey[_]],
+    extra: ScopeAxis[AttributeMap]
+) {
+  @deprecated(Scope.inIsDeprecated, "1.5.0")
+  def in(project: Reference, config: ConfigKey): Scope =
+    copy(project = Select(project), config = Select(config))
+
+  @deprecated(Scope.inIsDeprecated, "1.5.0")
+  def in(config: ConfigKey, task: AttributeKey[_]): Scope =
+    copy(config = Select(config), task = Select(task))
+
+  @deprecated(Scope.inIsDeprecated, "1.5.0")
+  def in(project: Reference, task: AttributeKey[_]): Scope =
+    copy(project = Select(project), task = Select(task))
+
+  @deprecated(Scope.inIsDeprecated, "1.5.0")
+  def in(project: Reference, config: ConfigKey, task: AttributeKey[_]): Scope =
+    copy(project = Select(project), config = Select(config), task = Select(task))
+
+  @deprecated(Scope.inIsDeprecated, "1.5.0")
   def in(project: Reference): Scope = copy(project = Select(project))
+
+  @deprecated(Scope.inIsDeprecated, "1.5.0")
   def in(config: ConfigKey): Scope = copy(config = Select(config))
+
+  @deprecated(Scope.inIsDeprecated, "1.5.0")
   def in(task: AttributeKey[_]): Scope = copy(task = Select(task))
+
+  override def toString: String = this match {
+    case Scope(Zero, Zero, Zero, Zero) => "Global"
+    case Scope(_, _, _, This)          => s"$project / $config / $task"
+    case _                             => s"Scope($project, $config, $task, $extra)"
+  }
 }
 object Scope {
-  val ThisScope = Scope(This, This, This, This)
-  val GlobalScope = Scope(Global, Global, Global, Global)
+  val ThisScope: Scope = Scope(This, This, This, This)
+  val Global: Scope = Scope(Zero, Zero, Zero, Zero)
+  val GlobalScope: Scope = Global
+
+  private[sbt] final val inIsDeprecated =
+    "`in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash"
 
   def resolveScope(thisScope: Scope, current: URI, rootProject: URI => String): Scope => Scope =
     resolveProject(current, rootProject) compose replaceThis(thisScope) compose subThisProject
@@ -28,8 +65,14 @@ object Scope {
   def resolveBuildScope(thisScope: Scope, current: URI): Scope => Scope =
     buildResolve(current) compose replaceThis(thisScope) compose subThisProject
 
-  def replaceThis(thisScope: Scope): Scope => Scope = (scope: Scope) =>
-    Scope(subThis(thisScope.project, scope.project), subThis(thisScope.config, scope.config), subThis(thisScope.task, scope.task), subThis(thisScope.extra, scope.extra))
+  def replaceThis(thisScope: Scope): Scope => Scope =
+    (scope: Scope) =>
+      Scope(
+        subThis(thisScope.project, scope.project),
+        subThis(thisScope.config, scope.config),
+        subThis(thisScope.task, scope.task),
+        subThis(thisScope.extra, scope.extra)
+      )
 
   def subThis[T](sub: ScopeAxis[T], into: ScopeAxis[T]): ScopeAxis[T] =
     if (into == This) sub else into
@@ -49,11 +92,10 @@ object Scope {
       case _            => scope.copy(task = Select(key))
     }
 
-  def mapReference(f: Reference => Reference): Scope => Scope =
-    {
-      case Scope(Select(ref), a, b, c) => Scope(Select(f(ref)), a, b, c)
-      case x                           => x
-    }
+  def mapReference(f: Reference => Reference): Scope => Scope = {
+    case Scope(Select(ref), a, b, c) => Scope(Select(f(ref)), a, b, c)
+    case x                           => x
+  }
   def resolveProject(uri: URI, rootProject: URI => String): Scope => Scope =
     mapReference(ref => resolveReference(uri, rootProject, ref))
   def buildResolve(uri: URI): Scope => Scope =
@@ -75,7 +117,7 @@ object Scope {
       case LocalProject(id)    => ProjectRef(current, id)
       case RootProject(uri)    => RootProject(resolveBuild(current, uri))
       case ProjectRef(uri, id) => ProjectRef(resolveBuild(current, uri), id)
-      case ThisProject         => RootProject(current) // Is this right? It was an inexhaustive match before..
+      case ThisProject         => ThisProject // haven't exactly "resolved" anything..
     }
   def resolveBuild(current: URI, uri: URI): URI =
     if (!uri.isAbsolute && current.isOpaque && uri.getSchemeSpecificPart == ".")
@@ -83,20 +125,27 @@ object Scope {
     else
       IO.directoryURI(current resolve uri)
 
-  def resolveReference(current: URI, rootProject: URI => String, ref: Reference): ResolvedReference =
+  def resolveReference(
+      current: URI,
+      rootProject: URI => String,
+      ref: Reference
+  ): ResolvedReference =
     ref match {
       case br: BuildReference   => resolveBuildRef(current, br)
       case pr: ProjectReference => resolveProjectRef(current, rootProject, pr)
     }
 
-  def resolveProjectRef(current: URI, rootProject: URI => String, ref: ProjectReference): ProjectRef =
+  def resolveProjectRef(
+      current: URI,
+      rootProject: URI => String,
+      ref: ProjectReference
+  ): ProjectRef =
     ref match {
-      case LocalRootProject => ProjectRef(current, rootProject(current))
-      case LocalProject(id) => ProjectRef(current, id)
-      case RootProject(uri) =>
-        val res = resolveBuild(current, uri); ProjectRef(res, rootProject(res))
+      case LocalRootProject    => ProjectRef(current, rootProject(current))
+      case LocalProject(id)    => ProjectRef(current, id)
+      case RootProject(uri)    => val u = resolveBuild(current, uri); ProjectRef(u, rootProject(u))
       case ProjectRef(uri, id) => ProjectRef(resolveBuild(current, uri), id)
-      case ThisProject         => ProjectRef(current, rootProject(current)) // Is this right? It was an inexhaustive match before..
+      case ThisProject         => sys.error("Cannot resolve ThisProject w/o the current project")
     }
   def resolveBuildRef(current: URI, ref: BuildReference): BuildRef =
     ref match {
@@ -104,19 +153,100 @@ object Scope {
       case BuildRef(uri) => BuildRef(resolveBuild(current, uri))
     }
 
-  def display(config: ConfigKey): String = config.name + ":"
-  def display(scope: Scope, sep: String): String = displayMasked(scope, sep, showProject, ScopeMask())
-  def displayMasked(scope: Scope, sep: String, mask: ScopeMask): String = displayMasked(scope, sep, showProject, mask)
-  def display(scope: Scope, sep: String, showProject: Reference => String): String = displayMasked(scope, sep, showProject, ScopeMask())
-  def displayMasked(scope: Scope, sep: String, showProject: Reference => String, mask: ScopeMask): String =
-    {
-      import scope.{ project, config, task, extra }
-      val configPrefix = config.foldStrict(display, "*:", ".:")
-      val taskPrefix = task.foldStrict(_.label + "::", "", ".::")
-      val extras = extra.foldStrict(_.entries.map(_.toString).toList, Nil, Nil)
+  def display(config: ConfigKey): String = guessConfigIdent(config.name) + " /"
+
+  private[sbt] val configIdents: Map[String, String] =
+    Map(
+      "it" -> "IntegrationTest",
+      "scala-tool" -> "ScalaTool",
+      "plugin" -> "CompilerPlugin"
+    )
+  private[sbt] val configIdentsInverse: Map[String, String] =
+    configIdents map { _.swap }
+
+  private[sbt] def guessConfigIdent(conf: String): String =
+    configIdents.applyOrElse(conf, (x: String) => x.capitalize)
+
+  private[sbt] def unguessConfigIdent(conf: String): String =
+    configIdentsInverse.applyOrElse(conf, (x: String) => x.take(1).toLowerCase + x.drop(1))
+
+  def displayConfigKey012Style(config: ConfigKey): String = config.name + ":"
+
+  def display(scope: Scope, sep: String): String =
+    displayMasked(scope, sep, showProject, ScopeMask())
+
+  def display(scope: Scope, sep: String, showProject: Reference => String): String =
+    displayMasked(scope, sep, showProject, ScopeMask())
+
+  private[sbt] def displayPedantic(scope: Scope, sep: String): String =
+    displayMasked(scope, sep, showProject, ScopeMask(), true)
+
+  def displayMasked(scope: Scope, sep: String, mask: ScopeMask): String =
+    displayMasked(scope, sep, showProject, mask)
+
+  def displayMasked(scope: Scope, sep: String, mask: ScopeMask, showZeroConfig: Boolean): String =
+    displayMasked(scope, sep, showProject, mask, showZeroConfig)
+
+  def displayMasked(
+      scope: Scope,
+      sep: String,
+      showProject: Reference => String,
+      mask: ScopeMask
+  ): String =
+    displayMasked(scope, sep, showProject, mask, false)
+
+  /**
+   * Allows the user to override the result of `Scope.display` or `Scope.displayMasked` for a
+   * particular scope. This can be used to enhance super shell and/or error reporting for tasks
+   * that use mangled names. For example, one might have:
+   * {{{
+   *   val mangledKey = TaskKey[Unit]("foo_slash_bar")
+   *   val attributeMap = AttributeMap.empty.put(Scope.customShowString("foo/bar"))
+   *   val sanitizedKey = mangledKey.copy(scope = mangledKey.copy(extra = Select(attributeMap)))
+   *   sanitizedKey := { ... }
+   * }}}
+   *
+   * Now whenever the `foo_slash_bar` task specified by sanitizedKey is evaluated, it will display
+   * "foo/bar" in super shell progress and in the error message if an error is thrown.
+   */
+  val customShowString = AttributeKey[String]("scope-custom-show-string")
+
+  /**
+   * unified slash style introduced in sbt 1.1.0.
+   * By default, sbt will no longer display the Zero-config,
+   * so `name` will render as `name` as opposed to `{uri}proj/Zero/name`.
+   * Technically speaking an unspecified configuration axis defaults to
+   * the scope delegation (first configuration defining the key, then Zero).
+   */
+  def displayMasked(
+      scope: Scope,
+      sep: String,
+      showProject: Reference => String,
+      mask: ScopeMask,
+      showZeroConfig: Boolean
+  ): String = {
+    import scope.{ project, config, task, extra }
+    extra.toOption.flatMap(_.get(customShowString)).getOrElse {
+      val zeroConfig = if (showZeroConfig) "Zero /" else ""
+      val configPrefix = config.foldStrict(display, zeroConfig, "./")
+      val taskPrefix = task.foldStrict(_.label + " /", "", "./")
+      val extras = extra.foldStrict(_.entries.map(_.toString).toList, nil, nil)
       val postfix = if (extras.isEmpty) "" else extras.mkString("(", ", ", ")")
-      mask.concatShow(projectPrefix(project, showProject), configPrefix, taskPrefix, sep, postfix)
+      if (scope == GlobalScope) "Global / " + sep + postfix
+      else
+        mask.concatShow(
+          appendSpace(projectPrefix(project, showProject)),
+          appendSpace(configPrefix),
+          appendSpace(taskPrefix),
+          sep,
+          postfix
+        )
     }
+  }
+
+  private[sbt] def appendSpace(s: String): String =
+    if (s == "") ""
+    else s + " "
 
   def equal(a: Scope, b: Scope, mask: ScopeMask): Boolean =
     (!mask.project || a.project == b.project) &&
@@ -124,103 +254,205 @@ object Scope {
       (!mask.task || a.task == b.task) &&
       (!mask.extra || a.extra == b.extra)
 
-  def projectPrefix(project: ScopeAxis[Reference], show: Reference => String = showProject): String = project.foldStrict(show, "*/", "./")
-  def showProject = (ref: Reference) => Reference.display(ref) + "/"
+  def projectPrefix(
+      project: ScopeAxis[Reference],
+      show: Reference => String = showProject
+  ): String =
+    project.foldStrict(show, "Zero /", "./")
 
-  def transformTaskName(s: String) =
-    {
-      val parts = s.split("-+")
-      (parts.take(1) ++ parts.drop(1).map(_.capitalize)).mkString
-    }
+  def projectPrefix012Style(
+      project: ScopeAxis[Reference],
+      show: Reference => String = showProject
+  ): String =
+    project.foldStrict(show, "*/", "./")
+
+  def showProject = (ref: Reference) => Reference.display(ref) + " /"
+
+  def showProject012Style = (ref: Reference) => Reference.display(ref) + "/"
+
+  @deprecated("No longer used", "1.1.3")
+  def transformTaskName(s: String) = {
+    val parts = s.split("-+")
+    (parts.take(1) ++ parts.drop(1).map(_.capitalize)).mkString
+  }
+
+  @deprecated("Use variant without extraInherit", "1.1.1")
+  def delegates[Proj](
+      refs: Seq[(ProjectRef, Proj)],
+      configurations: Proj => Seq[ConfigKey],
+      resolve: Reference => ResolvedReference,
+      rootProject: URI => String,
+      projectInherit: ProjectRef => Seq[ProjectRef],
+      configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey],
+      taskInherit: AttributeKey[_] => Seq[AttributeKey[_]],
+      extraInherit: (ResolvedReference, AttributeMap) => Seq[AttributeMap]
+  ): Scope => Seq[Scope] =
+    delegates(
+      refs,
+      configurations,
+      resolve,
+      rootProject,
+      projectInherit,
+      configInherit,
+      taskInherit,
+    )
 
   // *Inherit functions should be immediate delegates and not include argument itself.  Transitivity will be provided by this method
   def delegates[Proj](
-    refs: Seq[(ProjectRef, Proj)],
-    configurations: Proj => Seq[ConfigKey],
-    resolve: Reference => ResolvedReference,
-    rootProject: URI => String,
-    projectInherit: ProjectRef => Seq[ProjectRef],
-    configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey],
-    taskInherit: AttributeKey[_] => Seq[AttributeKey[_]],
-    extraInherit: (ResolvedReference, AttributeMap) => Seq[AttributeMap]): Scope => Seq[Scope] =
-    {
-      val index = delegates(refs, configurations, projectInherit, configInherit)
-      scope => indexedDelegates(resolve, index, rootProject, taskInherit, extraInherit)(scope)
-    }
+      refs: Seq[(ProjectRef, Proj)],
+      configurations: Proj => Seq[ConfigKey],
+      resolve: Reference => ResolvedReference,
+      rootProject: URI => String,
+      projectInherit: ProjectRef => Seq[ProjectRef],
+      configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey],
+      taskInherit: AttributeKey[_] => Seq[AttributeKey[_]],
+  ): Scope => Seq[Scope] = {
+    val index = delegates(refs, configurations, projectInherit, configInherit)
+    scope => indexedDelegates(resolve, index, rootProject, taskInherit)(scope)
+  }
+
+  @deprecated("Use variant without extraInherit", "1.1.1")
+  def indexedDelegates(
+      resolve: Reference => ResolvedReference,
+      index: DelegateIndex,
+      rootProject: URI => String,
+      taskInherit: AttributeKey[_] => Seq[AttributeKey[_]],
+      extraInherit: (ResolvedReference, AttributeMap) => Seq[AttributeMap]
+  )(rawScope: Scope): Seq[Scope] =
+    indexedDelegates(resolve, index, rootProject, taskInherit)(rawScope)
 
   def indexedDelegates(
-    resolve: Reference => ResolvedReference,
-    index: DelegateIndex,
-    rootProject: URI => String,
-    taskInherit: AttributeKey[_] => Seq[AttributeKey[_]],
-    extraInherit: (ResolvedReference, AttributeMap) => Seq[AttributeMap])(rawScope: Scope): Seq[Scope] =
-    {
-      val scope = Scope.replaceThis(GlobalScope)(rawScope)
+      resolve: Reference => ResolvedReference,
+      index: DelegateIndex,
+      rootProject: URI => String,
+      taskInherit: AttributeKey[_] => Seq[AttributeKey[_]],
+  )(rawScope: Scope): Seq[Scope] = {
+    val scope = Scope.replaceThis(GlobalScope)(rawScope)
 
-      def nonProjectScopes(resolvedProj: ResolvedReference)(px: ScopeAxis[ResolvedReference]) =
-        {
-          val p = px.toOption getOrElse resolvedProj
-          val configProj = p match { case pr: ProjectRef => pr; case br: BuildRef => ProjectRef(br.build, rootProject(br.build)) }
-          val cLin = scope.config match { case Select(conf) => index.config(configProj, conf); case _ => withGlobalAxis(scope.config) }
-          val tLin = scope.task match { case t @ Select(task) => linearize(t)(taskInherit); case _ => withGlobalAxis(scope.task) }
-          val eLin = withGlobalAxis(scope.extra)
-          for (c <- cLin; t <- tLin; e <- eLin) yield Scope(px, c, t, e)
-        }
-      scope.project match {
-        case Global | This => globalProjectDelegates(scope)
-        case Select(proj) =>
-          val resolvedProj = resolve(proj)
-          val projAxes: Seq[ScopeAxis[ResolvedReference]] =
-            resolvedProj match {
-              case pr: ProjectRef => index.project(pr)
-              case br: BuildRef   => Select(br) :: Global :: Nil
-            }
-          projAxes flatMap nonProjectScopes(resolvedProj)
+    // This is a hot method that gets called many times
+    def expandDelegateScopes(
+        resolvedProj: ResolvedReference
+    )(pLin: Seq[ScopeAxis[ResolvedReference]]): Vector[Scope] = {
+      val tLin = scope.task match {
+        case t @ Select(_) => linearize(t)(taskInherit)
+        case _             => withZeroAxis(scope.task)
       }
+      // val eLin = withZeroAxis(scope.extra)
+      // The following while loops handroll the nested for-expression + flatMap
+      // projAxes flatMap nonProjectScopes(resolvedProj)
+      //   ...
+      //   for (c <- cLin; t <- tLin; e <- eLin) yield Scope(px, c, t, e)
+      val res = Vector.newBuilder[Scope]
+      val pIt = pLin.iterator
+      while (pIt.hasNext) {
+        val px = pIt.next()
+        val p = px.toOption getOrElse resolvedProj
+        val configProj = p match {
+          case pr: ProjectRef => pr
+          case br: BuildRef   => ProjectRef(br.build, rootProject(br.build))
+        }
+        val cLin = scope.config match {
+          case Select(conf) => index.config(configProj, conf)
+          case _            => withZeroAxis(scope.config)
+        }
+        val cLinIt = cLin.iterator
+        while (cLinIt.hasNext) {
+          val c = cLinIt.next()
+          val tLinIt = tLin.iterator
+          while (tLinIt.hasNext) {
+            val t = tLinIt.next()
+            if (scope.extra.isSelect) {
+              res += Scope(px, c, t, scope.extra)
+              ()
+            }
+            res += Scope(px, c, t, Zero)
+          }
+        }
+      }
+      res.result()
     }
 
-  def withGlobalAxis[T](base: ScopeAxis[T]): Seq[ScopeAxis[T]] = if (base.isSelect) base :: Global :: Nil else Global :: Nil
-  def withGlobalScope(base: Scope): Seq[Scope] = if (base == GlobalScope) GlobalScope :: Nil else base :: GlobalScope :: Nil
-  def withRawBuilds(ps: Seq[ScopeAxis[ProjectRef]]): Seq[ScopeAxis[ResolvedReference]] =
-    ps ++ (ps flatMap rawBuild).distinct :+ Global
+    scope.project match {
+      case Zero | This => globalProjectDelegates(scope)
+      case Select(proj) =>
+        val resolvedProj = resolve(proj)
+        val projAxes: Seq[ScopeAxis[ResolvedReference]] =
+          resolvedProj match {
+            case pr: ProjectRef => index.project(pr)
+            case br: BuildRef =>
+              List(Select(br): ScopeAxis[ResolvedReference], Zero: ScopeAxis[ResolvedReference])
+          }
+        expandDelegateScopes(resolvedProj)(projAxes)
+    }
+  }
 
-  def rawBuild(ps: ScopeAxis[ProjectRef]): Seq[ScopeAxis[BuildRef]] = ps match { case Select(ref) => Select(BuildRef(ref.build)) :: Nil; case _ => Nil }
+  private val zeroL = List(Zero)
+  def withZeroAxis[T](base: ScopeAxis[T]): Seq[ScopeAxis[T]] =
+    if (base.isSelect) List(base, Zero: ScopeAxis[T])
+    else zeroL
+
+  def withGlobalScope(base: Scope): Seq[Scope] =
+    if (base == GlobalScope) GlobalScope :: Nil else base :: GlobalScope :: Nil
+  def withRawBuilds(ps: Seq[ScopeAxis[ProjectRef]]): Seq[ScopeAxis[ResolvedReference]] =
+    (ps: Seq[ScopeAxis[ResolvedReference]]) ++
+      ((ps flatMap rawBuild).distinct: Seq[ScopeAxis[ResolvedReference]]) :+
+      (Zero: ScopeAxis[ResolvedReference])
+
+  def rawBuild(ps: ScopeAxis[ProjectRef]): Seq[ScopeAxis[BuildRef]] = ps match {
+    case Select(ref) => Select(BuildRef(ref.build)) :: Nil; case _ => Nil
+  }
 
   def delegates[Proj](
-    refs: Seq[(ProjectRef, Proj)],
-    configurations: Proj => Seq[ConfigKey],
-    projectInherit: ProjectRef => Seq[ProjectRef],
-    configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey]): DelegateIndex =
-    {
-      val pDelegates = refs map {
-        case (ref, project) =>
-          (ref, delegateIndex(ref, configurations(project))(projectInherit, configInherit))
-      } toMap;
-      new DelegateIndex0(pDelegates)
+      refs: Seq[(ProjectRef, Proj)],
+      configurations: Proj => Seq[ConfigKey],
+      projectInherit: ProjectRef => Seq[ProjectRef],
+      configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey]
+  ): DelegateIndex = {
+    val pDelegates = refs map {
+      case (ref, project) =>
+        (ref, delegateIndex(ref, configurations(project))(projectInherit, configInherit))
+    } toMap;
+    new DelegateIndex0(pDelegates)
+  }
+  private[this] def delegateIndex(ref: ProjectRef, confs: Seq[ConfigKey])(
+      projectInherit: ProjectRef => Seq[ProjectRef],
+      configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey]
+  ): ProjectDelegates = {
+    val refDelegates = withRawBuilds(linearize(Select(ref), false)(projectInherit))
+    val configs = confs map { c =>
+      axisDelegates(configInherit, ref, c)
     }
-  private[this] def delegateIndex(ref: ProjectRef, confs: Seq[ConfigKey])(projectInherit: ProjectRef => Seq[ProjectRef], configInherit: (ResolvedReference, ConfigKey) => Seq[ConfigKey]): ProjectDelegates =
-    {
-      val refDelegates = withRawBuilds(linearize(Select(ref), false)(projectInherit))
-      val configs = confs map { c => axisDelegates(configInherit, ref, c) }
-      new ProjectDelegates(ref, refDelegates, configs.toMap)
-    }
-  def axisDelegates[T](direct: (ResolvedReference, T) => Seq[T], ref: ResolvedReference, init: T): (T, Seq[ScopeAxis[T]]) =
+    new ProjectDelegates(ref, refDelegates, configs.toMap)
+  }
+  def axisDelegates[T](
+      direct: (ResolvedReference, T) => Seq[T],
+      ref: ResolvedReference,
+      init: T
+  ): (T, Seq[ScopeAxis[T]]) =
     (init, linearize(Select(init))(direct(ref, _)))
 
-  def linearize[T](axis: ScopeAxis[T], appendGlobal: Boolean = true)(inherit: T => Seq[T]): Seq[ScopeAxis[T]] =
+  def linearize[T](axis: ScopeAxis[T], appendZero: Boolean = true)(
+      inherit: T => Seq[T]
+  ): Seq[ScopeAxis[T]] =
     axis match {
-      case Select(x)     => topologicalSort[T](x, appendGlobal)(inherit)
-      case Global | This => if (appendGlobal) Global :: Nil else Nil
+      case Select(x)   => topologicalSort[T](x, appendZero)(inherit)
+      case Zero | This => if (appendZero) Zero :: Nil else Nil
     }
 
-  def topologicalSort[T](node: T, appendGlobal: Boolean)(dependencies: T => Seq[T]): Seq[ScopeAxis[T]] =
-    {
-      val o = Dag.topologicalSortUnchecked(node)(dependencies).map(Select.apply)
-      if (appendGlobal) o ::: Global :: Nil else o
-    }
+  def topologicalSort[T](node: T, appendZero: Boolean)(
+      dependencies: T => Seq[T]
+  ): Seq[ScopeAxis[T]] = {
+    val o = Dag.topologicalSortUnchecked(node)(dependencies).map(x => Select(x): ScopeAxis[T])
+    if (appendZero) o ::: (Zero: ScopeAxis[T]) :: Nil
+    else o
+  }
   def globalProjectDelegates(scope: Scope): Seq[Scope] =
     if (scope == GlobalScope)
       GlobalScope :: Nil
     else
-      for (c <- withGlobalAxis(scope.config); t <- withGlobalAxis(scope.task); e <- withGlobalAxis(scope.extra)) yield Scope(Global, c, t, e)
+      for {
+        c <- withZeroAxis(scope.config)
+        t <- withZeroAxis(scope.task)
+        e <- withZeroAxis(scope.extra)
+      } yield Scope(Zero, c, t, e)
 }
diff --git a/main-settings/src/main/scala/sbt/ScopeAxis.scala b/main-settings/src/main/scala/sbt/ScopeAxis.scala
index ce774c562..6b494a73b 100644
--- a/main-settings/src/main/scala/sbt/ScopeAxis.scala
+++ b/main-settings/src/main/scala/sbt/ScopeAxis.scala
@@ -1,28 +1,51 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import sbt.internal.util.Types.some
+import sbt.internal.util.Util._
 
 sealed trait ScopeAxis[+S] {
-  def foldStrict[T](f: S => T, ifGlobal: T, ifThis: T): T = fold(f, ifGlobal, ifThis)
-  def fold[T](f: S => T, ifGlobal: => T, ifThis: => T): T = this match {
+  def foldStrict[T](f: S => T, ifZero: T, ifThis: T): T = fold(f, ifZero, ifThis)
+  def fold[T](f: S => T, ifZero: => T, ifThis: => T): T = this match {
     case This      => ifThis
-    case Global    => ifGlobal
+    case Zero      => ifZero
     case Select(s) => f(s)
   }
-  def toOption: Option[S] = foldStrict(some.fn, None, None)
-  def map[T](f: S => T): ScopeAxis[T] = foldStrict(s => Select(f(s)), Global, This)
+  def toOption: Option[S] = foldStrict(Option(_), none, none)
+  def map[T](f: S => T): ScopeAxis[T] =
+    foldStrict(s => Select(f(s)): ScopeAxis[T], Zero: ScopeAxis[T], This: ScopeAxis[T])
   def isSelect: Boolean = false
 }
+
+/**
+ * This is a scope component that represents not being
+ * scoped by the user, which later could be further scoped automatically
+ * by sbt.
+ */
 case object This extends ScopeAxis[Nothing]
-case object Global extends ScopeAxis[Nothing]
+
+/**
+ * Zero is a scope component that represents not scoping.
+ * It is a universal fallback component that is strictly weaker
+ * than any other values on a scope axis.
+ */
+case object Zero extends ScopeAxis[Nothing]
+
+/**
+ * Select is a type constructor that is used to wrap type `S`
+ * to make a scope component, equivalent of Some in Option.
+ */
 final case class Select[S](s: S) extends ScopeAxis[S] {
   override def isSelect = true
 }
 object ScopeAxis {
-  implicit def scopeAxisToScope(axis: ScopeAxis[Nothing]): Scope =
-    Scope(axis, axis, axis, axis)
   def fromOption[T](o: Option[T]): ScopeAxis[T] = o match {
     case Some(v) => Select(v)
-    case None    => Global
+    case None    => Zero
   }
 }
diff --git a/main-settings/src/main/scala/sbt/ScopeMask.scala b/main-settings/src/main/scala/sbt/ScopeMask.scala
index 0f1a018e1..056fdc385 100644
--- a/main-settings/src/main/scala/sbt/ScopeMask.scala
+++ b/main-settings/src/main/scala/sbt/ScopeMask.scala
@@ -1,15 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 /** Specifies the Scope axes that should be used for an operation.  `true` indicates an axis should be used. */
-final case class ScopeMask(project: Boolean = true, config: Boolean = true, task: Boolean = true, extra: Boolean = true) {
-  def concatShow(p: String, c: String, t: String, sep: String, x: String): String =
-    {
-      val sb = new StringBuilder
-      if (project) sb.append(p)
-      if (config) sb.append(c)
-      if (task) sb.append(t)
-      sb.append(sep)
-      if (extra) sb.append(x)
-      sb.toString
+final case class ScopeMask(
+    project: Boolean = true,
+    config: Boolean = true,
+    task: Boolean = true,
+    extra: Boolean = true
+) {
+  def concatShow(p: String, c: String, t: String, sep: String, x: String): String = {
+    val sb = new StringBuilder
+    if (project) {
+      sb.append(p); ()
     }
+    if (config) {
+      sb.append(c); ()
+    }
+    if (task) {
+      sb.append(t); ()
+    }
+    sb.append(sep)
+    if (extra) {
+      sb.append(x); ()
+    }
+    sb.toString
+  }
 }
diff --git a/main-settings/src/main/scala/sbt/SlashSyntax.scala b/main-settings/src/main/scala/sbt/SlashSyntax.scala
new file mode 100644
index 000000000..ae774b30a
--- /dev/null
+++ b/main-settings/src/main/scala/sbt/SlashSyntax.scala
@@ -0,0 +1,99 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import sbt.librarymanagement.Configuration
+import sbt.internal.util.AttributeKey
+import scala.annotation.nowarn
+
+/**
+ * SlashSyntax implements the slash syntax to scope keys for build.sbt DSL.
+ * The implicits are set up such that the order that the scope components
+ * must appear in the order of the project axis, the configuration axis, and
+ * the task axis. This ordering is the same as the shell syntax.
+ *
+ * @example
+ *  {{{
+ *  Global / cancelable := true
+ *  ThisBuild / scalaVersion := "2.12.2"
+ *  Test / test := ()
+ *  console / scalacOptions += "-deprecation"
+ *  Compile / console / scalacOptions += "-Ywarn-numeric-widen"
+ *  projA / Compile / console / scalacOptions += "-feature"
+ *  Zero / Zero / name := "foo"
+ *  }}}
+ */
+trait SlashSyntax {
+  import SlashSyntax._
+
+  implicit def sbtSlashSyntaxRichReferenceAxis(a: ScopeAxis[Reference]): RichReference =
+    new RichReference(Scope(a, This, This, This))
+
+  implicit def sbtSlashSyntaxRichReference(r: Reference): RichReference = Select(r)
+  implicit def sbtSlashSyntaxRichProject[A](p: A)(implicit x: A => Reference): RichReference =
+    (p: Reference)
+
+  implicit def sbtSlashSyntaxRichConfigKey(c: ConfigKey): RichConfiguration =
+    new RichConfiguration(Scope(This, Select(c), This, This))
+
+  implicit def sbtSlashSyntaxRichConfiguration(c: Configuration): RichConfiguration = (c: ConfigKey)
+
+  implicit def sbtSlashSyntaxRichScope(s: Scope): RichScope = new RichScope(s)
+
+  /**
+   * This handles task scoping an existing scoped key (such as `Compile / test`)
+   * into a task scoping in `(Compile / test) / name`.
+   */
+  implicit def sbtSlashSyntaxRichScopeFromScoped(t: Scoped): RichScope =
+    new RichScope(t.scope.copy(task = Select(t.key)))
+
+  implicit def sbtSlashSyntaxRichScopeFromAttributeKey(a: AttributeKey[_]): RichScope =
+    Scope(This, This, Select(a), This)
+
+}
+
+object SlashSyntax {
+
+  sealed trait HasSlashKey {
+    protected def scope: Scope
+    @nowarn
+    final def /[K](key: Scoped.ScopingSetting[K]): K = key in scope
+  }
+
+  sealed trait HasSlashKeyOrAttrKey extends HasSlashKey {
+    @nowarn
+    final def /(key: AttributeKey[_]): RichScope = new RichScope(scope in key)
+  }
+
+  /** RichReference wraps a reference to provide the `/` operator for scoping. */
+  final class RichReference(protected val scope: Scope) extends HasSlashKeyOrAttrKey {
+    @nowarn
+    def /(c: ConfigKey): RichConfiguration = new RichConfiguration(scope in c)
+
+    @nowarn
+    def /(c: Configuration): RichConfiguration = new RichConfiguration(scope in c)
+
+    // This is for handling `Zero / Zero / name`.
+    @nowarn
+    def /(configAxis: ScopeAxis[ConfigKey]): RichConfiguration =
+      new RichConfiguration(scope.copy(config = configAxis))
+  }
+
+  /** RichConfiguration wraps a configuration to provide the `/` operator for scoping. */
+  final class RichConfiguration(protected val scope: Scope) extends HasSlashKeyOrAttrKey {
+    // This is for handling `Zero / Zero / Zero / name`.
+    def /(taskAxis: ScopeAxis[AttributeKey[_]]): RichScope =
+      new RichScope(scope.copy(task = taskAxis))
+  }
+
+  /** RichScope wraps a general scope to provide the `/` operator for scoping. */
+  final class RichScope(protected val scope: Scope) extends HasSlashKeyOrAttrKey
+
+}
+
+private[sbt] object SlashSyntax0 extends SlashSyntax
diff --git a/main-settings/src/main/scala/sbt/Structure.scala b/main-settings/src/main/scala/sbt/Structure.scala
index 9f74e983b..6ac79293a 100644
--- a/main-settings/src/main/scala/sbt/Structure.scala
+++ b/main-settings/src/main/scala/sbt/Structure.scala
@@ -1,59 +1,124 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-/** An abstraction on top of Settings for build configuration and task definition. */
+import scala.language.experimental.macros
 
-import java.io.File
-
-import ConcurrentRestrictions.Tag
-import Def.{ Initialize, KeyedInitialize, ScopedKey, Setting, setting }
-import sbt.io.{ FileFilter, PathFinder }
-import sbt.io.syntax._
-import std.TaskExtra.{ task => mktask, _ }
 import sbt.internal.util.Types._
 import sbt.internal.util.{ ~>, AList, AttributeKey, Settings, SourcePosition }
+import sbt.util.OptJsonWriter
+import sbt.ConcurrentRestrictions.Tag
+import sbt.Def.{ Initialize, KeyedInitialize, ScopedKey, Setting, setting }
+import std.TaskExtra.{ task => mktask, _ }
 
-import language.experimental.macros
+/** An abstraction on top of Settings for build configuration and task definition. */
+sealed trait Scoped extends Equals {
+  def scope: Scope
+  val key: AttributeKey[_]
 
-sealed trait Scoped { def scope: Scope; val key: AttributeKey[_] }
+  override def equals(that: Any) =
+    (this eq that.asInstanceOf[AnyRef]) || (that match {
+      case that: Scoped => scope == that.scope && key == that.key && canEqual(that)
+      case _            => false
+    })
 
-/** A common type for SettingKey and TaskKey so that both can be used as inputs to tasks.*/
-sealed trait ScopedTaskable[T] extends Scoped {
+  override def hashCode() = (scope, key).##
+}
+
+/** A SettingKey, TaskKey or `Initialize[Task]` that can be converted into an `Initialize[Task]`. */
+sealed trait Taskable[T] {
   def toTask: Initialize[Task[T]]
 }
 
+sealed trait TaskableImplicits { self: Taskable.type =>
+  implicit def fromInit[T](x: Initialize[T]): Taskable[T] =
+    new Taskable[T] { def toTask = Def.toITask(x) }
+}
+
+object Taskable extends TaskableImplicits {
+  implicit def fromITask[T](x: Initialize[Task[T]]): Taskable[T] =
+    new Taskable[T] { def toTask = x }
+}
+
+/** A common type for SettingKey and TaskKey so that both can be used as inputs to tasks.*/
+sealed trait ScopedTaskable[T] extends Scoped with Taskable[T]
+
 /**
  * Identifies a setting.  It consists of three parts: the scope, the name, and the type of a value associated with this key.
  * The scope is represented by a value of type Scope.
  * The name and the type are represented by a value of type `AttributeKey[T]`.
  * Instances are constructed using the companion object.
  */
-sealed abstract class SettingKey[T] extends ScopedTaskable[T] with KeyedInitialize[T] with Scoped.ScopingSetting[SettingKey[T]] with Scoped.DefinableSetting[T] {
+sealed abstract class SettingKey[T]
+    extends ScopedTaskable[T]
+    with KeyedInitialize[T]
+    with Scoped.ScopingSetting[SettingKey[T]]
+    with Scoped.DefinableSetting[T] {
+
   val key: AttributeKey[T]
+
+  override def toString: String = s"SettingKey($scope / $key)"
+
   final def toTask: Initialize[Task[T]] = this apply inlineTask
+
   final def scopedKey: ScopedKey[T] = ScopedKey(scope, key)
-  final def in(scope: Scope): SettingKey[T] = Scoped.scopedSetting(Scope.replaceThis(this.scope)(scope), this.key)
+
+  // @deprecated(Scope.inIsDeprecated, "1.5.0")
+  final def in(scope: Scope): SettingKey[T] =
+    Scoped.scopedSetting(Scope.replaceThis(this.scope)(scope), this.key)
 
   final def :=(v: T): Setting[T] = macro std.TaskMacro.settingAssignMacroImpl[T]
-  final def +=[U](v: U)(implicit a: Append.Value[T, U]): Setting[T] = macro std.TaskMacro.settingAppend1Impl[T, U]
-  final def ++=[U](vs: U)(implicit a: Append.Values[T, U]): Setting[T] = macro std.TaskMacro.settingAppendNImpl[T, U]
-  final def <+=[V](v: Initialize[V])(implicit a: Append.Value[T, V]): Setting[T] = macro std.TaskMacro.fakeSettingAppend1Position[T, V]
-  final def <++=[V](vs: Initialize[V])(implicit a: Append.Values[T, V]): Setting[T] = macro std.TaskMacro.fakeSettingAppendNPosition[T, V]
-  final def -=[U](v: U)(implicit r: Remove.Value[T, U]): Setting[T] = macro std.TaskMacro.settingRemove1Impl[T, U]
-  final def --=[U](vs: U)(implicit r: Remove.Values[T, U]): Setting[T] = macro std.TaskMacro.settingRemoveNImpl[T, U]
+
+  final def +=[U](v: U)(implicit a: Append.Value[T, U]): Setting[T] =
+    macro std.TaskMacro.settingAppend1Impl[T, U]
+
+  final def ++=[U](vs: U)(implicit a: Append.Values[T, U]): Setting[T] =
+    macro std.TaskMacro.settingAppendNImpl[T, U]
+
+  final def <+=[V](v: Initialize[V])(implicit a: Append.Value[T, V]): Setting[T] =
+    macro std.TaskMacro.fakeSettingAppend1Position[T, V]
+
+  final def <++=[V](vs: Initialize[V])(implicit a: Append.Values[T, V]): Setting[T] =
+    macro std.TaskMacro.fakeSettingAppendNPosition[T, V]
+
+  final def -=[U](v: U)(implicit r: Remove.Value[T, U]): Setting[T] =
+    macro std.TaskMacro.settingRemove1Impl[T, U]
+
+  final def --=[U](vs: U)(implicit r: Remove.Values[T, U]): Setting[T] =
+    macro std.TaskMacro.settingRemoveNImpl[T, U]
+
   final def ~=(f: T => T): Setting[T] = macro std.TaskMacro.settingTransformPosition[T]
 
-  final def append1[V](v: Initialize[V], source: SourcePosition)(implicit a: Append.Value[T, V]): Setting[T] = make(v, source)(a.appendValue)
-  final def appendN[V](vs: Initialize[V], source: SourcePosition)(implicit a: Append.Values[T, V]): Setting[T] = make(vs, source)(a.appendValues)
+  final def append1[V](v: Initialize[V], source: SourcePosition)(
+      implicit a: Append.Value[T, V]
+  ): Setting[T] = make(v, source)(a.appendValue)
 
-  final def remove1[V](v: Initialize[V], source: SourcePosition)(implicit r: Remove.Value[T, V]): Setting[T] = make(v, source)(r.removeValue)
-  final def removeN[V](vs: Initialize[V], source: SourcePosition)(implicit r: Remove.Values[T, V]): Setting[T] = make(vs, source)(r.removeValues)
+  final def appendN[V](vs: Initialize[V], source: SourcePosition)(
+      implicit a: Append.Values[T, V]
+  ): Setting[T] = make(vs, source)(a.appendValues)
+
+  final def remove1[V](v: Initialize[V], source: SourcePosition)(
+      implicit r: Remove.Value[T, V]
+  ): Setting[T] = make(v, source)(r.removeValue)
+  final def removeN[V](vs: Initialize[V], source: SourcePosition)(
+      implicit r: Remove.Values[T, V]
+  ): Setting[T] = make(vs, source)(r.removeValues)
 
   final def transform(f: T => T, source: SourcePosition): Setting[T] = set(scopedKey(f), source)
 
-  protected[this] def make[S](other: Initialize[S], source: SourcePosition)(f: (T, S) => T): Setting[T] = set((this, other)(f), source)
+  protected[this] def make[S](other: Initialize[S], source: SourcePosition)(
+      f: (T, S) => T
+  ): Setting[T] = set(this.zipWith(other)(f), source)
+
+  final def withRank(rank: Int): SettingKey[T] =
+    SettingKey(AttributeKey.copyWithRank(key, rank))
+
+  def canEqual(that: Any): Boolean = that.isInstanceOf[SettingKey[_]]
 }
 
 /**
@@ -62,27 +127,66 @@ sealed abstract class SettingKey[T] extends ScopedTaskable[T] with KeyedInitiali
  * The name and the type are represented by a value of type `AttributeKey[Task[T]]`.
  * Instances are constructed using the companion object.
  */
-sealed abstract class TaskKey[T] extends ScopedTaskable[T] with KeyedInitialize[Task[T]] with Scoped.ScopingSetting[TaskKey[T]] with Scoped.DefinableTask[T] {
+sealed abstract class TaskKey[T]
+    extends ScopedTaskable[T]
+    with KeyedInitialize[Task[T]]
+    with Scoped.ScopingSetting[TaskKey[T]]
+    with Scoped.DefinableTask[T] {
+
   val key: AttributeKey[Task[T]]
+
+  override def toString: String = s"TaskKey($scope / $key)"
+
   def toTask: Initialize[Task[T]] = this
+
   def scopedKey: ScopedKey[Task[T]] = ScopedKey(scope, key)
-  def in(scope: Scope): TaskKey[T] = Scoped.scopedTask(Scope.replaceThis(this.scope)(scope), this.key)
 
-  def +=[U](v: U)(implicit a: Append.Value[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskAppend1Impl[T, U]
-  def ++=[U](vs: U)(implicit a: Append.Values[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskAppendNImpl[T, U]
-  def <+=[V](v: Initialize[Task[V]])(implicit a: Append.Value[T, V]): Setting[Task[T]] = macro std.TaskMacro.fakeTaskAppend1Position[T, V]
-  def <++=[V](vs: Initialize[Task[V]])(implicit a: Append.Values[T, V]): Setting[Task[T]] = macro std.TaskMacro.fakeTaskAppendNPosition[T, V]
-  final def -=[U](v: U)(implicit r: Remove.Value[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskRemove1Impl[T, U]
-  final def --=[U](vs: U)(implicit r: Remove.Values[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskRemoveNImpl[T, U]
+  // @deprecated(Scope.inIsDeprecated, "1.5.0")
+  def in(scope: Scope): TaskKey[T] =
+    Scoped.scopedTask(Scope.replaceThis(this.scope)(scope), this.key)
 
-  def append1[V](v: Initialize[Task[V]], source: SourcePosition)(implicit a: Append.Value[T, V]): Setting[Task[T]] = make(v, source)(a.appendValue)
-  def appendN[V](vs: Initialize[Task[V]], source: SourcePosition)(implicit a: Append.Values[T, V]): Setting[Task[T]] = make(vs, source)(a.appendValues)
+  def +=[U](v: U)(implicit a: Append.Value[T, U]): Setting[Task[T]] =
+    macro std.TaskMacro.taskAppend1Impl[T, U]
 
-  final def remove1[V](v: Initialize[Task[V]], source: SourcePosition)(implicit r: Remove.Value[T, V]): Setting[Task[T]] = make(v, source)(r.removeValue)
-  final def removeN[V](vs: Initialize[Task[V]], source: SourcePosition)(implicit r: Remove.Values[T, V]): Setting[Task[T]] = make(vs, source)(r.removeValues)
+  def ++=[U](vs: U)(implicit a: Append.Values[T, U]): Setting[Task[T]] =
+    macro std.TaskMacro.taskAppendNImpl[T, U]
 
-  private[this] def make[S](other: Initialize[Task[S]], source: SourcePosition)(f: (T, S) => T): Setting[Task[T]] =
-    set((this, other) { (a, b) => (a, b) map f.tupled }, source)
+  def <+=[V](v: Initialize[Task[V]])(implicit a: Append.Value[T, V]): Setting[Task[T]] =
+    macro std.TaskMacro.fakeTaskAppend1Position[T, V]
+
+  def <++=[V](vs: Initialize[Task[V]])(implicit a: Append.Values[T, V]): Setting[Task[T]] =
+    macro std.TaskMacro.fakeTaskAppendNPosition[T, V]
+
+  final def -=[U](v: U)(implicit r: Remove.Value[T, U]): Setting[Task[T]] =
+    macro std.TaskMacro.taskRemove1Impl[T, U]
+
+  final def --=[U](vs: U)(implicit r: Remove.Values[T, U]): Setting[Task[T]] =
+    macro std.TaskMacro.taskRemoveNImpl[T, U]
+
+  def append1[V](v: Initialize[Task[V]], source: SourcePosition)(
+      implicit a: Append.Value[T, V]
+  ): Setting[Task[T]] = make(v, source)(a.appendValue)
+
+  def appendN[V](vs: Initialize[Task[V]], source: SourcePosition)(
+      implicit a: Append.Values[T, V]
+  ): Setting[Task[T]] = make(vs, source)(a.appendValues)
+
+  final def remove1[V](v: Initialize[Task[V]], source: SourcePosition)(
+      implicit r: Remove.Value[T, V]
+  ): Setting[Task[T]] = make(v, source)(r.removeValue)
+
+  final def removeN[V](vs: Initialize[Task[V]], source: SourcePosition)(
+      implicit r: Remove.Values[T, V]
+  ): Setting[Task[T]] = make(vs, source)(r.removeValues)
+
+  private[this] def make[S](other: Initialize[Task[S]], source: SourcePosition)(
+      f: (T, S) => T
+  ): Setting[Task[T]] = set(this.zipWith(other)((a, b) => (a, b) map f.tupled), source)
+
+  final def withRank(rank: Int): TaskKey[T] =
+    TaskKey(AttributeKey.copyWithRank(key, rank))
+
+  def canEqual(that: Any): Boolean = that.isInstanceOf[TaskKey[_]]
 }
 
 /**
@@ -92,23 +196,43 @@ sealed abstract class TaskKey[T] extends ScopedTaskable[T] with KeyedInitialize[
  * The name and the type are represented by a value of type `AttributeKey[InputTask[T]]`.
  * Instances are constructed using the companion object.
  */
-sealed trait InputKey[T] extends Scoped with KeyedInitialize[InputTask[T]] with Scoped.ScopingSetting[InputKey[T]] with Scoped.DefinableSetting[InputTask[T]] {
+sealed trait InputKey[T]
+    extends Scoped
+    with KeyedInitialize[InputTask[T]]
+    with Scoped.ScopingSetting[InputKey[T]]
+    with Scoped.DefinableSetting[InputTask[T]] {
+
   val key: AttributeKey[InputTask[T]]
+
+  override def toString: String = s"InputKey($scope / $key)"
+
   def scopedKey: ScopedKey[InputTask[T]] = ScopedKey(scope, key)
-  def in(scope: Scope): InputKey[T] = Scoped.scopedInput(Scope.replaceThis(this.scope)(scope), this.key)
+
+  // @deprecated(Scope.inIsDeprecated, "1.5.0")
+  def in(scope: Scope): InputKey[T] =
+    Scoped.scopedInput(Scope.replaceThis(this.scope)(scope), this.key)
 
   final def :=(v: T): Setting[InputTask[T]] = macro std.TaskMacro.inputTaskAssignMacroImpl[T]
   final def ~=(f: T => T): Setting[InputTask[T]] = macro std.TaskMacro.itaskTransformPosition[T]
-  final def transform(f: T => T, source: SourcePosition): Setting[InputTask[T]] = set(scopedKey(_ mapTask { _ map f }), source)
+
+  final def transform(f: T => T, source: SourcePosition): Setting[InputTask[T]] =
+    set(scopedKey(_ mapTask { _ map f }), source)
+
+  final def withRank(rank: Int): InputKey[T] =
+    InputKey(AttributeKey.copyWithRank(key, rank))
+
+  def canEqual(that: Any): Boolean = that.isInstanceOf[InputKey[_]]
 }
 
 /** Methods and types related to constructing settings, including keys, scopes, and initializations. */
 object Scoped {
   implicit def taskScopedToKey[T](s: TaskKey[T]): ScopedKey[Task[T]] = ScopedKey(s.scope, s.key)
-  implicit def inputScopedToKey[T](s: InputKey[T]): ScopedKey[InputTask[T]] = ScopedKey(s.scope, s.key)
+
+  implicit def inputScopedToKey[T](s: InputKey[T]): ScopedKey[InputTask[T]] =
+    ScopedKey(s.scope, s.key)
 
   /**
-   * Mixin trait for adding convenience vocabulary associated with specifiying the [[Scope]] of a setting.
+   * Mixin trait for adding convenience vocabulary associated with specifying the [[Scope]] of a setting.
    * Allows specification of the Scope or part of the [[Scope]] of a setting being referenced.
    * @example
    *  {{{
@@ -123,21 +247,47 @@ object Scoped {
    *
    */
   sealed trait ScopingSetting[ResultType] {
+    // @deprecated(Scope.inIsDeprecated, "1.5.0")
     def in(s: Scope): ResultType
 
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
     def in(p: Reference): ResultType = in(Select(p), This, This)
+
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
     def in(t: Scoped): ResultType = in(This, This, Select(t.key))
+
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
     def in(c: ConfigKey): ResultType = in(This, Select(c), This)
+
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
     def in(c: ConfigKey, t: Scoped): ResultType = in(This, Select(c), Select(t.key))
+
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
     def in(p: Reference, c: ConfigKey): ResultType = in(Select(p), Select(c), This)
+
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
     def in(p: Reference, t: Scoped): ResultType = in(Select(p), This, Select(t.key))
-    def in(p: Reference, c: ConfigKey, t: Scoped): ResultType = in(Select(p), Select(c), Select(t.key))
-    def in(p: ScopeAxis[Reference], c: ScopeAxis[ConfigKey], t: ScopeAxis[AttributeKey[_]]): ResultType = in(Scope(p, c, t, This))
+
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
+    def in(p: Reference, c: ConfigKey, t: Scoped): ResultType =
+      in(Select(p), Select(c), Select(t.key))
+
+    @deprecated(Scope.inIsDeprecated, "1.5.0")
+    def in(
+        p: ScopeAxis[Reference],
+        c: ScopeAxis[ConfigKey],
+        t: ScopeAxis[AttributeKey[_]]
+    ): ResultType = in(Scope(p, c, t, This))
   }
 
-  def scopedSetting[T](s: Scope, k: AttributeKey[T]): SettingKey[T] = new SettingKey[T] { val scope = s; val key = k }
-  def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): InputKey[T] = new InputKey[T] { val scope = s; val key = k }
-  def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): TaskKey[T] = new TaskKey[T] { val scope = s; val key = k }
+  def scopedSetting[T](s: Scope, k: AttributeKey[T]): SettingKey[T] =
+    new SettingKey[T] { val scope = s; val key = k }
+
+  def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): InputKey[T] =
+    new InputKey[T] { val scope = s; val key = k }
+
+  def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): TaskKey[T] =
+    new TaskKey[T] { val scope = s; val key = k }
 
   /**
    * Mixin trait for adding convenience vocabulary associated with applying a setting to a configuration item.
@@ -147,17 +297,20 @@ object Scoped {
 
     private[sbt] final def :==(app: S): Setting[S] = macro std.TaskMacro.settingAssignPure[S]
 
-    final def <<=(app: Initialize[S]): Setting[S] = macro std.TaskMacro.fakeSettingAssignPosition[S]
+    final def <<=(app: Initialize[S]): Setting[S] =
+      macro std.TaskMacro.fakeSettingAssignPosition[S]
 
     /** Internally used function for setting a value along with the `.sbt` file location where it is defined. */
-    final def set(app: Initialize[S], source: SourcePosition): Setting[S] = setting(scopedKey, app, source)
+    final def set(app: Initialize[S], source: SourcePosition): Setting[S] =
+      setting(scopedKey, app, source)
 
-    /** From the given [[Settings]], extract the value bound to this key. */
-    final def get(settings: Settings[Scope]): Option[S] = settings.get(scopedKey.scope, scopedKey.key)
+    /** From the given `Settings`, extract the value bound to this key. */
+    final def get(settings: Settings[Scope]): Option[S] =
+      settings.get(scopedKey.scope, scopedKey.key)
 
     /**
-     * Creates an [[Def.Initialize]] with value [[scala.None]] if there was no previous definition of this key,
-     * and `[[scala.Some]](value)` if a definition exists. Useful for when you want to use the ''existence'' of
+     * Creates an [[Def.Initialize]] with value `scala.None` if there was no previous definition of this key,
+     * and `scala.Some(value)` if a definition exists. Useful for when you want to use the ''existence'' of
      * one setting in order to define another setting.
      * @return currently bound value wrapped in `Initialize[Some[T]]`, or `Initialize[None]` if unbound.
      */
@@ -168,7 +321,7 @@ object Scoped {
      * @param i value to return if this setting doesn't have a value.
      * @return currently bound setting value, or `i` if unbound.
      */
-    final def or[T >: S](i: Initialize[T]): Initialize[T] = (this.?, i)(_ getOrElse _)
+    final def or[T >: S](i: Initialize[T]): Initialize[T] = ?.zipWith(i)(_.getOrElse(_))
 
     /**
      * Like [[?]], but with a call-by-name parameter rather than an existing [[Def.Initialize]].
@@ -179,8 +332,22 @@ object Scoped {
     final def ??[T >: S](or: => T): Initialize[T] = Def.optional(scopedKey)(_ getOrElse or)
   }
 
+  // Duplicated with ProjectExtra.
+  private[sbt] object syntax {
+    implicit def richInitializeTask[T](init: Initialize[Task[T]]): Scoped.RichInitializeTask[T] =
+      new Scoped.RichInitializeTask(init)
+
+    implicit def richInitializeInputTask[T](
+        init: Initialize[InputTask[T]]
+    ): Scoped.RichInitializeInputTask[T] =
+      new Scoped.RichInitializeInputTask(init)
+
+    implicit def richInitialize[T](i: Initialize[T]): Scoped.RichInitialize[T] =
+      new Scoped.RichInitialize[T](i)
+  }
+
   /**
-   * Wraps an [[sbt.Def.Initialize]] instance to provide `map` and `flatMap` symantics.
+   * Wraps an [[sbt.Def.Initialize]] instance to provide `map` and `flatMap` semantics.
    */
   final class RichInitialize[S](init: Initialize[S]) {
     def map[T](f: S => T): Initialize[Task[T]] = init(s => mktask(f(s)))
@@ -189,46 +356,102 @@ object Scoped {
   sealed trait DefinableTask[S] { self: TaskKey[S] =>
 
     private[sbt] def :==(app: S): Setting[Task[S]] = macro std.TaskMacro.taskAssignPositionPure[S]
-    private[sbt] def ::=(app: Task[S]): Setting[Task[S]] = macro std.TaskMacro.taskAssignPositionT[S]
+
+    private[sbt] def ::=(app: Task[S]): Setting[Task[S]] =
+      macro std.TaskMacro.taskAssignPositionT[S]
+
     def :=(v: S): Setting[Task[S]] = macro std.TaskMacro.taskAssignMacroImpl[S]
     def ~=(f: S => S): Setting[Task[S]] = macro std.TaskMacro.taskTransformPosition[S]
 
-    def <<=(app: Initialize[Task[S]]): Setting[Task[S]] = macro std.TaskMacro.fakeItaskAssignPosition[S]
-    def set(app: Initialize[Task[S]], source: SourcePosition): Setting[Task[S]] = Def.setting(scopedKey, app, source)
-    def transform(f: S => S, source: SourcePosition): Setting[Task[S]] = set(scopedKey(_ map f), source)
+    def <<=(app: Initialize[Task[S]]): Setting[Task[S]] =
+      macro std.TaskMacro.fakeItaskAssignPosition[S]
 
-    @deprecated("No longer needed with new task syntax and SettingKey inheriting from Initialize.", "0.13.2")
+    def set(app: Initialize[Task[S]], source: SourcePosition): Setting[Task[S]] =
+      Def.setting(scopedKey, app, source)
+
+    def transform(f: S => S, source: SourcePosition): Setting[Task[S]] =
+      set(scopedKey(_ map f), source)
+
+    @deprecated(
+      "No longer needed with new task syntax and SettingKey inheriting from Initialize.",
+      "0.13.2"
+    )
     def task: SettingKey[Task[S]] = scopedSetting(scope, key)
+
+    def toSettingKey: SettingKey[Task[S]] = scopedSetting(scope, key)
+
     def get(settings: Settings[Scope]): Option[Task[S]] = settings.get(scope, key)
 
-    def ? : Initialize[Task[Option[S]]] = Def.optional(scopedKey) { case None => mktask { None }; case Some(t) => t map some.fn }
+    def ? : Initialize[Task[Option[S]]] = Def.optional(scopedKey) {
+      case None => mktask { None }; case Some(t) => t map some.fn
+    }
+
     def ??[T >: S](or: => T): Initialize[Task[T]] = Def.optional(scopedKey)(_ getOrElse mktask(or))
-    def or[T >: S](i: Initialize[Task[T]]): Initialize[Task[T]] = (this.? zipWith i)((x, y) => (x, y) map { case (a, b) => a getOrElse b })
+
+    def or[T >: S](i: Initialize[Task[T]]): Initialize[Task[T]] =
+      (this.? zipWith i)((x, y) => (x, y) map { case (a, b) => a getOrElse b })
   }
+
+  /** Enriches `Initialize[Task[S]]` types.
+   *
+   * @param i the original `Initialize[Task[S]]` value to enrich
+   * @tparam S the type of the underlying value
+   */
   final class RichInitializeTask[S](i: Initialize[Task[S]]) extends RichInitTaskBase[S, Task] {
     protected def onTask[T](f: Task[S] => Task[T]): Initialize[Task[T]] = i apply f
 
-    def dependsOn(tasks: AnyInitTask*): Initialize[Task[S]] = (i, Initialize.joinAny[Task](tasks)) { (thisTask, deps) => thisTask.dependsOn(deps: _*) }
+    def dependsOn(tasks: AnyInitTask*): Initialize[Task[S]] = {
+      i.zipWith(Initialize.joinAny[Task](tasks))((thisTask, deps) => thisTask.dependsOn(deps: _*))
+    }
 
     def failure: Initialize[Task[Incomplete]] = i(_.failure)
     def result: Initialize[Task[Result[S]]] = i(_.result)
 
-    def xtriggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy)
-    def triggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy)
-    def runBefore[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.runBefore)
-    private[this] def nonLocal(tasks: Seq[AnyInitTask], key: AttributeKey[Seq[Task[_]]]): Initialize[Task[S]] =
-      (Initialize.joinAny[Task](tasks), i) { (ts, i) => i.copy(info = i.info.set(key, ts)) }
-  }
-  final class RichInitializeInputTask[S](i: Initialize[InputTask[S]]) extends RichInitTaskBase[S, InputTask] {
-    protected def onTask[T](f: Task[S] => Task[T]): Initialize[InputTask[T]] = i(_ mapTask f)
-    def dependsOn(tasks: AnyInitTask*): Initialize[InputTask[S]] = (i, Initialize.joinAny[Task](tasks)) { (thisTask, deps) => thisTask.mapTask(_.dependsOn(deps: _*)) }
+    def xtriggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] =
+      nonLocal(tasks, Def.triggeredBy)
+
+    def triggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] =
+      nonLocal(tasks, Def.triggeredBy)
+
+    def runBefore[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] =
+      nonLocal(tasks, Def.runBefore)
+
+    private[this] def nonLocal(
+        tasks: Seq[AnyInitTask],
+        key: AttributeKey[Seq[Task[_]]]
+    ): Initialize[Task[S]] =
+      Initialize.joinAny[Task](tasks).zipWith(i)((ts, i) => i.copy(info = i.info.set(key, ts)))
   }
 
+  /** Enriches `Initialize[InputTask[S]]` types.
+   *
+   * @param i the original `Initialize[InputTask[S]]` value to enrich
+   * @tparam S the type of the underlying value
+   */
+  final class RichInitializeInputTask[S](i: Initialize[InputTask[S]])
+      extends RichInitTaskBase[S, InputTask] {
+
+    protected def onTask[T](f: Task[S] => Task[T]): Initialize[InputTask[T]] = i(_ mapTask f)
+
+    def dependsOn(tasks: AnyInitTask*): Initialize[InputTask[S]] = {
+      i.zipWith(Initialize.joinAny[Task](tasks))(
+        (thisTask, deps) => thisTask.mapTask(_.dependsOn(deps: _*))
+      )
+    }
+  }
+
+  /** Enriches `Initialize[R[S]]` types. Abstracts over the specific task-like type constructor.
+   *
+   * @tparam S the type of the underlying vault
+   * @tparam R the task-like type constructor (either Task or InputTask)
+   */
   sealed abstract class RichInitTaskBase[S, R[_]] {
     protected def onTask[T](f: Task[S] => Task[T]): Initialize[R[T]]
 
-    def flatMap[T](f: S => Task[T]): Initialize[R[T]] = flatMapR(f compose successM)
-    def map[T](f: S => T): Initialize[R[T]] = mapR(f compose successM)
+    def flatMap[T](f: S => Task[T]): Initialize[R[T]] =
+      onTask(_.result flatMap (f compose successM))
+
+    def map[T](f: S => T): Initialize[R[T]] = onTask(_.result map (f compose successM))
     def andFinally(fin: => Unit): Initialize[R[S]] = onTask(_ andFinally fin)
     def doFinally(t: Task[Unit]): Initialize[R[S]] = onTask(_ doFinally t)
 
@@ -238,17 +461,30 @@ object Scoped {
     def tag(tags: Tag*): Initialize[R[S]] = onTask(_.tag(tags: _*))
     def tagw(tags: (Tag, Int)*): Initialize[R[S]] = onTask(_.tagw(tags: _*))
 
-    @deprecated("Use the `result` method to create a task that returns the full Result of this task.  Then, call `flatMap` on the new task.", "0.13.0")
-    def flatMapR[T](f: Result[S] => Task[T]): Initialize[R[T]] = onTask(_ flatMapR f)
+    @deprecated(
+      "Use the `result` method to create a task that returns the full Result of this task.  Then, call `flatMap` on the new task.",
+      "0.13.0"
+    )
+    def flatMapR[T](f: Result[S] => Task[T]): Initialize[R[T]] = onTask(_.result flatMap f)
 
-    @deprecated("Use the `result` method to create a task that returns the full Result of this task.  Then, call `map` on the new task.", "0.13.0")
-    def mapR[T](f: Result[S] => T): Initialize[R[T]] = onTask(_ mapR f)
+    @deprecated(
+      "Use the `result` method to create a task that returns the full Result of this task.  Then, call `map` on the new task.",
+      "0.13.0"
+    )
+    def mapR[T](f: Result[S] => T): Initialize[R[T]] = onTask(_.result map f)
 
-    @deprecated("Use the `failure` method to create a task that returns Incomplete when this task fails and then call `flatMap` on the new task.", "0.13.0")
-    def flatFailure[T](f: Incomplete => Task[T]): Initialize[R[T]] = flatMapR(f compose failM)
+    @deprecated(
+      "Use the `failure` method to create a task that returns Incomplete when this task fails and then call `flatMap` on the new task.",
+      "0.13.0"
+    )
+    def flatFailure[T](f: Incomplete => Task[T]): Initialize[R[T]] =
+      onTask(_.result flatMap (f compose failM))
 
-    @deprecated("Use the `failure` method to create a task that returns Incomplete when this task fails and then call `map` on the new task.", "0.13.0")
-    def mapFailure[T](f: Incomplete => T): Initialize[R[T]] = mapR(f compose failM)
+    @deprecated(
+      "Use the `failure` method to create a task that returns Incomplete when this task fails and then call `map` on the new task.",
+      "0.13.0"
+    )
+    def mapFailure[T](f: Incomplete => T): Initialize[R[T]] = onTask(_.result map (f compose failM))
   }
 
   type AnyInitTask = Initialize[Task[T]] forSome { type T }
@@ -258,56 +494,29 @@ object Scoped {
     def join: Initialize[Task[Seq[T]]] = tasks(_.join)
     def tasks: Initialize[Seq[Task[T]]] = Initialize.join(keys)
   }
+
   implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq = new RichAnyTaskSeq(in)
   final class RichAnyTaskSeq(keys: Seq[AnyInitTask]) {
-    def dependOn: Initialize[Task[Unit]] = Initialize.joinAny[Task](keys).apply(deps => nop.dependsOn(deps: _*))
+    def dependOn: Initialize[Task[Unit]] =
+      Initialize.joinAny[Task](keys).apply(deps => nop.dependsOn(deps: _*))
   }
 
-  implicit def richFileSetting(s: SettingKey[File]): RichFileSetting = new RichFileSetting(s)
-  implicit def richFilesSetting(s: SettingKey[Seq[File]]): RichFilesSetting = new RichFilesSetting(s)
+  sealed abstract class RichTaskables[K[L[x]]](final val keys: K[Taskable])(
+      implicit a: AList[K]
+  ) {
 
-  final class RichFileSetting(s: SettingKey[File]) extends RichFileBase {
-    @deprecated("Use a standard setting definition.", "0.13.0")
-    def /(c: String): Initialize[File] = s { _ / c }
-    protected[this] def map0(f: PathFinder => PathFinder) = s(file => finder(f)(file :: Nil))
-  }
-  final class RichFilesSetting(s: SettingKey[Seq[File]]) extends RichFileBase {
-    @deprecated("Use a standard setting definition.", "0.13.0")
-    def /(s: String): Initialize[Seq[File]] = map0 { _ / s }
-    protected[this] def map0(f: PathFinder => PathFinder) = s(finder(f))
-  }
-  sealed abstract class RichFileBase {
-    @deprecated("Use a standard setting definition.", "0.13.0")
-    def *(filter: FileFilter): Initialize[Seq[File]] = map0 { _ * filter }
-    @deprecated("Use a standard setting definition.", "0.13.0")
-    def **(filter: FileFilter): Initialize[Seq[File]] = map0 { _ ** filter }
-    protected[this] def map0(f: PathFinder => PathFinder): Initialize[Seq[File]]
-    protected[this] def finder(f: PathFinder => PathFinder): Seq[File] => Seq[File] =
-      in => f(in).get
-  }
-
-  // this is the least painful arrangement I came up with
-  implicit def t2ToTable2[A, B](t2: (ScopedTaskable[A], ScopedTaskable[B])): RichTaskable2[A, B] = new RichTaskable2(t2)
-  implicit def t3ToTable3[A, B, C](t3: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C])): RichTaskable3[A, B, C] = new RichTaskable3(t3)
-  implicit def t4ToTable4[A, B, C, D](t4: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D])): RichTaskable4[A, B, C, D] = new RichTaskable4(t4)
-  implicit def t5ToTable5[A, B, C, D, E](t5: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E])): RichTaskable5[A, B, C, D, E] = new RichTaskable5(t5)
-  implicit def t6ToTable6[A, B, C, D, E, F](t6: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F])): RichTaskable6[A, B, C, D, E, F] = new RichTaskable6(t6)
-  implicit def t7ToTable7[A, B, C, D, E, F, G](t7: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G])): RichTaskable7[A, B, C, D, E, F, G] = new RichTaskable7(t7)
-  implicit def t8ToTable8[A, B, C, D, E, F, G, H](t8: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H])): RichTaskable8[A, B, C, D, E, F, G, H] = new RichTaskable8(t8)
-  implicit def t9ToTable9[A, B, C, D, E, F, G, H, I](t9: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I])): RichTaskable9[A, B, C, D, E, F, G, H, I] = new RichTaskable9(t9)
-  implicit def t10ToTable10[A, B, C, D, E, F, G, H, I, J](t10: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J])): RichTaskable10[A, B, C, D, E, F, G, H, I, J] = new RichTaskable10(t10)
-  implicit def t11ToTable11[A, B, C, D, E, F, G, H, I, J, K](t11: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K])): RichTaskable11[A, B, C, D, E, F, G, H, I, J, K] = new RichTaskable11(t11)
-  /*	implicit def t12ToTable12[A,B,C,D,E,F,G,H,I,J,K,L](t12: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L]) ): RichTaskable12[A,B,C,D,E,F,G,H,I,J,K,L] = new RichTaskable12(t12)
-	implicit def t13ToTable13[A,B,C,D,E,F,G,H,I,J,K,L,N](t13: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N]) ): RichTaskable13[A,B,C,D,E,F,G,H,I,J,K,L,N] = new RichTaskable13(t13)
-	implicit def t14ToTable14[A,B,C,D,E,F,G,H,I,J,K,L,N,O](t14: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N], ScopedTaskable[O]) ): RichTaskable14[A,B,C,D,E,F,G,H,I,J,K,L,N,O] = new RichTaskable14(t14)
-	implicit def t15ToTable15[A,B,C,D,E,F,G,H,I,J,K,L,N,O,P](t15: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N], ScopedTaskable[O], ScopedTaskable[P]) ): RichTaskable15[A,B,C,D,E,F,G,H,I,J,K,L,N,O,P] = new RichTaskable15(t15)*/
-
-  sealed abstract class RichTaskables[K[L[x]]]( final val keys: K[ScopedTaskable])(implicit a: AList[K]) {
     type App[T] = Initialize[Task[T]]
+
+    /** A higher-kinded function, where each parameter shares the same type constructor `M[_]`. */
     type Fun[M[_], Ret]
+
+    /** Convert the higher-kinded function to a Function1.  For tuples that means call `.tupled`. */
     protected def convert[M[_], Ret](f: Fun[M, Ret]): K[M] => Ret
-    private[this] val inputs: K[App] = a.transform(keys, new (ScopedTaskable ~> App) { def apply[T](in: ScopedTaskable[T]): App[T] = in.toTask })
-    private[this] def onTasks[T](f: K[Task] => Task[T]): App[T] = Def.app[({ type l[L[x]] = K[(L ∙ Task)#l] })#l, Task[T]](inputs)(f)(AList.asplit[K, Task](a))
+
+    private[this] val inputs: K[App] = a.transform(keys, λ[Taskable ~> App](_.toTask))
+
+    private[this] def onTasks[T](f: K[Task] => Task[T]): App[T] =
+      Def.app[AList.SplitK[K, Task]#l, Task[T]](inputs)(f)(AList.asplit[K, Task](a))
 
     def flatMap[T](f: Fun[Id, Task[T]]): App[T] = onTasks(_.flatMap(convert(f)))
     def flatMapR[T](f: Fun[Result, Task[T]]): App[T] = onTasks(_.flatMapR(convert(f)))
@@ -316,7 +525,10 @@ object Scoped {
     def flatFailure[T](f: Seq[Incomplete] => Task[T]): App[T] = onTasks(_ flatFailure f)
     def mapFailure[T](f: Seq[Incomplete] => T): App[T] = onTasks(_ mapFailure f)
   }
-  type ST[X] = ScopedTaskable[X]
+
+  // format: off
+
+  type ST[X] = Taskable[X]
   final class RichTaskable2[A, B](t2: (ST[A], ST[B])) extends RichTaskables[AList.T2K[A, B]#l](t2)(AList.tuple2[A, B]) {
     type Fun[M[_], Ret] = (M[A], M[B]) => Ret
     def identityMap = map(mkTuple2)
@@ -362,56 +574,12 @@ object Scoped {
     def identityMap = map(mkTuple10)
     protected def convert[M[_], R](z: Fun[M, R]) = z.tupled
   }
-
   final class RichTaskable11[A, B, C, D, E, F, G, H, I, J, K](t11: ((ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I], ST[J], ST[K]))) extends RichTaskables[AList.T11K[A, B, C, D, E, F, G, H, I, J, K]#l](t11)(AList.tuple11[A, B, C, D, E, F, G, H, I, J, K]) {
     type Fun[M[_], Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K]) => Ret
     def identityMap = map(mkTuple11)
     protected def convert[M[_], R](z: Fun[M, R]) = z.tupled
   }
 
-  /*	final class RichTaskable12[A,B,C,D,E,F,G,H,I,J,K,L](t12: ((ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I], ST[J], ST[K], ST[L]))) extends RichTaskables(k12(t12))
-	{
-		type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L]) => Ret
-		def identityMap = map(mkTuple12)
-		protected def convert[M[_],R](z: Fun[M,R]) = z.tupled
-	}
-
-	final class RichTaskable13[A,B,C,D,E,F,G,H,I,J,K,L,N](t13: ((ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I], ST[J], ST[K], ST[L], ST[N]))) extends RichTaskables(k13(t13))
-	{
-		type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N]) => Ret
-		def identityMap = map(mkTuple13)
-		protected def convert[M[_],R](z: Fun[M,R]) = z.tupled
-	}
-
-	final class RichTaskable14[A,B,C,D,E,F,G,H,I,J,K,L,N,O](t14: ((ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I], ST[J], ST[K], ST[L], ST[N], ST[O]))) extends RichTaskables(k14(t14))
-	{
-		type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N], M[O]) => Ret
-		def identityMap = map(mkTuple14)
-		protected def convert[M[_],R](z: Fun[M,R]) = z.tupled
-	}
-
-	final class RichTaskable15[A,B,C,D,E,F,G,H,I,J,K,L,N,O,P](t15: ((ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I], ST[J], ST[K], ST[L], ST[N], ST[O], ST[P]))) extends RichTaskables(k15(t15))
-	{
-		type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N], M[O], M[P]) => Ret
-		def identityMap = map(mkTuple15)
-		protected def convert[M[_],R](z: Fun[M,R]) = z.tupled
-	}*/
-
-  implicit def t2ToApp2[A, B](t2: (Initialize[A], Initialize[B])): Apply2[A, B] = new Apply2(t2)
-  implicit def t3ToApp3[A, B, C](t3: (Initialize[A], Initialize[B], Initialize[C])): Apply3[A, B, C] = new Apply3(t3)
-  implicit def t4ToApp4[A, B, C, D](t4: (Initialize[A], Initialize[B], Initialize[C], Initialize[D])): Apply4[A, B, C, D] = new Apply4(t4)
-  implicit def t5ToApp5[A, B, C, D, E](t5: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E])): Apply5[A, B, C, D, E] = new Apply5(t5)
-  implicit def t6ToApp6[A, B, C, D, E, F](t6: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F])): Apply6[A, B, C, D, E, F] = new Apply6(t6)
-  implicit def t7ToApp7[A, B, C, D, E, F, G](t7: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G])): Apply7[A, B, C, D, E, F, G] = new Apply7(t7)
-  implicit def t8ToApp8[A, B, C, D, E, F, G, H](t8: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H])): Apply8[A, B, C, D, E, F, G, H] = new Apply8(t8)
-  implicit def t9ToApp9[A, B, C, D, E, F, G, H, I](t9: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I])): Apply9[A, B, C, D, E, F, G, H, I] = new Apply9(t9)
-  implicit def t10ToApp10[A, B, C, D, E, F, G, H, I, J](t10: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J])): Apply10[A, B, C, D, E, F, G, H, I, J] = new Apply10(t10)
-  implicit def t11ToApp11[A, B, C, D, E, F, G, H, I, J, K](t11: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K])): Apply11[A, B, C, D, E, F, G, H, I, J, K] = new Apply11(t11)
-  /*    implicit def t12ToApp12[A,B,C,D,E,F,G,H,I,J,K,L](t12: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L]) ): Apply12[A,B,C,D,E,F,G,H,I,J,K,L] = new Apply12(t12)
-    implicit def t13ToApp13[A,B,C,D,E,F,G,H,I,J,K,L,N](t13: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N]) ): Apply13[A,B,C,D,E,F,G,H,I,J,K,L,N] = new Apply13(t13)
-    implicit def t14ToApp14[A,B,C,D,E,F,G,H,I,J,K,L,N,O](t14: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N], Initialize[O]) ): Apply14[A,B,C,D,E,F,G,H,I,J,K,L,N,O] = new Apply14(t14)
-    implicit def t15ToApp15[A,B,C,D,E,F,G,H,I,J,K,L,N,O,P](t15: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N], Initialize[O], Initialize[P]) ): Apply15[A,B,C,D,E,F,G,H,I,J,K,L,N,O,P] = new Apply15(t15)
-*/
   def mkTuple2[A, B] = (a: A, b: B) => (a, b)
   def mkTuple3[A, B, C] = (a: A, b: B, c: C) => (a, b, c)
   def mkTuple4[A, B, C, D] = (a: A, b: B, c: C, d: D) => (a, b, c, d)
@@ -467,73 +635,140 @@ object Scoped {
     def apply[T](z: (A, B, C, D, E, F, G, H, I, J, K) => T) = Def.app[AList.T11K[A, B, C, D, E, F, G, H, I, J, K]#l, T](t11)(z.tupled)(AList.tuple11[A, B, C, D, E, F, G, H, I, J, K])
     def identity = apply(mkTuple11)
   }
-  /*    final class Apply12[A,B,C,D,E,F,G,H,I,J,K,L](t12: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L])) {
-        def apply[T](z: (A,B,C,D,E,F,G,H,I,J,K,L) => T) = Def.app( k12(t12) )( hf12(z) )
-        def identity = apply(mkTuple12)
-    }
-    final class Apply13[A,B,C,D,E,F,G,H,I,J,K,L,N](t13: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N])) {
-        def apply[T](z: (A,B,C,D,E,F,G,H,I,J,K,L,N) => T) = Def.app( k13(t13) )( hf13(z) )
-        def identity = apply(mkTuple13)
-    }
-    final class Apply14[A,B,C,D,E,F,G,H,I,J,K,L,N,O](t14: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N], Initialize[O])) {
-        def apply[T](z: (A,B,C,D,E,F,G,H,I,J,K,L,N,O) => T) = Def.app( k14(t14) )( hf14(z) )
-        def identity = apply(mkTuple14)
-    }
-    final class Apply15[A,B,C,D,E,F,G,H,I,J,K,L,N,O,P](t15: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K], Initialize[L], Initialize[N], Initialize[O], Initialize[P])) {
-        def apply[T](z: (A,B,C,D,E,F,G,H,I,J,K,L,N,O,P) => T) = Def.app( k15(t15) )( hf15(z) )
-        def identity = apply(mkTuple15)
-    }
-*/
-  private[sbt] def extendScoped(s1: Scoped, ss: Seq[Scoped]): Seq[AttributeKey[_]] = s1.key +: ss.map(_.key)
+
+  // format: on
+
+  private[sbt] def extendScoped(s1: Scoped, ss: Seq[Scoped]): Seq[AttributeKey[_]] =
+    s1.key +: ss.map(_.key)
 }
 
+/** The sbt 0.10 style DSL was deprecated in 0.13.13, favouring the use of the '.value' macro.
+ *
+ * See https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#Migrating+from+sbt+0.12+style for how to migrate.
+ */
+trait TupleSyntax {
+  import Scoped._
+
+  // format: off
+
+  // this is the least painful arrangement I came up with
+  type ST[T] = Taskable[T]
+  implicit def t2ToTable2[A, B](t2: (ST[A], ST[B])): RichTaskable2[A, B] = new RichTaskable2(t2)
+  implicit def t3ToTable3[A, B, C](t3: (ST[A], ST[B], ST[C])): RichTaskable3[A, B, C] = new RichTaskable3(t3)
+  implicit def t4ToTable4[A, B, C, D](t4: (ST[A], ST[B], ST[C], ST[D])): RichTaskable4[A, B, C, D] = new RichTaskable4(t4)
+  implicit def t5ToTable5[A, B, C, D, E](t5: (ST[A], ST[B], ST[C], ST[D], ST[E])): RichTaskable5[A, B, C, D, E] = new RichTaskable5(t5)
+  implicit def t6ToTable6[A, B, C, D, E, F](t6: (ST[A], ST[B], ST[C], ST[D], ST[E], ST[F])): RichTaskable6[A, B, C, D, E, F] = new RichTaskable6(t6)
+  implicit def t7ToTable7[A, B, C, D, E, F, G](t7: (ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G])): RichTaskable7[A, B, C, D, E, F, G] = new RichTaskable7(t7)
+  implicit def t8ToTable8[A, B, C, D, E, F, G, H](t8: (ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H])): RichTaskable8[A, B, C, D, E, F, G, H] = new RichTaskable8(t8)
+  implicit def t9ToTable9[A, B, C, D, E, F, G, H, I](t9: (ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I])): RichTaskable9[A, B, C, D, E, F, G, H, I] = new RichTaskable9(t9)
+  implicit def t10ToTable10[A, B, C, D, E, F, G, H, I, J](t10: (ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I], ST[J])): RichTaskable10[A, B, C, D, E, F, G, H, I, J] = new RichTaskable10(t10)
+  implicit def t11ToTable11[A, B, C, D, E, F, G, H, I, J, K](t11: (ST[A], ST[B], ST[C], ST[D], ST[E], ST[F], ST[G], ST[H], ST[I], ST[J], ST[K])): RichTaskable11[A, B, C, D, E, F, G, H, I, J, K] = new RichTaskable11(t11)
+
+  implicit def t2ToApp2[A, B](t2: (Initialize[A], Initialize[B])): Apply2[A, B] = new Apply2(t2)
+  implicit def t3ToApp3[A, B, C](t3: (Initialize[A], Initialize[B], Initialize[C])): Apply3[A, B, C] = new Apply3(t3)
+  implicit def t4ToApp4[A, B, C, D](t4: (Initialize[A], Initialize[B], Initialize[C], Initialize[D])): Apply4[A, B, C, D] = new Apply4(t4)
+  implicit def t5ToApp5[A, B, C, D, E](t5: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E])): Apply5[A, B, C, D, E] = new Apply5(t5)
+  implicit def t6ToApp6[A, B, C, D, E, F](t6: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F])): Apply6[A, B, C, D, E, F] = new Apply6(t6)
+  implicit def t7ToApp7[A, B, C, D, E, F, G](t7: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G])): Apply7[A, B, C, D, E, F, G] = new Apply7(t7)
+  implicit def t8ToApp8[A, B, C, D, E, F, G, H](t8: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H])): Apply8[A, B, C, D, E, F, G, H] = new Apply8(t8)
+  implicit def t9ToApp9[A, B, C, D, E, F, G, H, I](t9: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I])): Apply9[A, B, C, D, E, F, G, H, I] = new Apply9(t9)
+  implicit def t10ToApp10[A, B, C, D, E, F, G, H, I, J](t10: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J])): Apply10[A, B, C, D, E, F, G, H, I, J] = new Apply10(t10)
+  implicit def t11ToApp11[A, B, C, D, E, F, G, H, I, J, K](t11: (Initialize[A], Initialize[B], Initialize[C], Initialize[D], Initialize[E], Initialize[F], Initialize[G], Initialize[H], Initialize[I], Initialize[J], Initialize[K])): Apply11[A, B, C, D, E, F, G, H, I, J, K] = new Apply11(t11)
+
+  // format: on
+}
+
+object TupleSyntax extends TupleSyntax
+
 import Scoped.extendScoped
 
 /** Constructs InputKeys, which are associated with input tasks to define a setting.*/
 object InputKey {
-  def apply[T: Manifest](label: String, description: String = "", rank: Int = KeyRanks.DefaultInputRank): InputKey[T] =
+  def apply[T: Manifest](
+      label: String,
+      description: String = "",
+      rank: Int = KeyRanks.DefaultInputRank
+  ): InputKey[T] =
     apply(AttributeKey[InputTask[T]](label, description, rank))
 
-  def apply[T: Manifest](label: String, description: String, extend1: Scoped, extendN: Scoped*): InputKey[T] =
-    apply(label, description, KeyRanks.DefaultInputRank, extend1, extendN: _*)
+  def apply[T: Manifest](
+      label: String,
+      description: String,
+      extend1: Scoped,
+      extendN: Scoped*
+  ): InputKey[T] = apply(label, description, KeyRanks.DefaultInputRank, extend1, extendN: _*)
 
-  def apply[T: Manifest](label: String, description: String, rank: Int, extend1: Scoped, extendN: Scoped*): InputKey[T] =
+  def apply[T: Manifest](
+      label: String,
+      description: String,
+      rank: Int,
+      extend1: Scoped,
+      extendN: Scoped*
+  ): InputKey[T] =
     apply(AttributeKey[InputTask[T]](label, description, extendScoped(extend1, extendN), rank))
 
   def apply[T](akey: AttributeKey[InputTask[T]]): InputKey[T] =
-    new InputKey[T] { val key = akey; def scope = Scope.ThisScope }
+    Scoped.scopedInput(Scope.ThisScope, akey)
 }
 
 /** Constructs TaskKeys, which are associated with tasks to define a setting.*/
 object TaskKey {
-  def apply[T: Manifest](label: String, description: String = "", rank: Int = KeyRanks.DefaultTaskRank): TaskKey[T] =
+  def apply[T: Manifest](
+      label: String,
+      description: String = "",
+      rank: Int = KeyRanks.DefaultTaskRank
+  ): TaskKey[T] =
     apply(AttributeKey[Task[T]](label, description, rank))
 
-  def apply[T: Manifest](label: String, description: String, extend1: Scoped, extendN: Scoped*): TaskKey[T] =
+  def apply[T: Manifest](
+      label: String,
+      description: String,
+      extend1: Scoped,
+      extendN: Scoped*
+  ): TaskKey[T] =
     apply(AttributeKey[Task[T]](label, description, extendScoped(extend1, extendN)))
 
-  def apply[T: Manifest](label: String, description: String, rank: Int, extend1: Scoped, extendN: Scoped*): TaskKey[T] =
+  def apply[T: Manifest](
+      label: String,
+      description: String,
+      rank: Int,
+      extend1: Scoped,
+      extendN: Scoped*
+  ): TaskKey[T] =
     apply(AttributeKey[Task[T]](label, description, extendScoped(extend1, extendN), rank))
 
-  def apply[T](akey: AttributeKey[Task[T]]): TaskKey[T] =
-    new TaskKey[T] { val key = akey; def scope = Scope.ThisScope }
+  def apply[T](akey: AttributeKey[Task[T]]): TaskKey[T] = Scoped.scopedTask(Scope.ThisScope, akey)
 
   def local[T: Manifest]: TaskKey[T] = apply[T](AttributeKey.local[Task[T]])
 }
 
 /** Constructs SettingKeys, which are associated with a value to define a basic setting.*/
 object SettingKey {
-  def apply[T: Manifest](label: String, description: String = "", rank: Int = KeyRanks.DefaultSettingRank): SettingKey[T] =
+  def apply[T: Manifest: OptJsonWriter](
+      label: String,
+      description: String = "",
+      rank: Int = KeyRanks.DefaultSettingRank
+  ): SettingKey[T] =
     apply(AttributeKey[T](label, description, rank))
 
-  def apply[T: Manifest](label: String, description: String, extend1: Scoped, extendN: Scoped*): SettingKey[T] =
+  def apply[T: Manifest: OptJsonWriter](
+      label: String,
+      description: String,
+      extend1: Scoped,
+      extendN: Scoped*
+  ): SettingKey[T] =
     apply(AttributeKey[T](label, description, extendScoped(extend1, extendN)))
 
-  def apply[T: Manifest](label: String, description: String, rank: Int, extend1: Scoped, extendN: Scoped*): SettingKey[T] =
+  def apply[T: Manifest: OptJsonWriter](
+      label: String,
+      description: String,
+      rank: Int,
+      extend1: Scoped,
+      extendN: Scoped*
+  ): SettingKey[T] =
     apply(AttributeKey[T](label, description, extendScoped(extend1, extendN), rank))
 
-  def apply[T](akey: AttributeKey[T]): SettingKey[T] =
-    new SettingKey[T] { val key = akey; def scope = Scope.ThisScope }
+  def apply[T](akey: AttributeKey[T]): SettingKey[T] = Scoped.scopedSetting(Scope.ThisScope, akey)
 
-  def local[T: Manifest]: SettingKey[T] = apply[T](AttributeKey.local[T])
+  def local[T: Manifest: OptJsonWriter]: SettingKey[T] = apply[T](AttributeKey.local[T])
 }
diff --git a/main-settings/src/main/scala/sbt/dsl/LinterLevel.scala b/main-settings/src/main/scala/sbt/dsl/LinterLevel.scala
new file mode 100644
index 000000000..7fe257c82
--- /dev/null
+++ b/main-settings/src/main/scala/sbt/dsl/LinterLevel.scala
@@ -0,0 +1,67 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.dsl
+
+/**
+ * Controls the kind of linting performed during task macro expansion. The linting level is
+ * controlled by implicitly bringing an instance of LinterLevel into scope:* {{{
+ *   val foo = taskKey[Unit]("")
+ *   val bar = taskKey[Unit]("")
+ *   // This compiles because of the import in the block
+ *   val fooTask = {
+ *     import sbt.dsl.LinterLevel.Ignore
+ *     Def.task {
+ *       if (true) bar.value
+ *       else bar.value
+ *     }
+ *   }
+ *   // because the import above was in a local scope, it does not apply here, so this won't
+ *   // compile:
+ *   //val barTask = Def.task {
+ *   //  if (true) foo.value
+ *   //  else foo.value
+ *   //}
+ *
+ *   import sbt.dsl.LinterLevel.Ignore
+ *   // Both defs compile because the Ignore LinterLevel is implicitly brought into scope and
+ *   // picked up by both task defs underneath
+ *   val newFooTask = Def.task {
+ *     if (true) bar.value
+ *     else bar.value
+ *   }
+ *   val barTask = Def.task {
+ *     if (true) foo.value
+ *     else foo.value
+ *   }
+ * }}}
+ * To make this work, the instances are all defined as implicit case objects. Moreover, the
+ * the [[LinterLevel.Warn]] setting is made default by placing [[LinterLevel.Abort]] and
+ * [[LinterLevel.Ignore]] using the low priority trait pattern.
+ */
+sealed trait LinterLevel
+object LinterLevel extends LinterLevelLowPriority {
+
+  /**
+   * Apply the linter but print warnings instead of aborting macro expansion when linter violations
+   * are found.
+   */
+  implicit case object Warn extends LinterLevel
+}
+
+private[dsl] trait LinterLevelLowPriority {
+
+  /**
+   * Abort the macro expansion if any linter check fails.
+   */
+  implicit case object Abort extends LinterLevel
+
+  /**
+   * Do not perform any linting.
+   */
+  implicit case object Ignore extends LinterLevel
+}
diff --git a/main-settings/src/main/scala/sbt/std/InputConvert.scala b/main-settings/src/main/scala/sbt/std/InputConvert.scala
index 9b185c3c0..c133a2eaa 100644
--- a/main-settings/src/main/scala/sbt/std/InputConvert.scala
+++ b/main-settings/src/main/scala/sbt/std/InputConvert.scala
@@ -1,11 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package std
 
-import reflect.macros._
+import scala.reflect.macros._
 
-import Def.Initialize
 import sbt.internal.util.complete.Parser
 import sbt.internal.util.appmacro.{ Convert, Converted }
+import Def.Initialize
 
 object InputInitConvert extends Convert {
   def apply[T: c.WeakTypeTag](c: blackbox.Context)(nme: String, in: c.Tree): Converted[c.type] =
@@ -33,28 +40,28 @@ object ParserConvert extends Convert {
 /** Convert instance for plain `Task`s not within the settings system. */
 object TaskConvert extends Convert {
   def apply[T: c.WeakTypeTag](c: blackbox.Context)(nme: String, in: c.Tree): Converted[c.type] =
-    if (nme == InputWrapper.WrapTaskName) Converted.Success[c.type](in) else Converted.NotApplicable[c.type]
+    if (nme == InputWrapper.WrapTaskName) Converted.Success[c.type](in)
+    else Converted.NotApplicable[c.type]
 }
 
 /** Converts an input `Tree` of type `Initialize[T]`, `Initialize[Task[T]]`, or `Task[T]` into a `Tree` of type `Initialize[Task[T]]`.*/
 object FullConvert extends Convert {
-  import InputWrapper._
   def apply[T: c.WeakTypeTag](c: blackbox.Context)(nme: String, in: c.Tree): Converted[c.type] =
     nme match {
-      case WrapInitTaskName => Converted.Success[c.type](in)
-      case WrapPreviousName => Converted.Success[c.type](in)
-      case WrapInitName     => wrapInit[T](c)(in)
-      case WrapTaskName     => wrapTask[T](c)(in)
-      case _                => Converted.NotApplicable[c.type]
+      case InputWrapper.WrapInitTaskName => Converted.Success[c.type](in)
+      case InputWrapper.WrapPreviousName => Converted.Success[c.type](in)
+      case InputWrapper.WrapInitName     => wrapInit[T](c)(in)
+      case InputWrapper.WrapTaskName     => wrapTask[T](c)(in)
+      case _                             => Converted.NotApplicable[c.type]
     }
 
-  private def wrapInit[T](c: blackbox.Context)(tree: c.Tree): Converted[c.type] = {
+  private def wrapInit[T: c.WeakTypeTag](c: blackbox.Context)(tree: c.Tree): Converted[c.type] = {
     val i = c.Expr[Initialize[T]](tree)
     val t = c.universe.reify(Def.toITask(i.splice)).tree
     Converted.Success[c.type](t)
   }
 
-  private def wrapTask[T](c: blackbox.Context)(tree: c.Tree): Converted[c.type] = {
+  private def wrapTask[T: c.WeakTypeTag](c: blackbox.Context)(tree: c.Tree): Converted[c.type] = {
     val i = c.Expr[Task[T]](tree)
     val t = c.universe.reify(Def.valueStrict[Task[T]](i.splice)).tree
     Converted.Success[c.type](t)
@@ -73,7 +80,7 @@ object InitParserConvert extends Convert {
       case _                        => Converted.NotApplicable[c.type]
     }
 
-  private def wrap[T](c: blackbox.Context)(tree: c.Tree): Converted[c.type] = {
+  private def wrap[T: c.WeakTypeTag](c: blackbox.Context)(tree: c.Tree): Converted[c.type] = {
     val e = c.Expr[State => Parser[T]](tree)
     val t = c.universe.reify { Def.valueStrict[State => Parser[T]](e.splice) }
     Converted.Success[c.type](t.tree)
diff --git a/main-settings/src/main/scala/sbt/std/InputWrapper.scala b/main-settings/src/main/scala/sbt/std/InputWrapper.scala
index 93dd79f87..f0fc8fb62 100644
--- a/main-settings/src/main/scala/sbt/std/InputWrapper.scala
+++ b/main-settings/src/main/scala/sbt/std/InputWrapper.scala
@@ -1,9 +1,17 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package std
 
-import language.experimental.macros
-import reflect.macros._
-import reflect.internal.annotations.compileTimeOnly
+import scala.language.experimental.macros
+
+import scala.annotation.compileTimeOnly
+import scala.reflect.macros._
 
 import Def.Initialize
 import sbt.internal.util.appmacro.ContextUtil
@@ -22,39 +30,73 @@ object InputWrapper {
   private[std] final val WrapInputName = "wrapInputTask_\u2603\u2603"
   private[std] final val WrapPreviousName = "wrapPrevious_\u2603\u2603"
 
-  @compileTimeOnly("`value` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task.")
-  def wrapTask_\u2603\u2603[T](in: Any): T = implDetailError
+  @compileTimeOnly(
+    "`value` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task."
+  )
+  def `wrapTask_\u2603\u2603`[T](@deprecated("unused", "") in: Any): T = implDetailError
 
-  @compileTimeOnly("`value` can only be used within a task or setting macro, such as :=, +=, ++=, Def.task, or Def.setting.")
-  def wrapInit_\u2603\u2603[T](in: Any): T = implDetailError
+  @compileTimeOnly(
+    "`value` can only be used within a task or setting macro, such as :=, +=, ++=, Def.task, or Def.setting."
+  )
+  def `wrapInit_\u2603\u2603`[T](@deprecated("unused", "") in: Any): T = implDetailError
 
-  @compileTimeOnly("`value` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task.")
-  def wrapInitTask_\u2603\u2603[T](in: Any): T = implDetailError
+  @compileTimeOnly(
+    "`value` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task."
+  )
+  def `wrapInitTask_\u2603\u2603`[T](@deprecated("unused", "") in: Any): T = implDetailError
 
-  @compileTimeOnly("`value` can only be called on an input task within a task definition macro, such as := or Def.inputTask.")
-  def wrapInputTask_\u2603\u2603[T](in: Any): T = implDetailError
+  @compileTimeOnly(
+    "`value` can only be called on an input task within a task definition macro, such as := or Def.inputTask."
+  )
+  def `wrapInputTask_\u2603\u2603`[T](@deprecated("unused", "") in: Any): T = implDetailError
 
-  @compileTimeOnly("`value` can only be called on an input task within a task definition macro, such as := or Def.inputTask.")
-  def wrapInitInputTask_\u2603\u2603[T](in: Any): T = implDetailError
+  @compileTimeOnly(
+    "`value` can only be called on an input task within a task definition macro, such as := or Def.inputTask."
+  )
+  def `wrapInitInputTask_\u2603\u2603`[T](@deprecated("unused", "") in: Any): T = implDetailError
 
-  @compileTimeOnly("`previous` can only be called on a task within a task or input task definition macro, such as :=, +=, ++=, Def.task, or Def.inputTask.")
-  def wrapPrevious_\u2603\u2603[T](in: Any): T = implDetailError
+  @compileTimeOnly(
+    "`previous` can only be called on a task within a task or input task definition macro, such as :=, +=, ++=, Def.task, or Def.inputTask."
+  )
+  def `wrapPrevious_\u2603\u2603`[T](@deprecated("unused", "") in: Any): T = implDetailError
 
-  private[this] def implDetailError = sys.error("This method is an implementation detail and should not be referenced.")
+  private[this] def implDetailError =
+    sys.error("This method is an implementation detail and should not be referenced.")
 
-  private[std] def wrapTask[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
+  private[std] def wrapTask[T: c.WeakTypeTag](c: blackbox.Context)(
+      ts: c.Expr[Any],
+      pos: c.Position
+  ): c.Expr[T] =
     wrapImpl[T, InputWrapper.type](c, InputWrapper, WrapTaskName)(ts, pos)
-  private[std] def wrapInit[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
+
+  private[std] def wrapInit[T: c.WeakTypeTag](c: blackbox.Context)(
+      ts: c.Expr[Any],
+      pos: c.Position
+  ): c.Expr[T] =
     wrapImpl[T, InputWrapper.type](c, InputWrapper, WrapInitName)(ts, pos)
-  private[std] def wrapInitTask[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
+
+  private[std] def wrapInitTask[T: c.WeakTypeTag](c: blackbox.Context)(
+      ts: c.Expr[Any],
+      pos: c.Position
+  ): c.Expr[T] =
     wrapImpl[T, InputWrapper.type](c, InputWrapper, WrapInitTaskName)(ts, pos)
 
-  private[std] def wrapInitInputTask[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
+  private[std] def wrapInitInputTask[T: c.WeakTypeTag](c: blackbox.Context)(
+      ts: c.Expr[Any],
+      pos: c.Position
+  ): c.Expr[T] =
     wrapImpl[T, InputWrapper.type](c, InputWrapper, WrapInitInputName)(ts, pos)
-  private[std] def wrapInputTask[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
+
+  private[std] def wrapInputTask[T: c.WeakTypeTag](c: blackbox.Context)(
+      ts: c.Expr[Any],
+      pos: c.Position
+  ): c.Expr[T] =
     wrapImpl[T, InputWrapper.type](c, InputWrapper, WrapInputName)(ts, pos)
 
-  private[std] def wrapPrevious[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[Option[T]] =
+  private[std] def wrapPrevious[T: c.WeakTypeTag](c: blackbox.Context)(
+      ts: c.Expr[Any],
+      pos: c.Position
+  ): c.Expr[Option[T]] =
     wrapImpl[Option[T], InputWrapper.type](c, InputWrapper, WrapPreviousName)(ts, pos)
 
   /**
@@ -63,44 +105,52 @@ object InputWrapper {
    *
    * `c.universe.reify { <s>.<wrapName>[T](ts.splice) }`
    */
-  def wrapImpl[T: c.WeakTypeTag, S <: AnyRef with Singleton](c: blackbox.Context, s: S, wrapName: String)(ts: c.Expr[Any], pos: c.Position)(implicit it: c.TypeTag[s.type]): c.Expr[T] =
-    {
-      import c.universe.{ Apply => ApplyTree, _ }
-      import internal.decorators._
-      val util = new ContextUtil[c.type](c)
-      val iw = util.singleton(s)
-      val tpe = c.weakTypeOf[T]
-      val nme = TermName(wrapName).encodedName
-      val sel = Select(Ident(iw), nme)
-      sel.setPos(pos) // need to set the position on Select, because that is where the compileTimeOnly check looks
-      val tree = ApplyTree(TypeApply(sel, TypeTree(tpe) :: Nil), ts.tree :: Nil)
-      tree.setPos(ts.tree.pos)
-      // JZ: I'm not sure why we need to do this. Presumably a caller is wrapping this tree in a
-      //     typed tree *before* handing the whole thing back to the macro engine. One must never splice
-      //     untyped trees under typed trees, as the type checker doesn't descend if `tree.tpe == null`.
-      //
-      //     #1031 The previous attempt to fix this just set the type on `tree`, which worked in cases when the
-      //     call to `.value` was inside a the task macro and eliminated before the end of the typer phase.
-      //     But, if a "naked" call to `.value` left the typer, the superaccessors phase would freak out when
-      //     if hit the untyped trees, before we could get to refchecks and the desired @compileTimeOnly warning.
-      val typedTree = c.typecheck(tree)
-      c.Expr[T](typedTree)
-    }
+  def wrapImpl[T: c.WeakTypeTag, S <: AnyRef with Singleton](
+      c: blackbox.Context,
+      s: S,
+      wrapName: String
+  )(ts: c.Expr[Any], pos: c.Position)(implicit it: c.TypeTag[s.type]): c.Expr[T] = {
+    import c.universe.{ Apply => ApplyTree, _ }
+    import internal.decorators._
+    val util = new ContextUtil[c.type](c)
+    val iw = util.singleton(s)
+    val tpe = c.weakTypeOf[T]
+    val nme = TermName(wrapName).encodedName
+    val sel = Select(Ident(iw), nme)
+    sel.setPos(pos) // need to set the position on Select, because that is where the compileTimeOnly check looks
+    val tree = ApplyTree(TypeApply(sel, TypeTree(tpe) :: Nil), ts.tree :: Nil)
+    tree.setPos(ts.tree.pos)
+    // JZ: I'm not sure why we need to do this. Presumably a caller is wrapping this tree in a
+    //     typed tree *before* handing the whole thing back to the macro engine. One must never splice
+    //     untyped trees under typed trees, as the type checker doesn't descend if `tree.tpe == null`.
+    //
+    //     #1031 The previous attempt to fix this just set the type on `tree`, which worked in cases when the
+    //     call to `.value` was inside a the task macro and eliminated before the end of the typer phase.
+    //     But, if a "naked" call to `.value` left the typer, the superaccessors phase would freak out when
+    //     if hit the untyped trees, before we could get to refchecks and the desired @compileTimeOnly warning.
+    val typedTree = c.typecheck(tree)
+    c.Expr[T](typedTree)
+  }
 
   def valueMacroImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[T] =
     ContextUtil.selectMacroImpl[T](c) { (ts, pos) =>
       ts.tree.tpe match {
         case tpe if tpe <:< c.weakTypeOf[Initialize[T]] =>
           if (c.weakTypeOf[T] <:< c.weakTypeOf[InputTask[_]]) {
-            c.abort(pos, """`value` is removed from input tasks. Use `evaluated` or `inputTaskValue`.
-                           |See http://www.scala-sbt.org/1.0/docs/Input-Tasks.html for more details.""".stripMargin)
+            c.abort(
+              pos,
+              """`value` is removed from input tasks. Use `evaluated` or `inputTaskValue`.
+                           |See https://www.scala-sbt.org/1.0/docs/Input-Tasks.html for more details.""".stripMargin
+            )
           }
           InputWrapper.wrapInit[T](c)(ts, pos)
-        case tpe if tpe <:< c.weakTypeOf[Initialize[Task[T]]]      => InputWrapper.wrapInitTask[T](c)(ts, pos)
-        case tpe if tpe <:< c.weakTypeOf[Task[T]]                  => InputWrapper.wrapTask[T](c)(ts, pos)
-        case tpe if tpe <:< c.weakTypeOf[InputTask[T]]             => InputWrapper.wrapInputTask[T](c)(ts, pos)
-        case tpe if tpe <:< c.weakTypeOf[Initialize[InputTask[T]]] => InputWrapper.wrapInitInputTask[T](c)(ts, pos)
-        case tpe                                                   => unexpectedType(c)(pos, tpe)
+        case tpe if tpe <:< c.weakTypeOf[Initialize[Task[T]]] =>
+          InputWrapper.wrapInitTask[T](c)(ts, pos)
+        case tpe if tpe <:< c.weakTypeOf[Task[T]]      => InputWrapper.wrapTask[T](c)(ts, pos)
+        case tpe if tpe <:< c.weakTypeOf[InputTask[T]] => InputWrapper.wrapInputTask[T](c)(ts, pos)
+        case tpe if tpe <:< c.weakTypeOf[Initialize[InputTask[T]]] =>
+          InputWrapper.wrapInitInputTask[T](c)(ts, pos)
+        case tpe => unexpectedType(c)(pos, tpe)
       }
     }
   def inputTaskValueMacroImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[InputTask[T]] =
@@ -115,51 +165,68 @@ object InputWrapper {
       else
         unexpectedType(c)(pos, tpe)
     }
+
   /** Translates <task: TaskKey[T]>.previous(format) to Previous.runtime(<task>)(format).value*/
-  def previousMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(format: c.Expr[sbinary.Format[T]]): c.Expr[Option[T]] =
-    {
-      import c.universe._
-      c.macroApplication match {
-        case a @ Apply(Select(Apply(_, t :: Nil), tp), fmt) =>
-          if (t.tpe <:< c.weakTypeOf[TaskKey[T]]) {
-            val tsTyped = c.Expr[TaskKey[T]](t)
-            val newTree = c.universe.reify { Previous.runtime[T](tsTyped.splice)(format.splice) }
-            wrapPrevious[T](c)(newTree, a.pos)
-          } else
-            unexpectedType(c)(a.pos, t.tpe)
-        case x => ContextUtil.unexpectedTree(x)
-      }
+  def previousMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(format: c.Expr[sjsonnew.JsonFormat[T]]): c.Expr[Option[T]] = {
+    import c.universe._
+    c.macroApplication match {
+      case a @ Apply(Select(Apply(_, t :: Nil), _), _) =>
+        if (t.tpe <:< c.weakTypeOf[TaskKey[T]]) {
+          val tsTyped = c.Expr[TaskKey[T]](t)
+          val newTree = c.universe.reify { Previous.runtime[T](tsTyped.splice)(format.splice) }
+          wrapPrevious[T](c)(newTree, a.pos)
+        } else
+          unexpectedType(c)(a.pos, t.tpe)
+      case x => ContextUtil.unexpectedTree(x)
     }
+  }
 
   private def unexpectedType(c: blackbox.Context)(pos: c.Position, tpe: c.Type) =
     c.abort(pos, s"Internal sbt error. Unexpected type ${tpe.widen}")
 }
 
 sealed abstract class MacroTaskValue[T] {
-  @compileTimeOnly("`taskValue` can only be used within a setting macro, such as :=, +=, ++=, or Def.setting.")
+  @compileTimeOnly(
+    "`taskValue` can only be used within a setting macro, such as :=, +=, ++=, or Def.setting."
+  )
   def taskValue: Task[T] = macro InputWrapper.taskValueMacroImpl[T]
 }
 sealed abstract class MacroValue[T] {
-  @compileTimeOnly("`value` can only be used within a task or setting macro, such as :=, +=, ++=, Def.task, or Def.setting.")
+  @compileTimeOnly(
+    "`value` can only be used within a task or setting macro, such as :=, +=, ++=, Def.task, or Def.setting."
+  )
   def value: T = macro InputWrapper.valueMacroImpl[T]
 }
 sealed abstract class ParserInput[T] {
-  @compileTimeOnly("`parsed` can only be used within an input task macro, such as := or Def.inputTask.")
+  @compileTimeOnly(
+    "`parsed` can only be used within an input task macro, such as := or Def.inputTask."
+  )
   def parsed: T = macro ParserInput.parsedMacroImpl[T]
 }
 sealed abstract class InputEvaluated[T] {
-  @compileTimeOnly("`evaluated` can only be used within an input task macro, such as := or Def.inputTask.")
+  @compileTimeOnly(
+    "`evaluated` can only be used within an input task macro, such as := or Def.inputTask."
+  )
   def evaluated: T = macro InputWrapper.valueMacroImpl[T]
-  @compileTimeOnly("`inputTaskValue` can only be used within an input task macro, such as := or Def.inputTask.")
+  @compileTimeOnly(
+    "`inputTaskValue` can only be used within an input task macro, such as := or Def.inputTask."
+  )
   def inputTaskValue: InputTask[T] = macro InputWrapper.inputTaskValueMacroImpl[T]
 }
 sealed abstract class ParserInputTask[T] {
-  @compileTimeOnly("`parsed` can only be used within an input task macro, such as := or Def.inputTask.")
+  @compileTimeOnly(
+    "`parsed` can only be used within an input task macro, such as := or Def.inputTask."
+  )
   def parsed: Task[T] = macro ParserInput.parsedInputMacroImpl[T]
 }
 sealed abstract class MacroPrevious[T] {
-  @compileTimeOnly("`previous` can only be used within a task macro, such as :=, +=, ++=, or Def.task.")
-  def previous(implicit format: sbinary.Format[T]): Option[T] = macro InputWrapper.previousMacroImpl[T]
+  @compileTimeOnly(
+    "`previous` can only be used within a task macro, such as :=, +=, ++=, or Def.task."
+  )
+  def previous(implicit format: sjsonnew.JsonFormat[T]): Option[T] =
+    macro InputWrapper.previousMacroImpl[T]
 }
 
 /** Implementation detail.  The wrap method temporarily holds the input parser (as a Tree, at compile time) until the input task macro processes it. */
@@ -170,45 +237,64 @@ object ParserInput {
   private[std] val WrapName = "parser_\u2603\u2603"
   private[std] val WrapInitName = "initParser_\u2603\u2603"
 
-  @compileTimeOnly("`parsed` can only be used within an input task macro, such as := or Def.inputTask.")
-  def parser_\u2603\u2603[T](i: Any): T = sys.error("This method is an implementation detail and should not be referenced.")
+  @compileTimeOnly(
+    "`parsed` can only be used within an input task macro, such as := or Def.inputTask."
+  )
+  def `parser_\u2603\u2603`[T](@deprecated("unused", "") i: Any): T =
+    sys.error("This method is an implementation detail and should not be referenced.")
 
-  @compileTimeOnly("`parsed` can only be used within an input task macro, such as := or Def.inputTask.")
-  def initParser_\u2603\u2603[T](i: Any): T = sys.error("This method is an implementation detail and should not be referenced.")
+  @compileTimeOnly(
+    "`parsed` can only be used within an input task macro, such as := or Def.inputTask."
+  )
+  def `initParser_\u2603\u2603`[T](@deprecated("unused", "") i: Any): T =
+    sys.error("This method is an implementation detail and should not be referenced.")
 
-  private[std] def wrap[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
+  private[std] def wrap[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
     InputWrapper.wrapImpl[T, ParserInput.type](c, ParserInput, WrapName)(ts, pos)
-  private[std] def wrapInit[T: c.WeakTypeTag](c: blackbox.Context)(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
+  private[std] def wrapInit[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(ts: c.Expr[Any], pos: c.Position): c.Expr[T] =
     InputWrapper.wrapImpl[T, ParserInput.type](c, ParserInput, WrapInitName)(ts, pos)
 
-  private[std] def inputParser[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[InputTask[T]]): c.Expr[State => Parser[Task[T]]] = c.universe.reify(t.splice.parser)
+  private[std] def inputParser[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[InputTask[T]]): c.Expr[State => Parser[Task[T]]] =
+    c.universe.reify(t.splice.parser)
 
   def parsedInputMacroImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Task[T]] =
     ContextUtil.selectMacroImpl[Task[T]](c) { (p, pos) =>
       p.tree.tpe match {
-        case tpe if tpe <:< c.weakTypeOf[InputTask[T]]             => wrapInputTask[T](c)(p.tree, pos)
-        case tpe if tpe <:< c.weakTypeOf[Initialize[InputTask[T]]] => wrapInitInputTask[T](c)(p.tree, pos)
-        case tpe                                                   => unexpectedType(c)(pos, tpe, "parsedInputMacroImpl")
+        case tpe if tpe <:< c.weakTypeOf[InputTask[T]] => wrapInputTask[T](c)(p.tree, pos)
+        case tpe if tpe <:< c.weakTypeOf[Initialize[InputTask[T]]] =>
+          wrapInitInputTask[T](c)(p.tree, pos)
+        case tpe => unexpectedType(c)(pos, tpe, "parsedInputMacroImpl")
       }
     }
 
-  private def wrapInputTask[T: c.WeakTypeTag](c: blackbox.Context)(tree: c.Tree, pos: c.Position) = {
+  private def wrapInputTask[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(tree: c.Tree, pos: c.Position) = {
     val e = c.Expr[InputTask[T]](tree)
     wrap[Task[T]](c)(inputParser(c)(e), pos)
   }
 
-  private def wrapInitInputTask[T: c.WeakTypeTag](c: blackbox.Context)(tree: c.Tree, pos: c.Position) = {
+  private def wrapInitInputTask[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(tree: c.Tree, pos: c.Position) = {
     val e = c.Expr[Initialize[InputTask[T]]](tree)
-    wrapInit[Task[T]](c)(c.universe.reify {Def.toIParser(e.splice)}, pos)
+    wrapInit[Task[T]](c)(c.universe.reify { Def.toIParser(e.splice) }, pos)
   }
 
   /** Implements `Parser[T].parsed` by wrapping the Parser with the ParserInput wrapper.*/
   def parsedMacroImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[T] =
     ContextUtil.selectMacroImpl[T](c) { (p, pos) =>
       p.tree.tpe match {
-        case tpe if tpe <:< c.weakTypeOf[Parser[T]]                      => wrapParser[T](c)(p.tree, pos)
-        case tpe if tpe <:< c.weakTypeOf[State => Parser[T]]             => wrap[T](c)(p, pos)
-        case tpe if tpe <:< c.weakTypeOf[Initialize[Parser[T]]]          => wrapInitParser[T](c)(p.tree, pos)
+        case tpe if tpe <:< c.weakTypeOf[Parser[T]]          => wrapParser[T](c)(p.tree, pos)
+        case tpe if tpe <:< c.weakTypeOf[State => Parser[T]] => wrap[T](c)(p, pos)
+        case tpe if tpe <:< c.weakTypeOf[Initialize[Parser[T]]] =>
+          wrapInitParser[T](c)(p.tree, pos)
         case tpe if tpe <:< c.weakTypeOf[Initialize[State => Parser[T]]] => wrapInit[T](c)(p, pos)
         case tpe                                                         => unexpectedType(c)(pos, tpe, "parsedMacroImpl")
       }
@@ -216,12 +302,14 @@ object ParserInput {
 
   private def wrapParser[T: c.WeakTypeTag](c: blackbox.Context)(tree: c.Tree, pos: c.Position) = {
     val e = c.Expr[Parser[T]](tree)
-    wrap[T](c)(c.universe.reify {Def.toSParser(e.splice)}, pos)
+    wrap[T](c)(c.universe.reify { Def.toSParser(e.splice) }, pos)
   }
 
-  private def wrapInitParser[T: c.WeakTypeTag](c: blackbox.Context)(tree: c.Tree, pos: c.Position) = {
+  private def wrapInitParser[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(tree: c.Tree, pos: c.Position) = {
     val e = c.Expr[Initialize[Parser[T]]](tree)
-    val es = c.universe.reify {Def.toISParser(e.splice)}
+    val es = c.universe.reify { Def.toISParser(e.splice) }
     wrapInit[T](c)(es, pos)
   }
 
diff --git a/main-settings/src/main/scala/sbt/std/KeyMacro.scala b/main-settings/src/main/scala/sbt/std/KeyMacro.scala
index 1218691b5..f7eaaf033 100644
--- a/main-settings/src/main/scala/sbt/std/KeyMacro.scala
+++ b/main-settings/src/main/scala/sbt/std/KeyMacro.scala
@@ -1,49 +1,87 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package std
 
-import reflect.macros._
+import scala.annotation.tailrec
+import scala.reflect.macros._
+
+import sbt.util.OptJsonWriter
 
 private[sbt] object KeyMacro {
-  def settingKeyImpl[T: c.WeakTypeTag](c: blackbox.Context)(description: c.Expr[String]): c.Expr[SettingKey[T]] =
-    keyImpl[T, SettingKey[T]](c) { (name, mf) =>
-      c.universe.reify { SettingKey[T](name.splice, description.splice)(mf.splice) }
+  def settingKeyImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(description: c.Expr[String]): c.Expr[SettingKey[T]] =
+    keyImpl2[T, SettingKey[T]](c) { (name, mf, ojw) =>
+      c.universe.reify { SettingKey[T](name.splice, description.splice)(mf.splice, ojw.splice) }
     }
-  def taskKeyImpl[T: c.WeakTypeTag](c: blackbox.Context)(description: c.Expr[String]): c.Expr[TaskKey[T]] =
+  def taskKeyImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(description: c.Expr[String]): c.Expr[TaskKey[T]] =
     keyImpl[T, TaskKey[T]](c) { (name, mf) =>
       c.universe.reify { TaskKey[T](name.splice, description.splice)(mf.splice) }
     }
-  def inputKeyImpl[T: c.WeakTypeTag](c: blackbox.Context)(description: c.Expr[String]): c.Expr[InputKey[T]] =
+  def inputKeyImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(description: c.Expr[String]): c.Expr[InputKey[T]] =
     keyImpl[T, InputKey[T]](c) { (name, mf) =>
       c.universe.reify { InputKey[T](name.splice, description.splice)(mf.splice) }
     }
 
-  def keyImpl[T: c.WeakTypeTag, S: c.WeakTypeTag](c: blackbox.Context)(f: (c.Expr[String], c.Expr[Manifest[T]]) => c.Expr[S]): c.Expr[S] =
-    {
-      import c.universe._
-      val enclosingValName = definingValName(c, methodName => s"""$methodName must be directly assigned to a val, such as `val x = $methodName[Int]("description")`.""")
-      val name = c.Expr[String](Literal(Constant(enclosingValName)))
-      val mf = c.Expr[Manifest[T]](c.inferImplicitValue(weakTypeOf[Manifest[T]]))
-      f(name, mf)
-    }
-  def definingValName(c: blackbox.Context, invalidEnclosingTree: String => String): String =
-    {
-      import c.universe.{ Apply => ApplyTree, _ }
-      val methodName = c.macroApplication.symbol.name
-      def processName(n: Name): String = n.decodedName.toString.trim // trim is not strictly correct, but macros don't expose the API necessary
-      def enclosingVal(trees: List[c.Tree]): String =
-        {
-          trees match {
-            case vd @ ValDef(_, name, _, _) :: ts => processName(name)
-            case (_: ApplyTree | _: Select | _: TypeApply) :: xs => enclosingVal(xs)
-            // lazy val x: X = <methodName> has this form for some reason (only when the explicit type is present, though)
-            case Block(_, _) :: DefDef(mods, name, _, _, _, _) :: xs if mods.hasFlag(Flag.LAZY) => processName(name)
-            case _ =>
-              c.error(c.enclosingPosition, invalidEnclosingTree(methodName.decodedName.toString))
-              "<error>"
-          }
-        }
-      enclosingVal(enclosingTrees(c).toList)
+  def keyImpl[T: c.WeakTypeTag, S: c.WeakTypeTag](c: blackbox.Context)(
+      f: (c.Expr[String], c.Expr[Manifest[T]]) => c.Expr[S]
+  ): c.Expr[S] =
+    f(getName(c), getImplicit[Manifest[T]](c))
+
+  private def keyImpl2[T: c.WeakTypeTag, S: c.WeakTypeTag](c: blackbox.Context)(
+      f: (c.Expr[String], c.Expr[Manifest[T]], c.Expr[OptJsonWriter[T]]) => c.Expr[S]
+  ): c.Expr[S] =
+    f(getName(c), getImplicit[Manifest[T]](c), getImplicit[OptJsonWriter[T]](c))
+
+  private def getName[S: c.WeakTypeTag, T: c.WeakTypeTag](c: blackbox.Context): c.Expr[String] = {
+    import c.universe._
+    val enclosingValName = definingValName(
+      c,
+      methodName =>
+        s"""$methodName must be directly assigned to a val, such as `val x = $methodName[Int]("description")`."""
+    )
+    c.Expr[String](Literal(Constant(enclosingValName)))
+  }
+
+  private def getImplicit[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[T] = {
+    import c.universe._
+    c.Expr[T](c.inferImplicitValue(weakTypeOf[T]))
+  }
+
+  def definingValName(c: blackbox.Context, invalidEnclosingTree: String => String): String = {
+    import c.universe.{ Apply => ApplyTree, _ }
+    val methodName = c.macroApplication.symbol.name
+    def processName(n: Name): String =
+      n.decodedName.toString.trim // trim is not strictly correct, but macros don't expose the API necessary
+    @tailrec def enclosingVal(trees: List[c.Tree]): String = {
+      trees match {
+        case ValDef(_, name, _, _) :: _                      => processName(name)
+        case (_: ApplyTree | _: Select | _: TypeApply) :: xs => enclosingVal(xs)
+        // lazy val x: X = <methodName> has this form for some reason (only when the explicit type is present, though)
+        case Block(_, _) :: DefDef(mods, name, _, _, _, _) :: _ if mods.hasFlag(Flag.LAZY) =>
+          processName(name)
+        case _ =>
+          c.error(c.enclosingPosition, invalidEnclosingTree(methodName.decodedName.toString))
+          "<error>"
+      }
     }
+    enclosingVal(enclosingTrees(c).toList)
+  }
+
   def enclosingTrees(c: blackbox.Context): Seq[c.Tree] =
-    c.asInstanceOf[reflect.macros.runtime.Context].callsiteTyper.context.enclosingContextChain.map(_.tree.asInstanceOf[c.Tree])
+    c.asInstanceOf[reflect.macros.runtime.Context]
+      .callsiteTyper
+      .context
+      .enclosingContextChain
+      .map(_.tree.asInstanceOf[c.Tree])
 }
diff --git a/main-settings/src/main/scala/sbt/std/SettingMacro.scala b/main-settings/src/main/scala/sbt/std/SettingMacro.scala
index 1fc0dda4a..43128193b 100644
--- a/main-settings/src/main/scala/sbt/std/SettingMacro.scala
+++ b/main-settings/src/main/scala/sbt/std/SettingMacro.scala
@@ -1,14 +1,29 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package std
 
 import Def.Initialize
-import sbt.internal.util.Types.{ idFun, Id }
+import sbt.internal.util.Types.{ Id, idFun }
 import sbt.internal.util.AList
-import sbt.internal.util.appmacro.{ Convert, Converted, Instance, MixedBuilder, MonadInstance }
+import sbt.internal.util.appmacro.{
+  Convert,
+  Converted,
+  Instance,
+  LinterDSL,
+  MixedBuilder,
+  MonadInstance
+}
 
 object InitializeInstance extends MonadInstance {
   type M[x] = Initialize[x]
-  def app[K[L[x]], Z](in: K[Initialize], f: K[Id] => Z)(implicit a: AList[K]): Initialize[Z] = Def.app[K, Z](in)(f)(a)
+  def app[K[L[x]], Z](in: K[Initialize], f: K[Id] => Z)(implicit a: AList[K]): Initialize[Z] =
+    Def.app[K, Z](in)(f)(a)
   def map[S, T](in: Initialize[S], f: S => T): Initialize[T] = Def.map(in)(f)
   def flatten[T](in: Initialize[Initialize[T]]): Initialize[T] = Def.bind(in)(idFun[Initialize[T]])
   def pure[T](t: () => T): Initialize[T] = Def.pure(t)
@@ -25,23 +40,35 @@ object InitializeConvert extends Convert {
       case _                                                         => Converted.NotApplicable
     }
 
-  private def convert[T](c: blackbox.Context)(in: c.Tree): Converted[c.type] =
-    {
-      val i = c.Expr[Initialize[T]](in)
-      val t = c.universe.reify(i.splice).tree
-      Converted.Success(t)
-    }
+  private def convert[T: c.WeakTypeTag](c: blackbox.Context)(in: c.Tree): Converted[c.type] = {
+    val i = c.Expr[Initialize[T]](in)
+    val t = c.universe.reify(i.splice).tree
+    Converted.Success(t)
+  }
 
-  private def failTask[C <: blackbox.Context with Singleton](c: C)(pos: c.Position): Converted[c.type] =
+  private def failTask[C <: blackbox.Context with Singleton](
+      c: C
+  )(pos: c.Position): Converted[c.type] =
     Converted.Failure(pos, "A setting cannot depend on a task")
-  private def failPrevious[C <: blackbox.Context with Singleton](c: C)(pos: c.Position): Converted[c.type] =
+  private def failPrevious[C <: blackbox.Context with Singleton](
+      c: C
+  )(pos: c.Position): Converted[c.type] =
     Converted.Failure(pos, "A setting cannot depend on a task's previous value.")
 }
 
 object SettingMacro {
+  import LinterDSL.{ Empty => EmptyLinter }
   def settingMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[T]): c.Expr[Initialize[T]] =
-    Instance.contImpl[T, Id](c, InitializeInstance, InitializeConvert, MixedBuilder)(Left(t), Instance.idTransform[c.type])
+    Instance.contImpl[T, Id](c, InitializeInstance, InitializeConvert, MixedBuilder, EmptyLinter)(
+      Left(t),
+      Instance.idTransform[c.type]
+    )
 
-  def settingDynMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[Initialize[T]]): c.Expr[Initialize[T]] =
-    Instance.contImpl[T, Id](c, InitializeInstance, InitializeConvert, MixedBuilder)(Right(t), Instance.idTransform[c.type])
+  def settingDynMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[Initialize[T]]): c.Expr[Initialize[T]] =
+    Instance.contImpl[T, Id](c, InitializeInstance, InitializeConvert, MixedBuilder, EmptyLinter)(
+      Right(t),
+      Instance.idTransform[c.type]
+    )
 }
diff --git a/main-settings/src/main/scala/sbt/std/TaskLinterDSL.scala b/main-settings/src/main/scala/sbt/std/TaskLinterDSL.scala
new file mode 100644
index 000000000..6a9b78aa7
--- /dev/null
+++ b/main-settings/src/main/scala/sbt/std/TaskLinterDSL.scala
@@ -0,0 +1,243 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.std
+
+import sbt.SettingKey
+import sbt.dsl.LinterLevel
+import sbt.dsl.LinterLevel.{ Abort, Warn }
+import sbt.internal.util.Terminal
+import sbt.internal.util.appmacro.{ Convert, LinterDSL }
+
+import scala.io.AnsiColor
+import scala.reflect.macros.blackbox
+
+abstract class BaseTaskLinterDSL extends LinterDSL {
+  def isDynamicTask: Boolean
+  def convert: Convert
+
+  private def impl(
+      ctx: blackbox.Context
+  )(tree: ctx.Tree, lint: (ctx.Position, String) => Unit): Unit = {
+    import ctx.universe._
+    val isTask = convert.asPredicate(ctx)
+    val unchecked = symbolOf[sbt.sbtUnchecked].asClass
+    val initializeType = typeOf[sbt.Def.Initialize[_]]
+
+    /*
+     * Lints a task tree.
+     *
+     * @param insideIf indicates whether or not the current tree is enclosed in an if statement.
+     *                It is generally illegal to call `.value` on a task within such a tree unless
+     *                the tree has been annotated with `@sbtUnchecked`.
+     * @param insideAnon indicates whether or not the current tree is enclosed in an anonymous
+     *                   function. It is generally illegal to call `.value` on a task within such
+     *                   a tree unless the tree has been annotated with `@sbtUnchecked`.
+     * @param uncheckedWrapper an optional tree that is provided to lint a tree in the form:
+     *                         `tree.value: @sbtUnchecked` for some tree. This can be used to
+     *                         prevent the linter from rejecting task evaluation within a
+     *                         conditional or an anonymous function.
+     */
+    class traverser(insideIf: Boolean, insideAnon: Boolean, uncheckedWrapper: Option[Tree])
+        extends Traverser {
+
+      def extractUncheckedWrapper(exprAtUseSite: Tree, tt: TypeTree): Option[Tree] = {
+        tt.original match {
+          case Annotated(annot, _) =>
+            Option(annot.tpe) match {
+              case Some(AnnotatedType(annotations, _)) =>
+                val tpeAnnotations = annotations.flatMap(ann => Option(ann.tree.tpe).toList)
+                val symAnnotations = tpeAnnotations.map(_.typeSymbol)
+                val isUnchecked = symAnnotations.contains(unchecked)
+                if (isUnchecked) {
+                  // Use expression at use site, arg contains the old expr
+                  // Referential equality between the two doesn't hold
+                  Some(exprAtUseSite match {
+                    case Typed(t, _) => t
+                    case _           => exprAtUseSite
+                  })
+                } else None
+              case _ => None
+            }
+          case _ => None
+        }
+      }
+
+      @inline def isKey(tpe: Type): Boolean = isInitialize(tpe)
+      @inline def isInitialize(tpe: Type): Boolean = tpe <:< initializeType
+
+      def detectAndErrorOnKeyMissingValue(i: Ident): Unit = {
+        if (isKey(i.tpe)) {
+          val keyName = i.name.decodedName.toString
+          lint(i.pos, TaskLinterDSLFeedback.missingValueForKey(keyName))
+        } else ()
+      }
+
+      def detectAndErrorOnKeyMissingValue(s: Select): Unit = {
+        if (isKey(s.tpe)) {
+          val keyName = s.name.decodedName.toString
+          lint(s.pos, TaskLinterDSLFeedback.missingValueForKey(keyName))
+        } else ()
+      }
+
+      def detectAndErrorOnKeyMissingValue(a: Apply): Unit = {
+        if (isInitialize(a.tpe)) {
+          val expr = "X / y"
+          lint(a.pos, TaskLinterDSLFeedback.missingValueForInitialize(expr))
+        } else ()
+      }
+
+      override def traverse(tree: ctx.universe.Tree): Unit = {
+        tree match {
+          case ap @ Apply(TypeApply(Select(_, name), tpe :: Nil), qual :: Nil) =>
+            val shouldIgnore = uncheckedWrapper.contains(ap)
+            val wrapperName = name.decodedName.toString
+            val (qualName, isSettingKey) =
+              Option(qual.symbol)
+                .map(sym => (sym.name.decodedName.toString, qual.tpe <:< typeOf[SettingKey[_]]))
+                .getOrElse((ap.pos.source.lineToString(ap.pos.line - 1), false))
+
+            if (!isSettingKey && !shouldIgnore && isTask(wrapperName, tpe.tpe, qual)) {
+              if (insideIf && !isDynamicTask) {
+                // Error on the use of value inside the if of a regular task (dyn task is ok)
+                lint(ap.pos, TaskLinterDSLFeedback.useOfValueInsideIfExpression(qualName))
+              }
+              if (insideAnon) {
+                // Error on the use of anonymous functions in any task or dynamic task
+                lint(ap.pos, TaskLinterDSLFeedback.useOfValueInsideAnon(qualName))
+              }
+            }
+            traverse(qual)
+          case If(condition, thenp, elsep) =>
+            traverse(condition)
+            val newTraverser = new traverser(insideIf = true, insideAnon, uncheckedWrapper)
+            newTraverser.traverse(thenp)
+            newTraverser.traverse(elsep)
+          case Typed(expr, tpt: TypeTree) if tpt.original != null =>
+            new traverser(insideIf, insideAnon, extractUncheckedWrapper(expr, tpt)).traverse(expr)
+            traverse(tpt)
+          case Function(vparams, body) =>
+            traverseTrees(vparams)
+            if (!vparams.exists(_.mods.hasFlag(Flag.SYNTHETIC))) {
+              new traverser(insideIf, insideAnon = true, uncheckedWrapper).traverse(body)
+            } else traverse(body)
+          case Block(stmts, expr) =>
+            if (!isDynamicTask) {
+              /* The missing .value analysis is dumb on purpose because it's expensive.
+               * Detecting valid use cases of idents whose type is an sbt key is difficult
+               * and dangerous because we may miss some corner cases. Instead, we report
+               * on the easiest cases in which we are certain that the user does not want
+               * to have a stale key reference. Those are idents in the rhs of a val definition
+               * whose name is `_` and those idents that are in statement position inside blocks.
+               */
+              stmts.foreach {
+                // TODO: Consider using unused names analysis to be able to report on more cases
+                case ValDef(_, valName, _, rhs) if valName == termNames.WILDCARD =>
+                  rhs match {
+                    case i: Ident  => detectAndErrorOnKeyMissingValue(i)
+                    case s: Select => detectAndErrorOnKeyMissingValue(s)
+                    case a: Apply  => detectAndErrorOnKeyMissingValue(a)
+                    case _         => ()
+                  }
+                case i: Ident  => detectAndErrorOnKeyMissingValue(i)
+                case s: Select => detectAndErrorOnKeyMissingValue(s)
+                case a: Apply  => detectAndErrorOnKeyMissingValue(a)
+                case _         => ()
+              }
+            }
+            traverseTrees(stmts)
+            traverse(expr)
+          case _ => super.traverse(tree)
+        }
+      }
+    }
+    new traverser(insideIf = false, insideAnon = false, uncheckedWrapper = None).traverse(tree)
+  }
+
+  override def runLinter(ctx: blackbox.Context)(tree: ctx.Tree): Unit = {
+    import ctx.universe._
+    ctx.inferImplicitValue(weakTypeOf[LinterLevel]) match {
+      case t if t.tpe =:= weakTypeOf[Abort.type] =>
+        impl(ctx)(tree, (pos, msg) => ctx.error(pos, msg))
+      case t if t.tpe =:= weakTypeOf[Warn.type] =>
+        impl(ctx)(tree, (pos, msg) => ctx.warning(pos, msg))
+      case _ => ()
+    }
+  }
+}
+
+object TaskLinterDSL extends BaseTaskLinterDSL {
+  override val isDynamicTask: Boolean = false
+  override def convert: Convert = FullConvert
+}
+
+object OnlyTaskLinterDSL extends BaseTaskLinterDSL {
+  override val isDynamicTask: Boolean = false
+  override def convert: Convert = TaskConvert
+}
+
+object TaskDynLinterDSL extends BaseTaskLinterDSL {
+  override val isDynamicTask: Boolean = true
+  override def convert: Convert = FullConvert
+}
+
+object OnlyTaskDynLinterDSL extends BaseTaskLinterDSL {
+  override val isDynamicTask: Boolean = true
+  override def convert: Convert = TaskConvert
+}
+
+object TaskLinterDSLFeedback {
+  private final val startBold = if (Terminal.isColorEnabled) AnsiColor.BOLD else ""
+  private final val startRed = if (Terminal.isColorEnabled) AnsiColor.RED else ""
+  private final val startGreen = if (Terminal.isColorEnabled) AnsiColor.GREEN else ""
+  private final val reset = if (Terminal.isColorEnabled) AnsiColor.RESET else ""
+
+  private final val ProblemHeader = s"${startRed}problem$reset"
+  private final val SolutionHeader = s"${startGreen}solution$reset"
+
+  def useOfValueInsideAnon(task: String): String =
+    s"""${startBold}The evaluation of `$task` inside an anonymous function is prohibited.$reset
+       |
+       |$ProblemHeader: Task invocations inside anonymous functions are evaluated independently of whether the anonymous function is invoked or not.
+       |$SolutionHeader:
+       |  1. Make `$task` evaluation explicit outside of the function body if you don't care about its evaluation.
+       |  2. Use a dynamic task to evaluate `$task` and pass that value as a parameter to an anonymous function.
+       |  3. Annotate the `$task` evaluation with `@sbtUnchecked`, e.g. `($task.value: @sbtUnchecked)`.
+       |  4. Add `import sbt.dsl.LinterLevel.Ignore` to your build file to disable all task linting.
+    """.stripMargin
+
+  def useOfValueInsideIfExpression(task: String): String =
+    s"""${startBold}value lookup of `$task` inside an `if` expression$reset
+       |
+       |$ProblemHeader: `$task.value` is inside an `if` expression of a regular task.
+       |  Regular tasks always evaluate task dependencies (`.value`) regardless of `if` expressions.
+       |$SolutionHeader:
+       |  1. Use a conditional task `Def.taskIf(...)` to evaluate it when the `if` predicate is true or false.
+       |  2. Or turn the task body into a single `if` expression; the task is then auto-converted to a conditional task. 
+       |  3. Or make the static evaluation explicit by declaring `$task.value` outside the `if` expression.
+       |  4. If you still want to force the static lookup, you may annotate the task lookup with `@sbtUnchecked`, e.g. `($task.value: @sbtUnchecked)`.
+       |  5. Add `import sbt.dsl.LinterLevel.Ignore` to your build file to disable all task linting.
+    """.stripMargin
+
+  def missingValueForKey(key: String): String =
+    s"""${startBold}The key `$key` is not being invoked inside the task definition.$reset
+       |
+       |$ProblemHeader:  Keys missing `.value` are not initialized and their dependency is not registered.
+       |$SolutionHeader:
+       |  1. Replace `$key` by `$key.value` or remove it if unused
+       |  2. Add `import sbt.dsl.LinterLevel.Ignore` to your build file to disable all task linting.
+    """.stripMargin
+
+  def missingValueForInitialize(expr: String): String =
+    s"""${startBold}The setting/task `$expr` is not being invoked inside the task definition.$reset
+       |
+       |$ProblemHeader:  Settings/tasks missing `.value` are not initialized and their dependency is not registered.
+       |$SolutionHeader:
+       |  1. Replace `$expr` by `($expr).value` or remove it if unused.
+       |  2. Add `import sbt.dsl.LinterLevel.Ignore` to your build file to disable all task linting.
+    """.stripMargin
+}
diff --git a/main-settings/src/main/scala/sbt/std/TaskMacro.scala b/main-settings/src/main/scala/sbt/std/TaskMacro.scala
index c159e0387..9d0dd530d 100644
--- a/main-settings/src/main/scala/sbt/std/TaskMacro.scala
+++ b/main-settings/src/main/scala/sbt/std/TaskMacro.scala
@@ -1,12 +1,26 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package std
 
 import Def.{ Initialize, Setting }
-import sbt.internal.util.Types.{ const, idFun, Id }
-import sbt.internal.util.appmacro.{ ContextUtil, Converted, Instance, MixedBuilder, MonadInstance }
+import sbt.internal.util.Types.{ Id, const, idFun }
+import sbt.internal.util.appmacro.{
+  ContextUtil,
+  Converted,
+  Instance,
+  LinterDSL,
+  MixedBuilder,
+  MonadInstance
+}
 import Instance.Transform
 import sbt.internal.util.complete.{ DefaultParsers, Parser }
-import sbt.internal.util.{ AList, LinePosition, NoPosition, SourcePosition }
+import sbt.internal.util.{ AList, LinePosition, NoPosition, SourcePosition, ~> }
 
 import language.experimental.macros
 import scala.annotation.tailrec
@@ -18,7 +32,7 @@ object TaskInstance extends MonadInstance {
   import TaskExtra._
 
   final type M[x] = Task[x]
-  def app[K[L[x]], Z](in: K[Task], f: K[Id] => Z)(implicit a: AList[K]): Task[Z] = Task(Info(), new Mapped[Z, K](in, f compose allM, a))
+  def app[K[L[x]], Z](in: K[Task], f: K[Id] => Z)(implicit a: AList[K]): Task[Z] = in map f
   def map[S, T](in: Task[S], f: S => T): Task[T] = in map f
   def flatten[T](in: Task[Task[T]]): Task[T] = in flatMap idFun[Task[T]]
   def pure[T](t: () => T): Task[T] = toTask(t)
@@ -38,29 +52,35 @@ object ParserInstance extends Instance {
 }
 
 /** Composes the Task and Initialize Instances to provide an Instance for [T] Initialize[Task[T]].*/
-object FullInstance extends Instance.Composed[Initialize, Task](InitializeInstance, TaskInstance) with MonadInstance {
+object FullInstance
+    extends Instance.Composed[Initialize, Task](InitializeInstance, TaskInstance)
+    with MonadInstance {
   type SS = sbt.internal.util.Settings[Scope]
-  val settingsData = TaskKey[SS]("settings-data", "Provides access to the project data for the build.", KeyRanks.DTask)
+  val settingsData = TaskKey[SS](
+    "settings-data",
+    "Provides access to the project data for the build.",
+    KeyRanks.DTask
+  )
 
-  def flatten[T](in: Initialize[Task[Initialize[Task[T]]]]): Initialize[Task[T]] =
-    {
-      import Scoped._
-      (in, settingsData, Def.capturedTransformations) apply {
-        (a: Task[Initialize[Task[T]]], data: Task[SS], f) =>
-          import TaskExtra.multT2Task
-          (a, data) flatMap { case (a, d) => f(a) evaluate d }
+  def flatten[T](in: Initialize[Task[Initialize[Task[T]]]]): Initialize[Task[T]] = {
+    type K[L[x]] = AList.T3K[Task[Initialize[Task[T]]], Task[SS], Initialize ~> Initialize]#l[L]
+    Def.app[K, Task[T]]((in, settingsData, Def.capturedTransformations)) {
+      case (a: Task[Initialize[Task[T]]], data: Task[SS], f) =>
+        import TaskExtra.multT2Task
+        (a, data) flatMap { case (a, d) => f(a) evaluate d }
+    }(AList.tuple3)
+  }
+
+  def flattenFun[S, T](in: Initialize[Task[S => Initialize[Task[T]]]]): Initialize[S => Task[T]] = {
+    type K[L[x]] =
+      AList.T3K[Task[S => Initialize[Task[T]]], Task[SS], Initialize ~> Initialize]#l[L]
+    Def.app[K, S => Task[T]]((in, settingsData, Def.capturedTransformations)) {
+      case (a: Task[S => Initialize[Task[T]]], data: Task[SS], f) => { (s: S) =>
+        import TaskExtra.multT2Task
+        (a, data) flatMap { case (af, d) => f(af(s)) evaluate d }
       }
-    }
-  def flattenFun[S, T](in: Initialize[Task[S => Initialize[Task[T]]]]): Initialize[S => Task[T]] =
-    {
-      import Scoped._
-      (in, settingsData, Def.capturedTransformations) apply {
-        (a: Task[S => Initialize[Task[T]]], data: Task[SS], f) =>
-          (s: S) =>
-            import TaskExtra.multT2Task
-            (a, data) flatMap { case (af, d) => f(af(s)) evaluate d }
-      }
-    }
+    }(AList.tuple3)
+  }
 }
 
 object TaskMacro {
@@ -72,210 +92,353 @@ object TaskMacro {
   final val TransformInitName = "transform"
   final val InputTaskCreateDynName = "createDyn"
   final val InputTaskCreateFreeName = "createFree"
-  final val append1Migration = "Use `lhs += { x.value }`."
-  final val appendNMigration = "Use `lhs ++= { x.value }`."
+  final val append1Migration =
+    "`<+=` operator is removed. Try `lhs += { x.value }`\n  or see https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html."
+  final val appendNMigration =
+    "`<++=` operator is removed. Try `lhs ++= { x.value }`\n  or see https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html."
   final val assignMigration =
-    """Use `key := { x.value }` or `key ~= (old => { newValue })`.
-      |The RHS of `<<=` takes an `Initialize[_]` expression, which can be converted to `:=` style
-      |by wrapping the expression in parenthesis, and calling `.value` at the end.
-      |For example, `key := (key.dependsOn(compile in Test)).value`.""".stripMargin
+    """`<<=` operator is removed. Use `key := { x.value }` or `key ~= (old => { newValue })`.
+      |See https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html""".stripMargin
 
-  def taskMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[T]): c.Expr[Initialize[Task[T]]] =
-    Instance.contImpl[T, Id](c, FullInstance, FullConvert, MixedBuilder)(Left(t), Instance.idTransform[c.type])
+  import LinterDSL.{ Empty => EmptyLinter }
 
-  def taskDynMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[Task[T]]] =
-    Instance.contImpl[T, Id](c, FullInstance, FullConvert, MixedBuilder)(Right(t), Instance.idTransform[c.type])
+  def taskMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[T]): c.Expr[Initialize[Task[T]]] = {
+    import c.universe._
+    t.tree match {
+      // the tree matches `if` and only `if`
+      case If(cond, thenp, elsep) =>
+        c.Expr[Initialize[Task[T]]](mkIfS[T](c)(cond, thenp, elsep))
+      case _ =>
+        Instance.contImpl[T, Id](c, FullInstance, FullConvert, MixedBuilder, TaskLinterDSL)(
+          Left(t),
+          Instance.idTransform[c.type]
+        )
+    }
+  }
+
+  def mkIfS[A: c.WeakTypeTag](
+      c: blackbox.Context
+  )(cond: c.Tree, thenp: c.Tree, elsep: c.Tree): c.Tree = {
+    import c.universe._
+    val AA = implicitly[c.WeakTypeTag[A]].tpe
+    q"""_root_.sbt.Def.ifS[$AA](_root_.sbt.Def.task($cond))(_root_.sbt.Def.task[$AA]($thenp: $AA))(_root_.sbt.Def.task[$AA]($elsep: $AA))"""
+  }
+
+  def taskDynMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[Task[T]]] =
+    Instance.contImpl[T, Id](c, FullInstance, FullConvert, MixedBuilder, TaskDynLinterDSL)(
+      Right(t),
+      Instance.idTransform[c.type]
+    )
+
+  def taskIfMacroImpl[A: c.WeakTypeTag](
+      c: blackbox.Context
+  )(a: c.Expr[A]): c.Expr[Initialize[Task[A]]] = {
+    import c.universe._
+    a.tree match {
+      case Block(stat, If(cond, thenp, elsep)) =>
+        c.Expr[Initialize[Task[A]]](mkIfS(c)(Block(stat, cond), thenp, elsep))
+      case If(cond, thenp, elsep) =>
+        c.Expr[Initialize[Task[A]]](mkIfS(c)(cond, thenp, elsep))
+      case x => ContextUtil.unexpectedTree(x)
+    }
+  }
 
   /** Implementation of := macro for settings. */
-  def settingAssignMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[T]): c.Expr[Setting[T]] =
-    {
-      val init = SettingMacro.settingMacroImpl[T](c)(v)
-      val assign = transformMacroImpl(c)(init.tree)(AssignInitName)
-      c.Expr[Setting[T]](assign)
-    }
+  def settingAssignMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(v: c.Expr[T]): c.Expr[Setting[T]] = {
+    val init = SettingMacro.settingMacroImpl[T](c)(v)
+    val assign = transformMacroImpl(c)(init.tree)(AssignInitName)
+    c.Expr[Setting[T]](assign)
+  }
+
   /** Implementation of := macro for tasks. */
-  def taskAssignMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[T]): c.Expr[Setting[Task[T]]] =
-    {
-      val init = taskMacroImpl[T](c)(v)
-      val assign = transformMacroImpl(c)(init.tree)(AssignInitName)
-      c.Expr[Setting[Task[T]]](assign)
-    }
+  def taskAssignMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(v: c.Expr[T]): c.Expr[Setting[Task[T]]] = {
+    val init = taskMacroImpl[T](c)(v)
+    val assign = transformMacroImpl(c)(init.tree)(AssignInitName)
+    c.Expr[Setting[Task[T]]](assign)
+  }
 
   // Error macros (Restligeist)
   // These macros are there just so we can fail old operators like `<<=` and provide useful migration information.
 
-  def fakeSettingAssignPosition[T: c.WeakTypeTag](c: blackbox.Context)(app: c.Expr[Initialize[T]]): c.Expr[Setting[T]] =
-    ContextUtil.selectMacroImpl[Setting[T]](c) { (ts, pos) =>
-      c.abort(pos, assignMigration)
-    }
-  def fakeSettingAppend1Position[S: c.WeakTypeTag, V: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[Initialize[V]])(a: c.Expr[Append.Value[S, V]]): c.Expr[Setting[S]] =
-    ContextUtil.selectMacroImpl[Setting[S]](c) { (ts, pos) =>
-      c.abort(pos, append1Migration)
-    }
-  def fakeSettingAppendNPosition[S: c.WeakTypeTag, V: c.WeakTypeTag](c: blackbox.Context)(vs: c.Expr[Initialize[V]])(a: c.Expr[Append.Values[S, V]]): c.Expr[Setting[S]] =
-    ContextUtil.selectMacroImpl[Setting[S]](c) { (ts, pos) =>
-      c.abort(pos, appendNMigration)
-    }
-  def fakeItaskAssignPosition[T: c.WeakTypeTag](c: blackbox.Context)(app: c.Expr[Initialize[Task[T]]]): c.Expr[Setting[Task[T]]] =
-    ContextUtil.selectMacroImpl[Setting[Task[T]]](c) { (ts, pos) =>
-      c.abort(pos, assignMigration)
-    }
-  def fakeTaskAppend1Position[S: c.WeakTypeTag, V: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[Initialize[Task[V]]])(a: c.Expr[Append.Value[S, V]]): c.Expr[Setting[Task[S]]] =
-    ContextUtil.selectMacroImpl[Setting[Task[S]]](c) { (ts, pos) =>
-      c.abort(pos, append1Migration)
-    }
-  def fakeTaskAppendNPosition[S: c.WeakTypeTag, V: c.WeakTypeTag](c: blackbox.Context)(vs: c.Expr[Initialize[Task[V]]])(a: c.Expr[Append.Values[S, V]]): c.Expr[Setting[Task[S]]] =
-    ContextUtil.selectMacroImpl[Setting[Task[S]]](c) { (ts, pos) =>
-      c.abort(pos, appendNMigration)
-    }
+  def fakeSettingAssignPosition[T: c.WeakTypeTag](c: blackbox.Context)(
+      @deprecated("unused", "") app: c.Expr[Initialize[T]]
+  ): c.Expr[Setting[T]] =
+    ContextUtil.selectMacroImpl[Setting[T]](c)((_, pos) => c.abort(pos, assignMigration))
 
-  /* Implementations of <<= macro variations for tasks and settings. These just get the source position of the call site.*/
+  def fakeSettingAppend1Position[S: c.WeakTypeTag, V: c.WeakTypeTag](
+      c: blackbox.Context
+  )(@deprecated("unused", "") v: c.Expr[Initialize[V]])(
+      @deprecated("unused", "") a: c.Expr[Append.Value[S, V]]
+  ): c.Expr[Setting[S]] =
+    ContextUtil.selectMacroImpl[Setting[S]](c)((_, pos) => c.abort(pos, append1Migration))
 
-  def itaskAssignPosition[T: c.WeakTypeTag](c: blackbox.Context)(app: c.Expr[Initialize[Task[T]]]): c.Expr[Setting[Task[T]]] =
+  def fakeSettingAppendNPosition[S: c.WeakTypeTag, V: c.WeakTypeTag](
+      c: blackbox.Context
+  )(@deprecated("unused", "") vs: c.Expr[Initialize[V]])(
+      @deprecated("unused", "") a: c.Expr[Append.Values[S, V]]
+  ): c.Expr[Setting[S]] =
+    ContextUtil.selectMacroImpl[Setting[S]](c)((_, pos) => c.abort(pos, appendNMigration))
+
+  def fakeItaskAssignPosition[T: c.WeakTypeTag](c: blackbox.Context)(
+      @deprecated("unused", "") app: c.Expr[Initialize[Task[T]]]
+  ): c.Expr[Setting[Task[T]]] =
+    ContextUtil.selectMacroImpl[Setting[Task[T]]](c)((_, pos) => c.abort(pos, assignMigration))
+
+  def fakeTaskAppend1Position[S: c.WeakTypeTag, V: c.WeakTypeTag](
+      c: blackbox.Context
+  )(@deprecated("unused", "") v: c.Expr[Initialize[Task[V]]])(
+      @deprecated("unused", "") a: c.Expr[Append.Value[S, V]]
+  ): c.Expr[Setting[Task[S]]] =
+    ContextUtil.selectMacroImpl[Setting[Task[S]]](c)((_, pos) => c.abort(pos, append1Migration))
+
+  def fakeTaskAppendNPosition[S: c.WeakTypeTag, V: c.WeakTypeTag](
+      c: blackbox.Context
+  )(@deprecated("unused", "") vs: c.Expr[Initialize[Task[V]]])(
+      @deprecated("unused", "") a: c.Expr[Append.Values[S, V]]
+  ): c.Expr[Setting[Task[S]]] =
+    ContextUtil.selectMacroImpl[Setting[Task[S]]](c)((_, pos) => c.abort(pos, appendNMigration))
+
+  // Implementations of <<= macro variations for tasks and settings.
+  // These just get the source position of the call site.
+
+  def itaskAssignPosition[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(app: c.Expr[Initialize[Task[T]]]): c.Expr[Setting[Task[T]]] =
     settingAssignPosition(c)(app)
-  def taskAssignPositionT[T: c.WeakTypeTag](c: blackbox.Context)(app: c.Expr[Task[T]]): c.Expr[Setting[Task[T]]] =
+
+  def taskAssignPositionT[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(app: c.Expr[Task[T]]): c.Expr[Setting[Task[T]]] =
     itaskAssignPosition(c)(c.universe.reify { Def.valueStrict(app.splice) })
-  def taskAssignPositionPure[T: c.WeakTypeTag](c: blackbox.Context)(app: c.Expr[T]): c.Expr[Setting[Task[T]]] =
+
+  def taskAssignPositionPure[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(app: c.Expr[T]): c.Expr[Setting[Task[T]]] =
     taskAssignPositionT(c)(c.universe.reify { TaskExtra.constant(app.splice) })
-  def taskTransformPosition[S: c.WeakTypeTag](c: blackbox.Context)(f: c.Expr[S => S]): c.Expr[Setting[Task[S]]] =
+
+  def taskTransformPosition[S: c.WeakTypeTag](
+      c: blackbox.Context
+  )(f: c.Expr[S => S]): c.Expr[Setting[Task[S]]] =
     c.Expr[Setting[Task[S]]](transformMacroImpl(c)(f.tree)(TransformInitName))
-  def settingTransformPosition[S: c.WeakTypeTag](c: blackbox.Context)(f: c.Expr[S => S]): c.Expr[Setting[S]] =
+
+  def settingTransformPosition[S: c.WeakTypeTag](
+      c: blackbox.Context
+  )(f: c.Expr[S => S]): c.Expr[Setting[S]] =
     c.Expr[Setting[S]](transformMacroImpl(c)(f.tree)(TransformInitName))
-  def itaskTransformPosition[S: c.WeakTypeTag](c: blackbox.Context)(f: c.Expr[S => S]): c.Expr[Setting[S]] =
+
+  def itaskTransformPosition[S: c.WeakTypeTag](
+      c: blackbox.Context
+  )(f: c.Expr[S => S]): c.Expr[Setting[S]] =
     c.Expr[Setting[S]](transformMacroImpl(c)(f.tree)(TransformInitName))
+
   def settingAssignPure[T: c.WeakTypeTag](c: blackbox.Context)(app: c.Expr[T]): c.Expr[Setting[T]] =
     settingAssignPosition(c)(c.universe.reify { Def.valueStrict(app.splice) })
-  def settingAssignPosition[T: c.WeakTypeTag](c: blackbox.Context)(app: c.Expr[Initialize[T]]): c.Expr[Setting[T]] =
+
+  def settingAssignPosition[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(app: c.Expr[Initialize[T]]): c.Expr[Setting[T]] =
     c.Expr[Setting[T]](transformMacroImpl(c)(app.tree)(AssignInitName))
 
   /** Implementation of := macro for tasks. */
-  def inputTaskAssignMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[T]): c.Expr[Setting[InputTask[T]]] =
-    {
-      val init = inputTaskMacroImpl[T](c)(v)
-      val assign = transformMacroImpl(c)(init.tree)(AssignInitName)
-      c.Expr[Setting[InputTask[T]]](assign)
-    }
+  def inputTaskAssignMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(v: c.Expr[T]): c.Expr[Setting[InputTask[T]]] = {
+    val init = inputTaskMacroImpl[T](c)(v)
+    val assign = transformMacroImpl(c)(init.tree)(AssignInitName)
+    c.Expr[Setting[InputTask[T]]](assign)
+  }
+
   /** Implementation of += macro for tasks. */
-  def taskAppend1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[Task[T]]] =
-    {
-      val init = taskMacroImpl[U](c)(v)
-      val append = appendMacroImpl(c)(init.tree, a.tree)(Append1InitName)
-      c.Expr[Setting[Task[T]]](append)
-    }
+  def taskAppend1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[Task[T]]] = {
+    val init = taskMacroImpl[U](c)(v)
+    val append = appendMacroImpl(c)(init.tree, a.tree)(Append1InitName)
+    c.Expr[Setting[Task[T]]](append)
+  }
+
   /** Implementation of += macro for settings. */
-  def settingAppend1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[T]] =
-    {
-      val init = SettingMacro.settingMacroImpl[U](c)(v)
-      val append = appendMacroImpl(c)(init.tree, a.tree)(Append1InitName)
-      c.Expr[Setting[T]](append)
+  def settingAppend1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(v: c.Expr[U])(a: c.Expr[Append.Value[T, U]]): c.Expr[Setting[T]] = {
+    import c.universe._
+    val ttpe = c.weakTypeOf[T]
+    val typeArgs = ttpe.typeArgs
+    v.tree.tpe match {
+      // To allow Initialize[Task[A]] in the position of += RHS, we're going to call "taskValue" automatically.
+      case tpe
+          if typeArgs.nonEmpty && (typeArgs.head weak_<:< c.weakTypeOf[Task[_]])
+            && (tpe weak_<:< c.weakTypeOf[Initialize[_]]) =>
+        c.macroApplication match {
+          case Apply(Apply(TypeApply(Select(preT, _), _), _), _) =>
+            val tree = Apply(
+              TypeApply(Select(preT, TermName("+=").encodedName), TypeTree(typeArgs.head) :: Nil),
+              Select(v.tree, TermName("taskValue").encodedName) :: Nil
+            )
+            c.Expr[Setting[T]](tree)
+          case x => ContextUtil.unexpectedTree(x)
+        }
+      case _ =>
+        val init = SettingMacro.settingMacroImpl[U](c)(v)
+        val append = appendMacroImpl(c)(init.tree, a.tree)(Append1InitName)
+        c.Expr[Setting[T]](append)
     }
+  }
+
   /** Implementation of ++= macro for tasks. */
-  def taskAppendNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[Task[T]]] =
-    {
-      val init = taskMacroImpl[U](c)(vs)
-      val append = appendMacroImpl(c)(init.tree, a.tree)(AppendNInitName)
-      c.Expr[Setting[Task[T]]](append)
-    }
+  def taskAppendNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[Task[T]]] = {
+    val init = taskMacroImpl[U](c)(vs)
+    val append = appendMacroImpl(c)(init.tree, a.tree)(AppendNInitName)
+    c.Expr[Setting[Task[T]]](append)
+  }
+
   /** Implementation of ++= macro for settings. */
-  def settingAppendNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[T]] =
-    {
-      val init = SettingMacro.settingMacroImpl[U](c)(vs)
-      val append = appendMacroImpl(c)(init.tree, a.tree)(AppendNInitName)
-      c.Expr[Setting[T]](append)
-    }
+  def settingAppendNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(vs: c.Expr[U])(a: c.Expr[Append.Values[T, U]]): c.Expr[Setting[T]] = {
+    val init = SettingMacro.settingMacroImpl[U](c)(vs)
+    val append = appendMacroImpl(c)(init.tree, a.tree)(AppendNInitName)
+    c.Expr[Setting[T]](append)
+  }
 
   /** Implementation of -= macro for tasks. */
-  def taskRemove1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[U])(r: c.Expr[Remove.Value[T, U]]): c.Expr[Setting[Task[T]]] =
-    {
-      val init = taskMacroImpl[U](c)(v)
-      val remove = removeMacroImpl(c)(init.tree, r.tree)(Remove1InitName)
-      c.Expr[Setting[Task[T]]](remove)
-    }
-  /** Implementation of -= macro for settings. */
-  def settingRemove1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(v: c.Expr[U])(r: c.Expr[Remove.Value[T, U]]): c.Expr[Setting[T]] =
-    {
-      val init = SettingMacro.settingMacroImpl[U](c)(v)
-      val remove = removeMacroImpl(c)(init.tree, r.tree)(Remove1InitName)
-      c.Expr[Setting[T]](remove)
-    }
-  /** Implementation of --= macro for tasks. */
-  def taskRemoveNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(vs: c.Expr[U])(r: c.Expr[Remove.Values[T, U]]): c.Expr[Setting[Task[T]]] =
-    {
-      val init = taskMacroImpl[U](c)(vs)
-      val remove = removeMacroImpl(c)(init.tree, r.tree)(RemoveNInitName)
-      c.Expr[Setting[Task[T]]](remove)
-    }
-  /** Implementation of --= macro for settings. */
-  def settingRemoveNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: blackbox.Context)(vs: c.Expr[U])(r: c.Expr[Remove.Values[T, U]]): c.Expr[Setting[T]] =
-    {
-      val init = SettingMacro.settingMacroImpl[U](c)(vs)
-      val remove = removeMacroImpl(c)(init.tree, r.tree)(RemoveNInitName)
-      c.Expr[Setting[T]](remove)
-    }
+  def taskRemove1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(v: c.Expr[U])(r: c.Expr[Remove.Value[T, U]]): c.Expr[Setting[Task[T]]] = {
+    val init = taskMacroImpl[U](c)(v)
+    val remove = removeMacroImpl(c)(init.tree, r.tree)(Remove1InitName)
+    c.Expr[Setting[Task[T]]](remove)
+  }
 
-  private[this] def appendMacroImpl(c: blackbox.Context)(init: c.Tree, append: c.Tree)(newName: String): c.Tree =
-    {
-      import c.universe._
+  /** Implementation of -= macro for settings. */
+  def settingRemove1Impl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(v: c.Expr[U])(r: c.Expr[Remove.Value[T, U]]): c.Expr[Setting[T]] = {
+    val init = SettingMacro.settingMacroImpl[U](c)(v)
+    val remove = removeMacroImpl(c)(init.tree, r.tree)(Remove1InitName)
+    c.Expr[Setting[T]](remove)
+  }
+
+  /** Implementation of --= macro for tasks. */
+  def taskRemoveNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(vs: c.Expr[U])(r: c.Expr[Remove.Values[T, U]]): c.Expr[Setting[Task[T]]] = {
+    val init = taskMacroImpl[U](c)(vs)
+    val remove = removeMacroImpl(c)(init.tree, r.tree)(RemoveNInitName)
+    c.Expr[Setting[Task[T]]](remove)
+  }
+
+  /** Implementation of --= macro for settings. */
+  def settingRemoveNImpl[T: c.WeakTypeTag, U: c.WeakTypeTag](
+      c: blackbox.Context
+  )(vs: c.Expr[U])(r: c.Expr[Remove.Values[T, U]]): c.Expr[Setting[T]] = {
+    val init = SettingMacro.settingMacroImpl[U](c)(vs)
+    val remove = removeMacroImpl(c)(init.tree, r.tree)(RemoveNInitName)
+    c.Expr[Setting[T]](remove)
+  }
+
+  private[this] def appendMacroImpl(
+      c: blackbox.Context
+  )(init: c.Tree, append: c.Tree)(newName: String): c.Tree = {
+    import c.universe._
+    c.macroApplication match {
+      case Apply(Apply(TypeApply(Select(preT, _), targs), _), _) =>
+        Apply(
+          Apply(
+            TypeApply(Select(preT, TermName(newName).encodedName), targs),
+            init :: sourcePosition(c).tree :: Nil
+          ),
+          append :: Nil
+        )
+      case x => ContextUtil.unexpectedTree(x)
+    }
+  }
+
+  private[this] def removeMacroImpl(
+      c: blackbox.Context
+  )(init: c.Tree, remove: c.Tree)(newName: String): c.Tree = {
+    import c.universe._
+    c.macroApplication match {
+      case Apply(Apply(TypeApply(Select(preT, _), targs), _), _) =>
+        Apply(
+          Apply(
+            TypeApply(Select(preT, TermName(newName).encodedName), targs),
+            init :: sourcePosition(c).tree :: Nil
+          ),
+          remove :: Nil
+        )
+      case x => ContextUtil.unexpectedTree(x)
+    }
+  }
+
+  private[this] def transformMacroImpl(c: blackbox.Context)(init: c.Tree)(
+      newName: String
+  ): c.Tree = {
+    import c.universe._
+    val target =
       c.macroApplication match {
-        case Apply(Apply(TypeApply(Select(preT, nmeT), targs), _), a) =>
-          Apply(Apply(TypeApply(Select(preT, TermName(newName).encodedName), targs), init :: sourcePosition(c).tree :: Nil), a)
-        case x => ContextUtil.unexpectedTree(x)
+        case Apply(Select(prefix, _), _) => prefix
+        case x                           => ContextUtil.unexpectedTree(x)
       }
-    }
-  private[this] def removeMacroImpl(c: blackbox.Context)(init: c.Tree, remove: c.Tree)(newName: String): c.Tree =
-    {
-      import c.universe._
-      c.macroApplication match {
-        case Apply(Apply(TypeApply(Select(preT, nmeT), targs), _), r) =>
-          Apply(Apply(TypeApply(Select(preT, TermName(newName).encodedName), targs), init :: sourcePosition(c).tree :: Nil), r)
-        case x => ContextUtil.unexpectedTree(x)
-      }
-    }
-  private[this] def transformMacroImpl(c: blackbox.Context)(init: c.Tree)(newName: String): c.Tree =
-    {
-      import c.universe._
-      val target =
-        c.macroApplication match {
-          case Apply(Select(prefix, _), _) => prefix
-          case x                           => ContextUtil.unexpectedTree(x)
-        }
-      Apply.apply(Select(target, TermName(newName).encodedName), init :: sourcePosition(c).tree :: Nil)
-    }
-  private[this] def sourcePosition(c: blackbox.Context): c.Expr[SourcePosition] =
-    {
-      import c.universe.reify
-      val pos = c.enclosingPosition
-      if (!pos.isInstanceOf[UndefinedPosition] && pos.line >= 0 && pos.source != null) {
-        val f = pos.source.file
-        val name = constant[String](c, settingSource(c, f.path, f.name))
-        val line = constant[Int](c, pos.line)
-        reify { LinePosition(name.splice, line.splice) }
-      } else
-        reify { NoPosition }
-    }
-  private[this] def settingSource(c: blackbox.Context, path: String, name: String): String =
-    {
-      @tailrec def inEmptyPackage(s: c.Symbol): Boolean = s != c.universe.NoSymbol && (
-        s.owner == c.mirror.EmptyPackage || s.owner == c.mirror.EmptyPackageClass || inEmptyPackage(s.owner)
+    Apply.apply(
+      Select(target, TermName(newName).encodedName),
+      init :: sourcePosition(c).tree :: Nil
+    )
+  }
+
+  private[this] def sourcePosition(c: blackbox.Context): c.Expr[SourcePosition] = {
+    import c.universe.reify
+    val pos = c.enclosingPosition
+    if (!pos.isInstanceOf[UndefinedPosition] && pos.line >= 0 && pos.source != null) {
+      val f = pos.source.file
+      val name = constant[String](c, settingSource(c, f.path, f.name))
+      val line = constant[Int](c, pos.line)
+      reify { LinePosition(name.splice, line.splice) }
+    } else
+      reify { NoPosition }
+  }
+
+  private[this] def settingSource(c: blackbox.Context, path: String, name: String): String = {
+    @tailrec def inEmptyPackage(s: c.Symbol): Boolean = s != c.universe.NoSymbol && (
+      s.owner == c.mirror.EmptyPackage || s.owner == c.mirror.EmptyPackageClass || inEmptyPackage(
+        s.owner
       )
-      c.enclosingClass.symbol match {
-        case ec if !ec.isStatic       => name
-        case ec if inEmptyPackage(ec) => path
-        case ec                       => s"(${ec.fullName}) $name"
-      }
+    )
+    c.internal.enclosingOwner match {
+      case ec if !ec.isStatic       => name
+      case ec if inEmptyPackage(ec) => path
+      case ec                       => s"(${ec.fullName}) $name"
     }
+  }
 
   private[this] def constant[T: c.TypeTag](c: blackbox.Context, t: T): c.Expr[T] = {
     import c.universe._
     c.Expr[T](Literal(Constant(t)))
   }
 
-  def inputTaskMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[T]): c.Expr[Initialize[InputTask[T]]] =
+  def inputTaskMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[T]): c.Expr[Initialize[InputTask[T]]] =
     inputTaskMacro0[T](c)(t)
-  def inputTaskDynMacroImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[InputTask[T]]] =
+
+  def inputTaskDynMacroImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[InputTask[T]]] =
     inputTaskDynMacro0[T](c)(t)
 
-  private[this] def inputTaskMacro0[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[T]): c.Expr[Initialize[InputTask[T]]] =
+  private[this] def inputTaskMacro0[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[T]): c.Expr[Initialize[InputTask[T]]] =
     iInitializeMacro(c)(t) { et =>
       val pt = iParserMacro(c)(et) { pt =>
         iTaskMacro(c)(pt)
@@ -283,144 +446,164 @@ object TaskMacro {
       c.universe.reify { InputTask.make(pt.splice) }
     }
 
-  private[this] def iInitializeMacro[M[_], T](c: blackbox.Context)(t: c.Expr[T])(f: c.Expr[T] => c.Expr[M[T]])(implicit tt: c.WeakTypeTag[T], mt: c.WeakTypeTag[M[T]]): c.Expr[Initialize[M[T]]] =
-    {
-      val inner: Transform[c.type, M] = new Transform[c.type, M] { def apply(in: c.Tree): c.Tree = f(c.Expr[T](in)).tree }
-      val cond = c.Expr[T](conditionInputTaskTree(c)(t.tree))
-      Instance.contImpl[T, M](c, InitializeInstance, InputInitConvert, MixedBuilder)(Left(cond), inner)
-    }
-  private[this] def conditionInputTaskTree(c: blackbox.Context)(t: c.Tree): c.Tree =
-    {
-      import c.universe._
-      import InputWrapper._
-      def wrapInitTask[T: c.WeakTypeTag](tree: Tree) =
-        {
-          val e = c.Expr[Initialize[Task[T]]](tree)
-          wrapTask[T](c)(wrapInit[Task[T]](c)(e, tree.pos), tree.pos).tree
-        }
-      def wrapInitParser[T: c.WeakTypeTag](tree: Tree) =
-        {
-          val e = c.Expr[Initialize[State => Parser[T]]](tree)
-          ParserInput.wrap[T](c)(wrapInit[State => Parser[T]](c)(e, tree.pos), tree.pos).tree
-        }
-      def wrapInitInput[T: c.WeakTypeTag](tree: Tree) =
-        {
-          val e = c.Expr[Initialize[InputTask[T]]](tree)
-          wrapInput[T](wrapInit[InputTask[T]](c)(e, tree.pos).tree)
-        }
-      def wrapInput[T: c.WeakTypeTag](tree: Tree) =
-        {
-          val e = c.Expr[InputTask[T]](tree)
-          val p = ParserInput.wrap[Task[T]](c)(ParserInput.inputParser(c)(e), tree.pos)
-          wrapTask[T](c)(p, tree.pos).tree
-        }
+  private[this] def iInitializeMacro[M[_], T](c: blackbox.Context)(t: c.Expr[T])(
+      f: c.Expr[T] => c.Expr[M[T]]
+  )(implicit tt: c.WeakTypeTag[T], mt: c.WeakTypeTag[M[T]]): c.Expr[Initialize[M[T]]] = {
+    val inner: Transform[c.type, M] = (in: c.Tree) => f(c.Expr[T](in)).tree
+    val cond = c.Expr[T](conditionInputTaskTree(c)(t.tree))
+    Instance
+      .contImpl[T, M](c, InitializeInstance, InputInitConvert, MixedBuilder, EmptyLinter)(
+        Left(cond),
+        inner
+      )
+  }
 
-      def expand(nme: String, tpe: Type, tree: Tree): Converted[c.type] = nme match {
-        case WrapInitTaskName         => Converted.Success(wrapInitTask(tree)(c.WeakTypeTag(tpe)))
-        case ParserInput.WrapInitName => Converted.Success(wrapInitParser(tree)(c.WeakTypeTag(tpe)))
-        case WrapInitInputName        => Converted.Success(wrapInitInput(tree)(c.WeakTypeTag(tpe)))
-        case WrapInputName            => Converted.Success(wrapInput(tree)(c.WeakTypeTag(tpe)))
-        case _                        => Converted.NotApplicable
+  private[this] def conditionInputTaskTree(c: blackbox.Context)(t: c.Tree): c.Tree = {
+    import c.universe._
+    import InputWrapper._
+    def wrapInitTask[T: c.WeakTypeTag](tree: Tree) = {
+      val e = c.Expr[Initialize[Task[T]]](tree)
+      wrapTask[T](c)(wrapInit[Task[T]](c)(e, tree.pos), tree.pos).tree
+    }
+    def wrapInitParser[T: c.WeakTypeTag](tree: Tree) = {
+      val e = c.Expr[Initialize[State => Parser[T]]](tree)
+      ParserInput.wrap[T](c)(wrapInit[State => Parser[T]](c)(e, tree.pos), tree.pos).tree
+    }
+    def wrapInitInput[T: c.WeakTypeTag](tree: Tree) = {
+      val e = c.Expr[Initialize[InputTask[T]]](tree)
+      wrapInput[T](wrapInit[InputTask[T]](c)(e, tree.pos).tree)
+    }
+    def wrapInput[T: c.WeakTypeTag](tree: Tree) = {
+      val e = c.Expr[InputTask[T]](tree)
+      val p = ParserInput.wrap[Task[T]](c)(ParserInput.inputParser(c)(e), tree.pos)
+      wrapTask[T](c)(p, tree.pos).tree
+    }
+
+    def expand(nme: String, tpe: Type, tree: Tree): Converted[c.type] = nme match {
+      case WrapInitTaskName         => Converted.Success(wrapInitTask(tree)(c.WeakTypeTag(tpe)))
+      case WrapPreviousName         => Converted.Success(wrapInitTask(tree)(c.WeakTypeTag(tpe)))
+      case ParserInput.WrapInitName => Converted.Success(wrapInitParser(tree)(c.WeakTypeTag(tpe)))
+      case WrapInitInputName        => Converted.Success(wrapInitInput(tree)(c.WeakTypeTag(tpe)))
+      case WrapInputName            => Converted.Success(wrapInput(tree)(c.WeakTypeTag(tpe)))
+      case _                        => Converted.NotApplicable
+    }
+    val util = ContextUtil[c.type](c)
+    util.transformWrappers(t, (nme, tpe, tree, original) => expand(nme, tpe, tree))
+  }
+
+  private[this] def iParserMacro[M[_], T](c: blackbox.Context)(t: c.Expr[T])(
+      f: c.Expr[T] => c.Expr[M[T]]
+  )(implicit tt: c.WeakTypeTag[T], mt: c.WeakTypeTag[M[T]]): c.Expr[State => Parser[M[T]]] = {
+    val inner: Transform[c.type, M] = (in: c.Tree) => f(c.Expr[T](in)).tree
+    Instance.contImpl[T, M](c, ParserInstance, ParserConvert, MixedBuilder, LinterDSL.Empty)(
+      Left(t),
+      inner
+    )
+  }
+
+  private[this] def iTaskMacro[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[T]): c.Expr[Task[T]] =
+    Instance
+      .contImpl[T, Id](c, TaskInstance, TaskConvert, MixedBuilder, EmptyLinter)(
+        Left(t),
+        Instance.idTransform
+      )
+
+  private[this] def inputTaskDynMacro0[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[InputTask[T]]] = {
+    import c.universe.{ Apply => ApplyTree, _ }
+    import internal.decorators._
+
+    val tag = implicitly[c.WeakTypeTag[T]]
+    val util = ContextUtil[c.type](c)
+    val it = Ident(util.singleton(InputTask))
+    val isParserWrapper = InitParserConvert.asPredicate(c)
+    val isTaskWrapper = FullConvert.asPredicate(c)
+    val isAnyWrapper = (n: String, tpe: Type, tr: Tree) =>
+      isParserWrapper(n, tpe, tr) || isTaskWrapper(n, tpe, tr)
+    val ttree = t.tree
+    val defs = util.collectDefs(ttree, isAnyWrapper)
+    val checkQual = util.checkReferences(defs, isAnyWrapper, weakTypeOf[Initialize[InputTask[Any]]])
+
+    // the Symbol for the anonymous function passed to the appropriate Instance.map/flatMap/pure method
+    // this Symbol needs to be known up front so that it can be used as the owner of synthetic vals
+    val functionSym = util.functionSymbol(ttree.pos)
+    var result: Option[(Tree, Type, ValDef)] = None
+
+    // original is the Tree being replaced.  It is needed for preserving attributes.
+    def subWrapper(tpe: Type, qual: Tree, original: Tree): Tree =
+      if (result.isDefined) {
+        c.error(
+          qual.pos,
+          "Implementation restriction: a dynamic InputTask can only have a single input parser."
+        )
+        EmptyTree
+      } else {
+        qual.foreach(checkQual)
+        val vd = util.freshValDef(tpe, qual.symbol.pos, functionSym) // val $x: <tpe>
+        result = Some((qual, tpe, vd))
+        val tree = util.refVal(original, vd) // $x
+        tree.setPos(qual.pos) // position needs to be set so that wrapKey passes the position onto the wrapper
+        assert(tree.tpe != null, "Null type: " + tree)
+        tree.setType(tpe)
+        tree
       }
-      val util = ContextUtil[c.type](c)
-      util.transformWrappers(t, (nme, tpe, tree, original) => expand(nme, tpe, tree))
+    // Tree for InputTask.<name>[<tpeA>, <tpeB>](arg1)(arg2)
+    def inputTaskCreate(name: String, tpeA: Type, tpeB: Type, arg1: Tree, arg2: Tree) = {
+      val typedApp = TypeApply(util.select(it, name), TypeTree(tpeA) :: TypeTree(tpeB) :: Nil)
+      val app = ApplyTree(ApplyTree(typedApp, arg1 :: Nil), arg2 :: Nil)
+      c.Expr[Initialize[InputTask[T]]](app)
     }
-
-  private[this] def iParserMacro[M[_], T](c: blackbox.Context)(t: c.Expr[T])(f: c.Expr[T] => c.Expr[M[T]])(implicit tt: c.WeakTypeTag[T], mt: c.WeakTypeTag[M[T]]): c.Expr[State => Parser[M[T]]] =
-    {
-      val inner: Transform[c.type, M] = new Transform[c.type, M] { def apply(in: c.Tree): c.Tree = f(c.Expr[T](in)).tree }
-      Instance.contImpl[T, M](c, ParserInstance, ParserConvert, MixedBuilder)(Left(t), inner)
+    // Tree for InputTask.createFree[<tpe>](arg1)
+    def inputTaskCreateFree(tpe: Type, arg: Tree) = {
+      val typedApp = TypeApply(util.select(it, InputTaskCreateFreeName), TypeTree(tpe) :: Nil)
+      val app = ApplyTree(typedApp, arg :: Nil)
+      c.Expr[Initialize[InputTask[T]]](app)
     }
+    def expandTask[I: WeakTypeTag](dyn: Boolean, tx: Tree): c.Expr[Initialize[Task[I]]] =
+      if (dyn)
+        taskDynMacroImpl[I](c)(c.Expr[Initialize[Task[I]]](tx))
+      else
+        taskMacroImpl[I](c)(c.Expr[I](tx))
+    def wrapTag[I: WeakTypeTag]: WeakTypeTag[Initialize[Task[I]]] = weakTypeTag
 
-  private[this] def iTaskMacro[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[T]): c.Expr[Task[T]] =
-    Instance.contImpl[T, Id](c, TaskInstance, TaskConvert, MixedBuilder)(Left(t), Instance.idTransform)
-
-  private[this] def inputTaskDynMacro0[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[Initialize[Task[T]]]): c.Expr[Initialize[InputTask[T]]] =
-    {
-      import c.universe.{ Apply => ApplyTree, _ }
-      import internal.decorators._
-
-      val tag = implicitly[c.WeakTypeTag[T]]
-      val util = ContextUtil[c.type](c)
-      val it = Ident(util.singleton(InputTask))
-      val isParserWrapper = InitParserConvert.asPredicate(c)
-      val isTaskWrapper = FullConvert.asPredicate(c)
-      val isAnyWrapper = (n: String, tpe: Type, tr: Tree) => isParserWrapper(n, tpe, tr) || isTaskWrapper(n, tpe, tr)
-      val ttree = t.tree
-      val defs = util.collectDefs(ttree, isAnyWrapper)
-      val checkQual = util.checkReferences(defs, isAnyWrapper)
-
-      // the Symbol for the anonymous function passed to the appropriate Instance.map/flatMap/pure method
-      // this Symbol needs to be known up front so that it can be used as the owner of synthetic vals
-      val functionSym = util.functionSymbol(ttree.pos)
-      var result: Option[(Tree, Type, ValDef)] = None
-
-      // original is the Tree being replaced.  It is needed for preserving attributes.
-      def subWrapper(tpe: Type, qual: Tree, original: Tree): Tree =
-        if (result.isDefined) {
-          c.error(qual.pos, "Implementation restriction: a dynamic InputTask can only have a single input parser.")
-          EmptyTree
-        } else {
-          qual.foreach(checkQual)
-          val vd = util.freshValDef(tpe, qual.symbol.pos, functionSym) // val $x: <tpe>
-          result = Some((qual, tpe, vd))
-          val tree = util.refVal(original, vd) // $x
-          tree.setPos(qual.pos) // position needs to be set so that wrapKey passes the position onto the wrapper
-          assert(tree.tpe != null, "Null type: " + tree)
-          tree.setType(tpe)
-          tree
-        }
-      // Tree for InputTask.<name>[<tpeA>, <tpeB>](arg1)(arg2)
-      def inputTaskCreate(name: String, tpeA: Type, tpeB: Type, arg1: Tree, arg2: Tree) =
-        {
-          val typedApp = TypeApply(util.select(it, name), TypeTree(tpeA) :: TypeTree(tpeB) :: Nil)
-          val app = ApplyTree(ApplyTree(typedApp, arg1 :: Nil), arg2 :: Nil)
-          c.Expr[Initialize[InputTask[T]]](app)
-        }
-      // Tree for InputTask.createFree[<tpe>](arg1)
-      def inputTaskCreateFree(tpe: Type, arg: Tree) =
-        {
-          val typedApp = TypeApply(util.select(it, InputTaskCreateFreeName), TypeTree(tpe) :: Nil)
-          val app = ApplyTree(typedApp, arg :: Nil)
-          c.Expr[Initialize[InputTask[T]]](app)
-        }
-      def expandTask[I: WeakTypeTag](dyn: Boolean, tx: Tree): c.Expr[Initialize[Task[I]]] =
-        if (dyn)
-          taskDynMacroImpl[I](c)(c.Expr[Initialize[Task[I]]](tx))
-        else
-          taskMacroImpl[I](c)(c.Expr[I](tx))
-      def wrapTag[I: WeakTypeTag]: WeakTypeTag[Initialize[Task[I]]] = weakTypeTag
-
-      def sub(name: String, tpe: Type, qual: Tree, selection: Tree): Converted[c.type] =
-        {
-          val tag = c.WeakTypeTag[T](tpe)
-          InitParserConvert(c)(name, qual)(tag) transform { tree =>
-            subWrapper(tpe, tree, selection)
-          }
-        }
-
-      val tx = util.transformWrappers(ttree, (n, tpe, tree, replace) => sub(n, tpe, tree, replace))
-      result match {
-        case Some((p, tpe, param)) =>
-          val fCore = util.createFunction(param :: Nil, tx, functionSym)
-          val bodyTpe = wrapTag(tag).tpe
-          val fTpe = util.functionType(tpe :: Nil, bodyTpe)
-          val fTag = c.WeakTypeTag[Any](fTpe) // don't know the actual type yet, so use Any
-          val fInit = expandTask(false, fCore)(fTag).tree
-          inputTaskCreate(InputTaskCreateDynName, tpe, tag.tpe, p, fInit)
-        case None =>
-          val init = expandTask[T](true, tx).tree
-          inputTaskCreateFree(tag.tpe, init)
+    def sub(name: String, tpe: Type, qual: Tree, selection: Tree): Converted[c.type] = {
+      val tag = c.WeakTypeTag[T](tpe)
+      InitParserConvert(c)(name, qual)(tag) transform { tree =>
+        subWrapper(tpe, tree, selection)
       }
     }
+
+    val tx = util.transformWrappers(ttree, (n, tpe, tree, replace) => sub(n, tpe, tree, replace))
+    result match {
+      case Some((p, tpe, param)) =>
+        val fCore = util.createFunction(param :: Nil, tx, functionSym)
+        val bodyTpe = wrapTag(tag).tpe
+        val fTpe = util.functionType(tpe :: Nil, bodyTpe)
+        val fTag = c.WeakTypeTag[Any](fTpe) // don't know the actual type yet, so use Any
+        val fInit = expandTask(false, fCore)(fTag).tree
+        inputTaskCreate(InputTaskCreateDynName, tpe, tag.tpe, p, fInit)
+      case None =>
+        val init = expandTask[T](true, tx).tree
+        inputTaskCreateFree(tag.tpe, init)
+    }
+  }
 }
 
 object PlainTaskMacro {
   def task[T](t: T): Task[T] = macro taskImpl[T]
   def taskImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[T]): c.Expr[Task[T]] =
-    Instance.contImpl[T, Id](c, TaskInstance, TaskConvert, MixedBuilder)(Left(t), Instance.idTransform[c.type])
+    Instance.contImpl[T, Id](c, TaskInstance, TaskConvert, MixedBuilder, OnlyTaskLinterDSL)(
+      Left(t),
+      Instance.idTransform[c.type]
+    )
 
   def taskDyn[T](t: Task[T]): Task[T] = macro taskDynImpl[T]
   def taskDynImpl[T: c.WeakTypeTag](c: blackbox.Context)(t: c.Expr[Task[T]]): c.Expr[Task[T]] =
-    Instance.contImpl[T, Id](c, TaskInstance, TaskConvert, MixedBuilder)(Right(t), Instance.idTransform[c.type])
+    Instance.contImpl[T, Id](c, TaskInstance, TaskConvert, MixedBuilder, OnlyTaskDynLinterDSL)(
+      Right(t),
+      Instance.idTransform[c.type]
+    )
 }
diff --git a/main-settings/src/main/scala/sbt/unchecked.scala b/main-settings/src/main/scala/sbt/unchecked.scala
new file mode 100644
index 000000000..55261fa97
--- /dev/null
+++ b/main-settings/src/main/scala/sbt/unchecked.scala
@@ -0,0 +1,20 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import scala.annotation.Annotation
+
+/** An annotation to designate that the annotated entity
+ *  should not be considered for additional sbt compiler checks.
+ *  These checks ensure that the DSL is predictable and prevents
+ *  users from doing dangerous things at the cost of a stricter
+ *  code structure.
+ *
+ *  @since 1.0.0
+ */
+class sbtUnchecked extends Annotation
diff --git a/main-settings/src/test/scala/sbt/AppendSpec.scala b/main-settings/src/test/scala/sbt/AppendSpec.scala
new file mode 100644
index 000000000..a9c0e035e
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/AppendSpec.scala
@@ -0,0 +1,31 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+object AppendSpec {
+  val onLoad = SettingKey[State => State]("onLoad")
+
+  import Scope.Global
+  import SlashSyntax0._
+
+  def doSideEffect(): Unit = ()
+
+  Global / onLoad := (Global / onLoad).value.andThen { s =>
+    doSideEffect()
+    s
+  }
+
+  Global / onLoad += { (s: State) =>
+    doSideEffect()
+    s
+  }
+
+  Global / onLoad += doSideEffect _
+  Global / onLoad += (() => doSideEffect())
+  Global / onLoad += (() => println("foo"))
+}
diff --git a/main-settings/src/test/scala/sbt/BuildSettingsInstances.scala b/main-settings/src/test/scala/sbt/BuildSettingsInstances.scala
new file mode 100644
index 000000000..313459dbb
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/BuildSettingsInstances.scala
@@ -0,0 +1,136 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.test
+
+import org.scalacheck.{ Test => _, _ }, Arbitrary.arbitrary, Gen._
+
+import java.io.File
+import sbt.io.IO
+import sbt.{ Scope, ScopeAxis, Scoped, Select, This, Zero }
+import sbt.{
+  BuildRef,
+  LocalProject,
+  LocalRootProject,
+  ProjectRef,
+  Reference,
+  RootProject,
+  ThisBuild,
+  ThisProject
+}
+import sbt.ConfigKey
+import sbt.librarymanagement.syntax._
+import sbt.{ InputKey, SettingKey, TaskKey }
+import sbt.internal.util.{ AttributeKey, AttributeMap }
+import scala.annotation.nowarn
+
+object BuildSettingsInstances {
+  val genFile: Gen[File] = Gen.oneOf(new File("."), new File("/tmp")) // for now..
+
+  implicit val arbBuildRef: Arbitrary[BuildRef] = Arbitrary(genFile map (f => BuildRef(IO toURI f)))
+
+  implicit val arbProjectRef: Arbitrary[ProjectRef] =
+    Arbitrary(for (f <- genFile; id <- Gen.identifier) yield ProjectRef(f, id))
+
+  implicit val arbLocalProject: Arbitrary[LocalProject] =
+    Arbitrary(arbitrary[String] map LocalProject)
+
+  implicit val arbRootProject: Arbitrary[RootProject] = Arbitrary(genFile map (RootProject(_)))
+
+  implicit val arbReference: Arbitrary[Reference] = Arbitrary {
+    Gen.frequency(
+      96 -> arbitrary[BuildRef],
+      10271 -> ThisBuild,
+      325 -> LocalRootProject,
+      2283 -> arbitrary[ProjectRef],
+      299 -> ThisProject,
+      436 -> arbitrary[LocalProject],
+      1133 -> arbitrary[RootProject],
+    )
+  }
+
+  implicit def arbConfigKey: Arbitrary[ConfigKey] = Arbitrary {
+    Gen.frequency(
+      2 -> const[ConfigKey](Compile),
+      2 -> const[ConfigKey](Test),
+      1 -> const[ConfigKey](Runtime),
+      1 -> const[ConfigKey](IntegrationTest),
+      1 -> const[ConfigKey](Provided),
+    )
+  }
+
+  implicit def arbAttrKey[A: Manifest]: Arbitrary[AttributeKey[_]] =
+    Arbitrary(Gen.identifier map (AttributeKey[A](_)))
+
+  implicit val arbAttributeMap: Arbitrary[AttributeMap] = Arbitrary {
+    Gen.frequency(
+      20 -> AttributeMap.empty,
+      1 -> {
+        for (name <- Gen.identifier; isModule <- arbitrary[Boolean])
+          yield AttributeMap.empty
+            .put(AttributeKey[String]("name"), name)
+            .put(AttributeKey[Boolean]("isModule"), isModule)
+      }
+    )
+  }
+
+  implicit def arbScopeAxis[A: Arbitrary]: Arbitrary[ScopeAxis[A]] =
+    Arbitrary(Gen.oneOf[ScopeAxis[A]](This, Zero, arbitrary[A] map (Select(_))))
+
+  implicit def arbScope: Arbitrary[Scope] = Arbitrary(
+    for {
+      r <- arbitrary[ScopeAxis[Reference]]
+      c <- arbitrary[ScopeAxis[ConfigKey]]
+      t <- arbitrary[ScopeAxis[AttributeKey[_]]]
+      e <- arbitrary[ScopeAxis[AttributeMap]]
+    } yield Scope(r, c, t, e)
+  )
+
+  type Key = K forSome { type K <: Scoped.ScopingSetting[K] with Scoped }
+
+  final case class Label(value: String)
+  val genLabel: Gen[Label] = Gen.identifier map Label
+  implicit def arbLabel: Arbitrary[Label] = Arbitrary(genLabel)
+
+  def genInputKey[A: Manifest]: Gen[InputKey[A]] = genLabel map (x => InputKey[A](x.value))
+  def genSettingKey[A: Manifest]: Gen[SettingKey[A]] = genLabel map (x => SettingKey[A](x.value))
+  def genTaskKey[A: Manifest]: Gen[TaskKey[A]] = genLabel map (x => TaskKey[A](x.value))
+
+  @nowarn
+  def withScope[K <: Scoped.ScopingSetting[K]](keyGen: Gen[K]): Arbitrary[K] = Arbitrary {
+    Gen.frequency(
+      5 -> keyGen,
+      1 -> (for (key <- keyGen; scope <- arbitrary[Scope]) yield key in scope)
+    )
+  }
+
+  implicit def arbInputKey[A: Manifest]: Arbitrary[InputKey[A]] = withScope(genInputKey[A])
+  implicit def arbSettingKey[A: Manifest]: Arbitrary[SettingKey[A]] = withScope(genSettingKey[A])
+  implicit def arbTaskKey[A: Manifest]: Arbitrary[TaskKey[A]] = withScope(genTaskKey[A])
+
+  implicit def arbKey[A: Manifest](
+      implicit
+      arbInputKey: Arbitrary[InputKey[A]],
+      arbSettingKey: Arbitrary[SettingKey[A]],
+      arbTaskKey: Arbitrary[TaskKey[A]],
+  ): Arbitrary[Key] = Arbitrary {
+    def convert[T](g: Gen[T]) = g.asInstanceOf[Gen[Key]]
+    Gen.frequency(
+      15431 -> convert(arbitrary[InputKey[A]]),
+      19645 -> convert(arbitrary[SettingKey[A]]),
+      22867 -> convert(arbitrary[TaskKey[A]]),
+    )
+  }
+
+  object WithoutScope {
+    implicit def arbInputKey[A: Manifest]: Arbitrary[InputKey[A]] = Arbitrary(genInputKey[A])
+    implicit def arbSettingKey[A: Manifest]: Arbitrary[SettingKey[A]] = Arbitrary(genSettingKey[A])
+    implicit def arbTaskKey[A: Manifest]: Arbitrary[TaskKey[A]] = Arbitrary(genTaskKey[A])
+  }
+
+  implicit def arbScoped[A: Manifest]: Arbitrary[Scoped] = Arbitrary(arbitrary[Key])
+}
diff --git a/main-settings/src/test/scala/sbt/ScopeDisplaySpec.scala b/main-settings/src/test/scala/sbt/ScopeDisplaySpec.scala
new file mode 100644
index 000000000..c1af590b4
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/ScopeDisplaySpec.scala
@@ -0,0 +1,77 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import org.scalatest.FlatSpec
+import sbt.internal.util.{ AttributeKey, AttributeMap }
+import sbt.io.syntax.file
+import scala.annotation.nowarn
+
+class ScopeDisplaySpec extends FlatSpec {
+  val project = ProjectRef(file("foo/bar"), "bar")
+  val mangledName = "bar_slash_blah_blah_blah"
+
+  @nowarn
+  val scopedKey = Def.ScopedKey(Scope.Global in project, AttributeKey[Task[String]](mangledName))
+  val am = AttributeMap.empty.put(Scope.customShowString, "blah")
+  val sanitizedKey = scopedKey.copy(scope = scopedKey.scope.copy(extra = Select(am)))
+  "Def.displayRelative2" should "display mangled name" in {
+    assert(Def.showRelativeKey2(project, None).show(scopedKey) == mangledName)
+  }
+  it should "display sanitized name with extra setting" in {
+    assert(Def.showRelativeKey2(project, None).show(sanitizedKey) == "blah")
+  }
+  "Scope.display" should "display the full scope" in {
+    val full = Scope.display(
+      scopedKey.scope,
+      "/",
+      (ref: Reference) =>
+        ref match {
+          case ProjectRef(_, n) => n
+          case _                => ???
+        }
+    )
+    assert(full == "bar /")
+  }
+  it should "display the sanitized scope" in {
+    val string = Scope.display(
+      sanitizedKey.scope,
+      "/",
+      (ref: Reference) =>
+        ref match {
+          case ProjectRef(_, n) => n
+          case _                => ???
+        }
+    )
+    assert(string == "blah")
+  }
+
+  behavior of "Def.displayRelative2"
+
+  val b1 = project.build
+  val b2 = sbt.io.IO.toURI(file("other"))
+
+  val p1 = project
+  val p2 = ProjectRef(b1, "baz")
+  val p3 = ProjectRef(b2, "qux")
+
+  private def disp(r: Reference) = Def.displayRelative2(current = p1, r)
+
+  it should "ProjectRef curr proj" in assert(disp(p1) == "")
+  it should "ProjectRef same build" in assert(disp(p2) == "baz /")
+  it should "ProjectRef diff build" in assert(disp(p3) == """ProjectRef(uri("other"), "qux") /""")
+  it should "BuildRef same build" in assert(disp(BuildRef(b1)) == "ThisBuild /")
+  it should "BuildRef diff build" in assert(disp(BuildRef(b2)) == "{other} /")
+  it should "RootProject same build" in assert(disp(RootProject(b1)) == "<root> /")
+  it should "RootProject diff build" in assert(disp(RootProject(b2)) == "{other }<root> /")
+  it should "LocalProject curr proj" in assert(disp(LocalProject(p1.project)) == "")
+  it should "LocalProject diff proj" in assert(disp(LocalProject(p2.project)) == "baz /")
+  it should "ThisBuild" in assert(disp(ThisBuild) == "ThisBuild /")
+  it should "LocalRootProject" in assert(disp(LocalRootProject) == "<root> /")
+  it should "ThisProject" in assert(disp(ThisProject) == "<this> /")
+}
diff --git a/main-settings/src/test/scala/sbt/ScopedSpec.scala b/main-settings/src/test/scala/sbt/ScopedSpec.scala
new file mode 100644
index 000000000..8e5702188
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/ScopedSpec.scala
@@ -0,0 +1,145 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.test
+
+import org.scalacheck._, Prop._, util.Pretty
+
+import sbt.internal.util.AttributeKey
+import sbt.util.NoJsonWriter
+import sbt.{ InputTask, Scope, Task }
+import sbt.{ InputKey, Scoped, SettingKey, TaskKey }
+
+import BuildSettingsInstances._
+
+object ScopedSpec extends Properties("Scoped") {
+  val intManifest = manifest[Int]
+  val stringManifest = manifest[String]
+
+  implicit val arbManifest: Arbitrary[Manifest[_]] =
+    Arbitrary(Gen.oneOf(intManifest, stringManifest))
+
+  property("setting keys are structurally equal") = {
+    forAll { (label: Label, manifest: Manifest[_], scope: Scope) =>
+      val k1 = settingKey(label, manifest, scope)
+      val k2 = settingKey(label, manifest, scope)
+      expectEq(k1, k2)
+    }
+  }
+
+  property("task keys are structurally equal") = {
+    forAll { (label: Label, manifest: Manifest[_], scope: Scope) =>
+      val k1 = taskKey(label, manifest, scope)
+      val k2 = taskKey(label, manifest, scope)
+      expectEq(k1, k2)
+    }
+  }
+
+  property("input keys are structurally equal") = {
+    forAll { (label: Label, manifest: Manifest[_], scope: Scope) =>
+      val k1 = inputKey(label, manifest, scope)
+      val k2 = inputKey(label, manifest, scope)
+      expectEq(k1, k2)
+    }
+  }
+
+  property("different key types are not equal") = {
+    forAll { (label: Label, manifest: Manifest[_], scope: Scope) =>
+      val settingKey1 = settingKey(label, manifest, scope)
+      val taskKey1 = taskKey(label, manifest, scope)
+      val inputKey1 = inputKey(label, manifest, scope)
+
+      all(
+        expectNe(settingKey1, taskKey1),
+        expectNe(settingKey1, inputKey1),
+        expectNe(taskKey1, inputKey1),
+      )
+    }
+  }
+
+  property("different key types, with the same manifest, are not equal") = {
+    forAll { (label: Label, scope: Scope) =>
+      val prop1 = {
+        val manifest1 = manifest[Task[String]]
+        val attrKey = attributeKey(label, manifest1)
+        val k1 = SettingKey(attrKey) in scope
+        val k2 = TaskKey(attrKey) in scope
+        expectNeSameManifest(k1, k2)
+      }
+
+      val prop2 = {
+        val manifest1 = manifest[InputTask[String]]
+        val attrKey = attributeKey(label, manifest1)
+        val k1 = SettingKey(attrKey) in scope
+        val k2 = InputKey(attrKey) in scope
+        expectNeSameManifest(k1, k2)
+      }
+
+      all(prop1, prop2)
+    }
+  }
+
+  ///
+
+  def settingKey[A](label: Label, manifest: Manifest[A], scope: Scope): SettingKey[A] = {
+    val noJsonWriter = NoJsonWriter[A]()
+    SettingKey[A](label.value)(manifest, noJsonWriter) in scope
+  }
+
+  def taskKey[A](label: Label, manifest: Manifest[A], s: Scope): TaskKey[A] =
+    TaskKey[A](label.value)(manifest) in s
+
+  def inputKey[A](label: Label, manifest: Manifest[A], scope: Scope): InputKey[A] =
+    InputKey[A](label.value)(manifest) in scope
+
+  def attributeKey[A](label: Label, manifest: Manifest[A]): AttributeKey[A] = {
+    val jsonWriter = NoJsonWriter[A]()
+    AttributeKey[A](label.value)(manifest, jsonWriter)
+  }
+
+  ///
+
+  def expectEq(k1: Scoped, k2: Scoped): Prop =
+    ?=(k1, k2) && ?=(k2, k1) map eqLabels(k1, k2)
+
+  def expectNe(k1: Scoped, k2: Scoped): Prop =
+    !=(k1, k2) && !=(k2, k1) map eqLabels(k1, k2)
+
+  def expectNeSameManifest(k1: Scoped, k2: Scoped) = {
+    all(
+      ?=(k1.key.manifest, k2.key.manifest), // sanity check the manifests are the same
+      expectNe(k1, k2),
+    )
+  }
+
+  def eqLabels(k1: Scoped, k2: Scoped): Prop.Result => Prop.Result = r => {
+    val eqLabel = k1.key.label == k2.key.label
+    val eqManifest = k1.key.manifest == k2.key.manifest
+    val eqScope = k1.scope == k2.scope
+    r.label(s"label equality: ${k1.key.label} == ${k2.key.label} : $eqLabel")
+      .label(s"manifest equality: ${k1.key.manifest} == ${k2.key.manifest} : $eqManifest")
+      .label(s"scope equality: ${k1.scope} == ${k2.scope} : $eqScope")
+  }
+
+  def ?=[T](x: T, y: T)(implicit pp: T => Pretty): Prop =
+    if (x == y) proved
+    else
+      falsified :| {
+        val act = Pretty.pretty[T](x, Pretty.Params(0))
+        val exp = Pretty.pretty[T](y, Pretty.Params(0))
+        s"Expected $act to be equal to $exp"
+      }
+
+  def !=[T](x: T, y: T)(implicit pp: T => Pretty): Prop =
+    if (x == y) falsified
+    else
+      proved :| {
+        val act = Pretty.pretty[T](x, Pretty.Params(0))
+        val exp = Pretty.pretty[T](y, Pretty.Params(0))
+        s"Expected $act to NOT be equal to $exp"
+      }
+}
diff --git a/main-settings/src/test/scala/sbt/SlashSyntaxSpec.scala b/main-settings/src/test/scala/sbt/SlashSyntaxSpec.scala
new file mode 100644
index 000000000..159276235
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/SlashSyntaxSpec.scala
@@ -0,0 +1,112 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.test
+
+import org.scalacheck.{ Test => _, _ }, Prop._
+
+import sbt.SlashSyntax
+import sbt.{ Scope, ScopeAxis, Scoped }, Scope.{ Global, ThisScope }
+import sbt.Reference
+import sbt.ConfigKey
+import sbt.internal.util.AttributeKey
+
+import BuildSettingsInstances._
+import scala.annotation.nowarn
+
+@nowarn
+object SlashSyntaxSpec extends Properties("SlashSyntax") with SlashSyntax {
+  property("Global / key == key in Global") = {
+    forAll((k: Key) => expectValue(k in Global)(Global / k))
+  }
+
+  property("Reference / key == key in Reference") = {
+    forAll((r: Reference, k: Key) => expectValue(k in r)(r / k))
+  }
+
+  property("Reference / Config / key == key in Reference in Config") = {
+    forAll((r: Reference, c: ConfigKey, k: Key) => expectValue(k in r in c)(r / c / k))
+  }
+
+  property("Reference / task.key / key == key in Reference in task") = {
+    forAll((r: Reference, t: Scoped, k: Key) => expectValue(k in (r, t))(r / t.key / k))
+  }
+
+  property("Reference / task / key ~= key in Reference in task") = {
+    import WithoutScope._
+    forAll((r: Reference, t: Key, k: Key) => expectValue(k in (r, t))(r / t / k))
+  }
+
+  property("Reference / Config / task.key / key == key in Reference in Config in task") = {
+    forAll { (r: Reference, c: ConfigKey, t: Scoped, k: Key) =>
+      expectValue(k in (r, c, t))(r / c / t.key / k)
+    }
+  }
+
+  property("Reference / Config / task / key ~= key in Reference in Config in task") = {
+    import WithoutScope._
+    forAll { (r: Reference, c: ConfigKey, t: Key, k: Key) =>
+      expectValue(k in (r, c, t))(r / c / t / k)
+    }
+  }
+
+  property("Config / key == key in Config") = {
+    forAll((c: ConfigKey, k: Key) => expectValue(k in c)(c / k))
+  }
+
+  property("Config / task.key / key == key in Config in task") = {
+    forAll((c: ConfigKey, t: Scoped, k: Key) => expectValue(k in c in t)(c / t.key / k))
+  }
+
+  property("Config / task / key ~= key in Config in task") = {
+    import WithoutScope._
+    forAll((c: ConfigKey, t: Key, k: Key) => expectValue(k in c in t)(c / t / k))
+  }
+
+  property("task.key / key == key in task") = {
+    forAll((t: Scoped, k: Key) => expectValue(k in t)(t.key / k))
+  }
+
+  property("task / key ~= key in task") = {
+    import WithoutScope._
+    forAll((t: Key, k: Key) => expectValue(k in t)(t / k))
+  }
+
+  property("Scope / key == key in Scope") = {
+    forAll((s: Scope, k: Key) => expectValue(k in s)(s / k))
+  }
+
+  property("Reference? / key == key in ThisScope.copy(..)") = {
+    forAll { (r: ScopeAxis[Reference], k: Key) =>
+      expectValue(k in ThisScope.copy(project = r))(r / k)
+    }
+  }
+
+  property("Reference? / ConfigKey? / key == key in ThisScope.copy(..)") = {
+    forAll(
+      (r: ScopeAxis[Reference], c: ScopeAxis[ConfigKey], k: Key) =>
+        expectValue(k in ThisScope.copy(project = r, config = c))(r / c / k)
+    )
+  }
+
+//  property("Reference? / AttributeKey? / key == key in ThisScope.copy(..)") = {
+//    forAll((r: ScopeAxis[Reference], t: ScopeAxis[AttributeKey[_]], k: AnyKey) =>
+//      expectValue(k in ThisScope.copy(project = r, task = t))(r / t / k))
+//  }
+
+  property("Reference? / ConfigKey? / AttributeKey? / key == key in ThisScope.copy(..)") = {
+    forAll {
+      (r: ScopeAxis[Reference], c: ScopeAxis[ConfigKey], t: ScopeAxis[AttributeKey[_]], k: Key) =>
+        expectValue(k in ThisScope.copy(project = r, config = c, task = t))(r / c / t / k)
+    }
+  }
+
+  def expectValue(expected: Scoped)(x: Scoped) = {
+    val equals = x.scope == expected.scope && x.key == expected.key
+    if (equals) proved else falsified :| s"Expected $expected but got $x"
+  }
+}
diff --git a/main-settings/src/test/scala/sbt/SlashSyntaxTest.scala b/main-settings/src/test/scala/sbt/SlashSyntaxTest.scala
new file mode 100644
index 000000000..8076fab2f
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/SlashSyntaxTest.scala
@@ -0,0 +1,64 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.test
+
+import java.io.File
+import sjsonnew._, BasicJsonProtocol._
+import sbt.Def.{ Setting, inputKey, settingKey, taskKey }
+import sbt.Scope.Global
+import sbt.librarymanagement.ModuleID
+import sbt.librarymanagement.syntax._
+import sbt.{ LocalProject, ProjectReference, ThisBuild, Zero }
+
+object SlashSyntaxTest extends sbt.SlashSyntax {
+  final case class Proj(id: String)
+  implicit def projToRef(p: Proj): ProjectReference = LocalProject(p.id)
+
+  val projA = Proj("a")
+
+  val cancelable = settingKey[Boolean]("")
+  val console = taskKey[Unit]("")
+  val libraryDependencies = settingKey[Seq[ModuleID]]("")
+  val name = settingKey[String]("")
+  val run = inputKey[Unit]("")
+  val scalaVersion = settingKey[String]("")
+  val scalacOptions = taskKey[Seq[String]]("")
+
+  val foo = taskKey[Int]("")
+  val bar = taskKey[Int]("")
+  val baz = inputKey[Unit]("")
+  val buildInfo = taskKey[Seq[File]]("")
+
+  val uTest = "com.lihaoyi" %% "utest" % "0.5.3"
+
+  Seq[Setting[_]](
+    Global / cancelable := true,
+    ThisBuild / scalaVersion := "2.12.3",
+    console / scalacOptions += "-deprecation",
+    Compile / console / scalacOptions += "-Ywarn-numeric-widen",
+    projA / Compile / console / scalacOptions += "-feature",
+    Zero / name := "foo",
+    Zero / Zero / name := "foo",
+    Zero / Zero / Zero / name := "foo",
+    Test / bar := 1,
+    Test / foo := (Test / bar).value + 1,
+    Compile / foo := {
+      (Compile / bar).previous.getOrElse(1)
+    },
+    Compile / bar := {
+      (Compile / foo).previous.getOrElse(2)
+    },
+    Test / buildInfo := Nil,
+    baz := {
+      val _ = (Test / buildInfo).taskValue
+      (Compile / run).evaluated
+    },
+    foo := (Test / bar).value + 1,
+    libraryDependencies += uTest % Test,
+  )
+}
diff --git a/main-settings/src/test/scala/sbt/TupleSyntaxTest.scala b/main-settings/src/test/scala/sbt/TupleSyntaxTest.scala
new file mode 100644
index 000000000..7b4028bcb
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/TupleSyntaxTest.scala
@@ -0,0 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.test
+
+import sbt._
+import sbt.Def.Initialize
+import sbt.TupleSyntax._
+
+object TupleSyntaxTest {
+  def t1[T](a: SettingKey[T], b: TaskKey[T], c: Initialize[T], d: Initialize[Task[T]]) = {
+    (a, b, c.toTaskable, d.toTaskable).map((x: T, y: T, z: T, w: T) => "" + x + y + z + w)
+  }
+}
diff --git a/main-settings/src/test/scala/sbt/std/TaskConfigSpec.scala b/main-settings/src/test/scala/sbt/std/TaskConfigSpec.scala
new file mode 100644
index 000000000..e43b655a6
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/std/TaskConfigSpec.scala
@@ -0,0 +1,77 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.std
+
+import org.scalatest.{ TestData, fixture }
+import sbt.std.TestUtil._
+
+import scala.tools.reflect.{ FrontEnd, ToolBoxError }
+
+class TaskConfigSpec extends fixture.FunSuite with fixture.TestDataFixture {
+  private def expectError(
+      errorSnippet: String,
+      compileOptions: String = "",
+  )(code: String)(implicit td: TestData) = {
+    val errorMessage = intercept[ToolBoxError] {
+      eval(code, s"$compileOptions -cp ${toolboxClasspath(td)}")
+      println(s"Test failed -- compilation was successful! Expected:\n$errorSnippet")
+    }.getMessage
+    val userMessage =
+      s"""
+         |FOUND: $errorMessage
+         |EXPECTED: $errorSnippet
+      """.stripMargin
+    assert(errorMessage.contains(errorSnippet), userMessage)
+  }
+  private class CachingToolbox(implicit td: TestData) {
+    private[this] val m = scala.reflect.runtime.currentMirror
+    private[this] var _infos: List[FrontEnd#Info] = Nil
+    private[this] val frontEnd = new FrontEnd {
+      override def display(info: Info): Unit = _infos ::= info
+      def interactive(): Unit = {}
+    }
+
+    import scala.tools.reflect.ToolBox
+    val toolbox = m.mkToolBox(frontEnd, options = s"-cp ${toolboxClasspath(td)}")
+    def eval(code: String): Any = toolbox.eval(toolbox.parse(code))
+    def infos: List[FrontEnd#Info] = _infos
+  }
+
+  private def taskDef(linterLevelImport: Option[String]): String =
+    s"""
+       |import sbt._
+       |import sbt.Def._
+       |${linterLevelImport.getOrElse("")}
+       |
+       |val fooNeg = taskKey[String]("")
+       |var condition = true
+       |
+       |val barNeg = Def.task[String] {
+       |  val s = 1
+       |  if (condition) fooNeg.value
+       |  else ""
+       |}
+      """.stripMargin
+  private val fooNegError = TaskLinterDSLFeedback.useOfValueInsideIfExpression("fooNeg")
+
+  test("Fail on task invocation inside if it is used inside a regular task") { implicit td =>
+    val fooNegError = TaskLinterDSLFeedback.useOfValueInsideIfExpression("fooNeg")
+    val code = taskDef(Some("import sbt.dsl.LinterLevel.Abort"))
+    expectError(List(fooNegError).mkString("\n"))(code)
+  }
+  test("Succeed if the linter level is set to warn") { implicit td =>
+    val toolbox = new CachingToolbox
+    assert(toolbox.eval(taskDef(None)) == ((): Unit))
+    assert(toolbox.infos.exists(i => i.severity.count == 1 && i.msg.contains(fooNegError)))
+  }
+  test("Succeed if the linter level is set to ignore") { implicit td =>
+    val toolbox = new CachingToolbox
+    assert(toolbox.eval(taskDef(Some("import sbt.dsl.LinterLevel.Ignore"))) == ((): Unit))
+    assert(toolbox.infos.isEmpty)
+  }
+}
diff --git a/main-settings/src/test/scala/sbt/std/TaskPosSpec.scala b/main-settings/src/test/scala/sbt/std/TaskPosSpec.scala
new file mode 100644
index 000000000..671d8c24f
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/std/TaskPosSpec.scala
@@ -0,0 +1,206 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.std
+
+class TaskPosSpec {
+  // Starting sbt 1.4.0, Def.task can have task value lookups inside
+  // if branches since tasks with single if-expressions are automatically
+  // converted into a conditional task.
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val bar = taskKey[String]("")
+    val condition = true
+    Def.task[String] {
+      if (condition) foo.value
+      else bar.value
+    }
+  }
+
+  // Dynamic tasks can have task invocations inside if branches
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val bar = taskKey[String]("")
+    val condition = true
+    Def.taskDyn[String] {
+      if (condition) foo
+      else bar
+    }
+  }
+
+  // Dynamic settings can have setting invocations inside if branches
+  locally {
+    import sbt._, Def._
+    val foo = settingKey[String]("")
+    val bar = settingKey[String]("")
+    val condition = true
+    Def.settingDyn[String] {
+      if (condition) foo
+      else bar
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val condition = true
+    Def.task[String] {
+      val fooAnon = () => foo.value: @sbtUnchecked
+      if (condition) fooAnon()
+      else fooAnon()
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val condition = true
+    Def.task[String] {
+      val fooAnon = () => (foo.value: @sbtUnchecked) + ""
+      if (condition) fooAnon()
+      else fooAnon()
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val bar = taskKey[String]("")
+    val condition = true
+    Def.task[String] {
+      if (condition) foo.value: @sbtUnchecked
+      else bar.value: @sbtUnchecked
+    }
+  }
+
+  locally {
+    // This is fix 1 for appearance of tasks inside anons
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val condition = true
+    Def.task[String] {
+      val fooResult = foo.value
+      val anon = () => fooResult + " "
+      if (condition) anon()
+      else ""
+    }
+  }
+
+  locally {
+    // This is fix 2 for appearance of tasks inside anons
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val condition = true
+    Def.taskDyn[String] {
+      val anon1 = (value: String) => value + " "
+      if (condition) {
+        Def.task(anon1(foo.value))
+      } else Def.task("")
+    }
+  }
+
+  locally {
+    // missing .value error should not happen inside task dyn
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    Def.taskDyn[String] {
+      foo
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    val avoidDCE = ""
+    Def.task[String] {
+      val _ = foo: @sbtUnchecked
+      avoidDCE
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    Def.task[String] {
+      def inner(s: KeyedInitialize[_]) = println(s)
+      inner(foo)
+      ""
+    }
+  }
+
+  locally {
+    // In theory, this should be reported, but missing .value analysis is dumb at the cost of speed
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    def avoidDCE = { println(""); "" }
+    Def.task[String] {
+      val (_, _) = "" match {
+        case _ => (foo, 1 + 2)
+      }
+      avoidDCE
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = taskKey[String]("")
+    def avoidDCE(x: TaskKey[String]) = x.toString
+    Def.task[String] {
+      val hehe = foo
+      // We do not detect `hehe` because guessing that the user did the wrong thing would require
+      // us to run the unused name traverser defined in Typer (and hence proxy it from context util)
+      avoidDCE(hehe)
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    def withKey(foo: => SettingKey[String]): Def.Initialize[Task[Unit]] = {
+      Def.task {
+        if (true) {
+          Def.unit(foo.value); ()
+        }
+      }
+    }
+    val foo = settingKey[String]("")
+    withKey(foo)
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = settingKey[String]("")
+    val condition = true
+    Def.task[String] {
+      // settings can be evaluated in a condition
+      if (condition) foo.value
+      else "..."
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    val foo = settingKey[String]("")
+    Def.task[Seq[String]] {
+      (1 to 10).map(_ => foo.value)
+    }
+  }
+
+  locally {
+    import sbt._, Def._
+    def withKey(bar: => SettingKey[Int]) = {
+      Def.task {
+        List(42).map { _ =>
+          if (true) bar.value
+        }
+      }
+    }
+    val bar = settingKey[Int]("bar")
+    withKey(bar)
+  }
+}
diff --git a/main-settings/src/test/scala/sbt/std/TestUtil.scala b/main-settings/src/test/scala/sbt/std/TestUtil.scala
new file mode 100644
index 000000000..e020624ab
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/std/TestUtil.scala
@@ -0,0 +1,31 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.std
+
+import org.scalatest.TestData
+
+import scala.tools.reflect.ToolBox
+
+object TestUtil {
+  def eval(code: String, compileOptions: String = ""): Any = {
+    val tb = mkToolbox(compileOptions)
+    tb.eval(tb.parse(code))
+  }
+
+  def mkToolbox(compileOptions: String = ""): ToolBox[_ <: scala.reflect.api.Universe] = {
+    val m = scala.reflect.runtime.currentMirror
+    import scala.tools.reflect.ToolBox
+    m.mkToolBox(options = compileOptions)
+  }
+
+  def toolboxClasspath(td: TestData): String =
+    td.configMap.get("sbt.server.classpath") match {
+      case Some(s: String) => s
+      case _               => throw new IllegalStateException("No classpath specified.")
+    }
+}
diff --git a/main-settings/src/test/scala/UsageTest.scala b/main-settings/src/test/scala/sbt/std/UsageTest.scala
similarity index 87%
rename from main-settings/src/test/scala/UsageTest.scala
rename to main-settings/src/test/scala/sbt/std/UsageTest.scala
index 909374049..154bec498 100644
--- a/main-settings/src/test/scala/UsageTest.scala
+++ b/main-settings/src/test/scala/sbt/std/UsageTest.scala
@@ -1,8 +1,15 @@
-package sbt
-package std
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.std
 
 import sbt.internal.util.complete
 import sbt.internal.util.complete.DefaultParsers
+import sbt.{ Def, InputTask, Task }
 
 /*object UseTask
 {
@@ -20,6 +27,7 @@ import sbt.internal.util.complete.DefaultParsers
 }*/
 object Assign {
   import java.io.File
+
   import Def.{ Initialize, inputKey, macroValueT, parserToInput, settingKey, taskKey }
   //	import UseTask.{x,y,z,a,set,plain}
 
@@ -52,7 +60,9 @@ object Assign {
 		bk ++= Seq(z.value)
 	)*/
 
-  val zz = Def.task { mk.value + tk.value + mk.value + tk.value + mk.value + tk.value + mk.value + tk.value + mk.value + tk.value + mk.value + tk.value }
+  val zz = Def.task {
+    mk.value + tk.value + mk.value + tk.value + mk.value + tk.value + mk.value + tk.value + mk.value + tk.value + mk.value + tk.value
+  }
 
   import DefaultParsers._
   val p = Def.setting { name.value ~> Space ~> ID }
@@ -61,7 +71,7 @@ object Assign {
     name := "asdf",
     tk := (math.random * 1000).toInt,
     isk := dummys.value.parsed // should not compile: cannot use a task to define the parser
-  //		ik := { if( tsk.parsed.value == "blue") tk.value else mk.value }
+    //		ik := { if( tsk.parsed.value == "blue") tk.value else mk.value }
   )
 
   val it1 = Def.inputTask {
@@ -84,7 +94,6 @@ object Assign {
   }
   val it6 = Def.inputTaskDyn {
     val d3 = dummy3.parsed
-    val x = d3._1
     val i = d3._2
     Def.task { tk.value + i }
   }
diff --git a/main-settings/src/test/scala/sbt/std/neg/TaskNegSpec.scala b/main-settings/src/test/scala/sbt/std/neg/TaskNegSpec.scala
new file mode 100644
index 000000000..0e08b5e96
--- /dev/null
+++ b/main-settings/src/test/scala/sbt/std/neg/TaskNegSpec.scala
@@ -0,0 +1,384 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.std.neg
+
+import scala.tools.reflect.ToolBoxError
+import org.scalatest.{ TestData, fixture }
+import sbt.std.{ TaskLinterDSLFeedback, TestUtil }
+import sbt.std.TestUtil._
+
+class TaskNegSpec extends fixture.FunSuite with fixture.TestDataFixture {
+  def expectError(
+      errorSnippet: String,
+      compileOptions: String = "",
+  )(code: String)(implicit td: TestData) = {
+    val errorMessage = intercept[ToolBoxError] {
+      val baseCompileOptions = s"-cp ${TestUtil.toolboxClasspath(td)}"
+      eval(code, s"$compileOptions $baseCompileOptions")
+      println(s"Test failed -- compilation was successful! Expected:\n$errorSnippet")
+    }.getMessage
+    val userMessage =
+      s"""
+         |FOUND: $errorMessage
+         |EXPECTED: $errorSnippet
+      """.stripMargin
+    assert(errorMessage.contains(errorSnippet), userMessage)
+  }
+
+  test("Fail on task invocation inside if it is used inside a regular task") { implicit td =>
+    val fooNegError = TaskLinterDSLFeedback.useOfValueInsideIfExpression("fooNeg")
+    val barNegError = TaskLinterDSLFeedback.useOfValueInsideIfExpression("barNeg")
+    expectError(List(fooNegError, barNegError).mkString("\n")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.task[String] {
+        |  val s = 1
+        |  if (condition) fooNeg.value
+        |  else barNeg.value
+        |}
+      """.stripMargin
+    }
+  }
+
+  test("Fail on task invocation inside `if` if it is used inside a regular task") { implicit td =>
+    val fooNegError = TaskLinterDSLFeedback.useOfValueInsideIfExpression("fooNeg")
+    val barNegError = TaskLinterDSLFeedback.useOfValueInsideIfExpression("barNeg")
+    expectError(List(fooNegError, barNegError).mkString("\n")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |def bi(s: String) = s + "  "
+        |
+        |val bazNeg = Def.task[String] {
+        |  val s = 1
+        |  if (condition) "" + fooNeg.value
+        |  else bi(barNeg.value)
+        |}
+      """.stripMargin
+    }
+  }
+
+  test("Fail on task invocation inside `if` of task returned by dynamic task") { implicit td =>
+    expectError(TaskLinterDSLFeedback.useOfValueInsideIfExpression("fooNeg")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.taskDyn[String] {
+        |  if (condition) {
+        |    Def.task {
+        |      val s = 1
+        |      if (condition) {
+        |        fooNeg.value
+        |      } else ""
+        |    }
+        |  } else Def.task("")
+        |}
+      """.stripMargin
+    }
+  }
+
+  test("Fail on task invocation inside nested `if` of task returned by dynamic task") {
+    implicit td =>
+      val fooNegCatch = TaskLinterDSLFeedback.useOfValueInsideIfExpression("fooNeg")
+      val barNegCatch = TaskLinterDSLFeedback.useOfValueInsideIfExpression("barNeg")
+      expectError(List(fooNegCatch, barNegCatch).mkString("\n")) {
+        """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.taskDyn[String] {
+        |  if (condition) {
+        |    Def.task {
+        |      val s = 1
+        |      if (condition) {
+        |        val first = if (!condition && condition) {
+        |          fooNeg.value
+        |        } else ""
+        |        if ("true".toBoolean) first
+        |        else {
+        |          barNeg.value
+        |        }
+        |      } else ""
+        |    }
+        |  } else Def.task("")
+        |}
+      """.stripMargin
+      }
+  }
+
+  test("Fail on task invocation inside else of task returned by dynamic task") { implicit td =>
+    expectError(TaskLinterDSLFeedback.useOfValueInsideIfExpression("barNeg")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.taskDyn[String] {
+        |  if (condition) {
+        |    Def.task {
+        |      val s = 1
+        |      if (condition) ""
+        |      else barNeg.value
+        |    }
+        |  } else Def.task("")
+        |}
+      """.stripMargin
+    }
+  }
+
+  test("Fail on task invocation inside anonymous function returned by regular task") {
+    implicit td =>
+      val fooNegError = TaskLinterDSLFeedback.useOfValueInsideAnon("fooNeg")
+      expectError(fooNegError) {
+        """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.task[String] {
+        |  val anon = () => fooNeg.value
+        |  if (condition) anon()
+        |  else anon()
+        |}
+      """.stripMargin
+      }
+  }
+
+  test("Fail on task invocation inside nested anonymous function returned by regular task") {
+    implicit td =>
+      val fooNegError = TaskLinterDSLFeedback.useOfValueInsideAnon("fooNeg")
+      val barNegError = TaskLinterDSLFeedback.useOfValueInsideAnon("barNeg")
+      expectError(List(fooNegError, barNegError).mkString("\n")) {
+        """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.task[String] {
+        |  val anon = () => { val _ = () => fooNeg.value; barNeg.value}
+        |  if (condition) anon()
+        |  else anon()
+        |}
+      """.stripMargin
+      }
+  }
+
+  test("Fail on task invocation inside complex anonymous function returned by regular task") {
+    implicit td =>
+      val fooNegError = TaskLinterDSLFeedback.useOfValueInsideAnon("fooNeg")
+      expectError(fooNegError) {
+        """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.task[String] {
+        |  val anon = () => fooNeg.value + ""
+        |  if (condition) anon()
+        |  else anon()
+        |}
+      """.stripMargin
+      }
+  }
+
+  test("Fail on task invocation inside anonymous function returned by dynamic task") {
+    implicit td =>
+      val fooNegError = TaskLinterDSLFeedback.useOfValueInsideAnon("fooNeg")
+      expectError(fooNegError) {
+        """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |val barNeg = taskKey[String]("")
+        |var condition = true
+        |
+        |val bazNeg = Def.taskDyn[String] {
+        |  if (condition) {
+        |    val anon = () => fooNeg.value
+        |    Def.task(anon())
+        |  } else Def.task("")
+        |}
+      """.stripMargin
+      }
+  }
+
+  test("Detect a missing `.value` inside a task") { implicit td =>
+    expectError(TaskLinterDSLFeedback.missingValueForKey("fooNeg")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg = taskKey[String]("")
+        |
+        |def avoidDCE = {println(""); ""}
+        |val bazNeg = Def.task[String] {
+        |  fooNeg
+        |  avoidDCE
+        |}
+      """.stripMargin
+    }
+  }
+
+  /*
+  test("Detect a missing `.value` inside a val definition of a task") { implicit td =>
+    expectError(TaskLinterDSLFeedback.missingValueForKey("fooNeg2")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg2 = taskKey[String]("")
+        |
+        |def avoidDCE = {println(""); ""}
+        |val bazNeg = Def.task[String] {
+        |  val _ = fooNeg2
+        |  avoidDCE
+        |}
+      """.stripMargin
+    }
+  }
+
+  test("Detect a missing `.value` inside a val definition of an inner method of a task") {
+    implicit td =>
+      expectError(TaskLinterDSLFeedback.missingValueForKey("fooNeg2")) {
+        """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg2 = taskKey[String]("")
+        |
+        |def avoidDCE = {println(""); ""}
+        |val bazNeg = Def.task[String] {
+        |  def inner = {
+        |    val _ = fooNeg2
+        |    avoidDCE
+        |  }
+        |  inner
+        |}
+      """.stripMargin
+      }
+  }
+   */
+
+  test("Detect a missing `.value` inside an inner method of a task") { implicit td =>
+    expectError(TaskLinterDSLFeedback.missingValueForKey("fooNeg3")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg3 = taskKey[String]("")
+        |def avoidDCE = {println(""); ""}
+        |val bazNeg = Def.task[String] {
+        |  def inner: String = {
+        |    fooNeg3
+        |    avoidDCE
+        |  }
+        |  inner
+        |}
+      """.stripMargin
+    }
+  }
+
+  test("Detect a missing `.value` inside a task whose return type is Unit") { implicit td =>
+    expectError(TaskLinterDSLFeedback.missingValueForKey("fooNeg4")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |import sbt.dsl.LinterLevel.Abort
+        |
+        |val fooNeg4 = taskKey[String]("")
+        |
+        |val bazNeg = Def.task[Unit] {
+        |  fooNeg4
+        |}
+      """.stripMargin
+    }
+  }
+
+  // Enable these tests when https://github.com/scala/bug/issues/10340 is fixed
+
+  /*
+  test("Detect a missing `.value` inside a val of an inner method of a task returning a literal") {
+    expectError(TaskLinterDSLFeedback.missingValueForKey("fooNeg3")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |
+        |val fooNeg3 = taskKey[String]("")
+        |
+        |val bazNeg = Def.task[String] {
+        |  def inner: String = {
+        |    val _ = fooNeg3
+        |    ""
+        |  }
+        |  inner
+        |}
+      """.stripMargin
+    }
+  }
+
+  test("Detect a missing `.value` inside a val of a task returning a literal") {
+    expectError(TaskLinterDSLFeedback.missingValueForKey("fooNeg3")) {
+      """
+        |import sbt._
+        |import sbt.Def._
+        |
+        |val fooNeg3 = taskKey[String]("")
+        |
+        |val bazNeg = Def.task[String] {
+        |  val _ = fooNeg3
+        |  ""
+        |}
+      """.stripMargin
+    }
+  }
+ */
+}
diff --git a/main/NOTICE b/main/NOTICE
index de7e8ba8c..0fab58e02 100644
--- a/main/NOTICE
+++ b/main/NOTICE
@@ -1,3 +1,4 @@
-Simple Build Tool: Main integration component
-Copyright 2010  Mark Harrah
-Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
+sbt: Main integration component
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under BSD-3-Clause license (see LICENSE)
diff --git a/main/src/main/contraband-scala/sbt/JavaVersion.scala b/main/src/main/contraband-scala/sbt/JavaVersion.scala
new file mode 100644
index 000000000..3d63e894a
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/JavaVersion.scala
@@ -0,0 +1,49 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+final class JavaVersion private (
+  val numbers: Vector[Long],
+  val tags: Vector[String],
+  val vendor: Option[String]) extends Serializable {
+  def numberStr: String = numbers.mkString(".")
+  private def tagStr: String = if (tags.isEmpty) "" else tags.mkString("-", "-", "")
+  private def this() = this(Vector(), Vector(), None)
+  private def this(numbers: Vector[Long], vendor: Option[String]) = this(numbers, Vector(), vendor)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JavaVersion => (this.numbers == x.numbers) && (this.tags == x.tags) && (this.vendor == x.vendor)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.JavaVersion".##) + numbers.##) + tags.##) + vendor.##)
+  }
+  override def toString: String = {
+    vendor.map(_ + "@").getOrElse("") + numberStr + tagStr
+  }
+  private[this] def copy(numbers: Vector[Long] = numbers, tags: Vector[String] = tags, vendor: Option[String] = vendor): JavaVersion = {
+    new JavaVersion(numbers, tags, vendor)
+  }
+  def withNumbers(numbers: Vector[Long]): JavaVersion = {
+    copy(numbers = numbers)
+  }
+  def withTags(tags: Vector[String]): JavaVersion = {
+    copy(tags = tags)
+  }
+  def withVendor(vendor: Option[String]): JavaVersion = {
+    copy(vendor = vendor)
+  }
+  def withVendor(vendor: String): JavaVersion = {
+    copy(vendor = Option(vendor))
+  }
+}
+object JavaVersion {
+  def apply(version: String): JavaVersion = sbt.internal.CrossJava.parseJavaVersion(version)
+  def apply(): JavaVersion = new JavaVersion()
+  def apply(numbers: Vector[Long], vendor: Option[String]): JavaVersion = new JavaVersion(numbers, vendor)
+  def apply(numbers: Vector[Long], vendor: String): JavaVersion = new JavaVersion(numbers, Option(vendor))
+  def apply(numbers: Vector[Long], tags: Vector[String], vendor: Option[String]): JavaVersion = new JavaVersion(numbers, tags, vendor)
+  def apply(numbers: Vector[Long], tags: Vector[String], vendor: String): JavaVersion = new JavaVersion(numbers, tags, Option(vendor))
+}
diff --git a/main/src/main/contraband-scala/sbt/PluginTrigger.scala b/main/src/main/contraband-scala/sbt/PluginTrigger.scala
new file mode 100644
index 000000000..808abd467
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/PluginTrigger.scala
@@ -0,0 +1,18 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+/**
+ * Type for AutoPlugin's trigger method.
+ * Determines whether an AutoPlugin will be activated for a project when the
+ * `requires` clause is satisfied.
+ */
+sealed abstract class PluginTrigger extends Serializable
+object PluginTrigger {
+  
+  
+  case object AllRequirements extends PluginTrigger
+  case object NoTrigger extends PluginTrigger
+}
diff --git a/main/src/main/contraband-scala/sbt/ProjectOrigin.scala b/main/src/main/contraband-scala/sbt/ProjectOrigin.scala
new file mode 100644
index 000000000..370b70f7a
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/ProjectOrigin.scala
@@ -0,0 +1,19 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+/**
+ * Indicate whether the project was created organically, synthesized by a plugin,
+ * or is a "generic root" project supplied by sbt when a project doesn't exist for `file(".")`.
+ */
+sealed abstract class ProjectOrigin extends Serializable
+object ProjectOrigin {
+  
+  
+  case object Organic extends ProjectOrigin
+  case object ExtraProject extends ProjectOrigin
+  case object DerivedProject extends ProjectOrigin
+  case object GenericRoot extends ProjectOrigin
+}
diff --git a/main/src/main/contraband-scala/sbt/internal/remotecache/CompileRemoteCacheArtifact.scala b/main/src/main/contraband-scala/sbt/internal/remotecache/CompileRemoteCacheArtifact.scala
new file mode 100644
index 000000000..982fdfd62
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/internal/remotecache/CompileRemoteCacheArtifact.scala
@@ -0,0 +1,44 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.remotecache
+final class CompileRemoteCacheArtifact private (
+  artifact: sbt.librarymanagement.Artifact,
+  packaged: sbt.TaskKey[java.io.File],
+  val extractDirectory: java.io.File,
+  val analysisFile: java.io.File) extends sbt.internal.remotecache.RemoteCacheArtifact(artifact, packaged) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CompileRemoteCacheArtifact => (this.artifact == x.artifact) && (this.packaged == x.packaged) && (this.extractDirectory == x.extractDirectory) && (this.analysisFile == x.analysisFile)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.remotecache.CompileRemoteCacheArtifact".##) + artifact.##) + packaged.##) + extractDirectory.##) + analysisFile.##)
+  }
+  override def toString: String = {
+    "CompileRemoteCacheArtifact(" + artifact + ", " + packaged + ", " + extractDirectory + ", " + analysisFile + ")"
+  }
+  private[this] def copy(artifact: sbt.librarymanagement.Artifact = artifact, packaged: sbt.TaskKey[java.io.File] = packaged, extractDirectory: java.io.File = extractDirectory, analysisFile: java.io.File = analysisFile): CompileRemoteCacheArtifact = {
+    new CompileRemoteCacheArtifact(artifact, packaged, extractDirectory, analysisFile)
+  }
+  def withArtifact(artifact: sbt.librarymanagement.Artifact): CompileRemoteCacheArtifact = {
+    copy(artifact = artifact)
+  }
+  def withPackaged(packaged: sbt.TaskKey[java.io.File]): CompileRemoteCacheArtifact = {
+    copy(packaged = packaged)
+  }
+  def withExtractDirectory(extractDirectory: java.io.File): CompileRemoteCacheArtifact = {
+    copy(extractDirectory = extractDirectory)
+  }
+  def withAnalysisFile(analysisFile: java.io.File): CompileRemoteCacheArtifact = {
+    copy(analysisFile = analysisFile)
+  }
+}
+object CompileRemoteCacheArtifact {
+  
+  def apply(artifact: sbt.librarymanagement.Artifact, packaged: sbt.TaskKey[java.io.File], extractDirectory: java.io.File, analysisFile: java.io.File): CompileRemoteCacheArtifact = new CompileRemoteCacheArtifact(artifact, packaged, extractDirectory, analysisFile)
+}
diff --git a/main/src/main/contraband-scala/sbt/internal/remotecache/CustomRemoteCacheArtifact.scala b/main/src/main/contraband-scala/sbt/internal/remotecache/CustomRemoteCacheArtifact.scala
new file mode 100644
index 000000000..81ade63a2
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/internal/remotecache/CustomRemoteCacheArtifact.scala
@@ -0,0 +1,44 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.remotecache
+final class CustomRemoteCacheArtifact private (
+  artifact: sbt.librarymanagement.Artifact,
+  packaged: sbt.TaskKey[java.io.File],
+  val extractDirectory: java.io.File,
+  val preserveLastModified: Boolean) extends sbt.internal.remotecache.RemoteCacheArtifact(artifact, packaged) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CustomRemoteCacheArtifact => (this.artifact == x.artifact) && (this.packaged == x.packaged) && (this.extractDirectory == x.extractDirectory) && (this.preserveLastModified == x.preserveLastModified)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.remotecache.CustomRemoteCacheArtifact".##) + artifact.##) + packaged.##) + extractDirectory.##) + preserveLastModified.##)
+  }
+  override def toString: String = {
+    "CustomRemoteCacheArtifact(" + artifact + ", " + packaged + ", " + extractDirectory + ", " + preserveLastModified + ")"
+  }
+  private[this] def copy(artifact: sbt.librarymanagement.Artifact = artifact, packaged: sbt.TaskKey[java.io.File] = packaged, extractDirectory: java.io.File = extractDirectory, preserveLastModified: Boolean = preserveLastModified): CustomRemoteCacheArtifact = {
+    new CustomRemoteCacheArtifact(artifact, packaged, extractDirectory, preserveLastModified)
+  }
+  def withArtifact(artifact: sbt.librarymanagement.Artifact): CustomRemoteCacheArtifact = {
+    copy(artifact = artifact)
+  }
+  def withPackaged(packaged: sbt.TaskKey[java.io.File]): CustomRemoteCacheArtifact = {
+    copy(packaged = packaged)
+  }
+  def withExtractDirectory(extractDirectory: java.io.File): CustomRemoteCacheArtifact = {
+    copy(extractDirectory = extractDirectory)
+  }
+  def withPreserveLastModified(preserveLastModified: Boolean): CustomRemoteCacheArtifact = {
+    copy(preserveLastModified = preserveLastModified)
+  }
+}
+object CustomRemoteCacheArtifact {
+  
+  def apply(artifact: sbt.librarymanagement.Artifact, packaged: sbt.TaskKey[java.io.File], extractDirectory: java.io.File, preserveLastModified: Boolean): CustomRemoteCacheArtifact = new CustomRemoteCacheArtifact(artifact, packaged, extractDirectory, preserveLastModified)
+}
diff --git a/main/src/main/contraband-scala/sbt/internal/remotecache/PomRemoteCacheArtifact.scala b/main/src/main/contraband-scala/sbt/internal/remotecache/PomRemoteCacheArtifact.scala
new file mode 100644
index 000000000..7e14d1f73
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/internal/remotecache/PomRemoteCacheArtifact.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.remotecache
+final class PomRemoteCacheArtifact private (
+  artifact: sbt.librarymanagement.Artifact,
+  packaged: sbt.TaskKey[java.io.File]) extends sbt.internal.remotecache.RemoteCacheArtifact(artifact, packaged) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: PomRemoteCacheArtifact => (this.artifact == x.artifact) && (this.packaged == x.packaged)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.remotecache.PomRemoteCacheArtifact".##) + artifact.##) + packaged.##)
+  }
+  override def toString: String = {
+    "PomRemoteCacheArtifact(" + artifact + ", " + packaged + ")"
+  }
+  private[this] def copy(artifact: sbt.librarymanagement.Artifact = artifact, packaged: sbt.TaskKey[java.io.File] = packaged): PomRemoteCacheArtifact = {
+    new PomRemoteCacheArtifact(artifact, packaged)
+  }
+  def withArtifact(artifact: sbt.librarymanagement.Artifact): PomRemoteCacheArtifact = {
+    copy(artifact = artifact)
+  }
+  def withPackaged(packaged: sbt.TaskKey[java.io.File]): PomRemoteCacheArtifact = {
+    copy(packaged = packaged)
+  }
+}
+object PomRemoteCacheArtifact {
+  
+  def apply(artifact: sbt.librarymanagement.Artifact, packaged: sbt.TaskKey[java.io.File]): PomRemoteCacheArtifact = new PomRemoteCacheArtifact(artifact, packaged)
+}
diff --git a/main/src/main/contraband-scala/sbt/internal/remotecache/RemoteCacheArtifact.scala b/main/src/main/contraband-scala/sbt/internal/remotecache/RemoteCacheArtifact.scala
new file mode 100644
index 000000000..01c286e24
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/internal/remotecache/RemoteCacheArtifact.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.remotecache
+abstract class RemoteCacheArtifact(
+  val artifact: sbt.librarymanagement.Artifact,
+  val packaged: sbt.TaskKey[java.io.File]) extends Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: RemoteCacheArtifact => (this.artifact == x.artifact) && (this.packaged == x.packaged)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.remotecache.RemoteCacheArtifact".##) + artifact.##) + packaged.##)
+  }
+  override def toString: String = {
+    "RemoteCacheArtifact(" + artifact + ", " + packaged + ")"
+  }
+}
+object RemoteCacheArtifact {
+  
+}
diff --git a/main/src/main/contraband-scala/sbt/internal/remotecache/TestRemoteCacheArtifact.scala b/main/src/main/contraband-scala/sbt/internal/remotecache/TestRemoteCacheArtifact.scala
new file mode 100644
index 000000000..7fb49f693
--- /dev/null
+++ b/main/src/main/contraband-scala/sbt/internal/remotecache/TestRemoteCacheArtifact.scala
@@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.remotecache
+final class TestRemoteCacheArtifact private (
+  artifact: sbt.librarymanagement.Artifact,
+  packaged: sbt.TaskKey[java.io.File],
+  val extractDirectory: java.io.File,
+  val analysisFile: java.io.File,
+  val testResult: java.io.File) extends sbt.internal.remotecache.RemoteCacheArtifact(artifact, packaged) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestRemoteCacheArtifact => (this.artifact == x.artifact) && (this.packaged == x.packaged) && (this.extractDirectory == x.extractDirectory) && (this.analysisFile == x.analysisFile) && (this.testResult == x.testResult)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.remotecache.TestRemoteCacheArtifact".##) + artifact.##) + packaged.##) + extractDirectory.##) + analysisFile.##) + testResult.##)
+  }
+  override def toString: String = {
+    "TestRemoteCacheArtifact(" + artifact + ", " + packaged + ", " + extractDirectory + ", " + analysisFile + ", " + testResult + ")"
+  }
+  private[this] def copy(artifact: sbt.librarymanagement.Artifact = artifact, packaged: sbt.TaskKey[java.io.File] = packaged, extractDirectory: java.io.File = extractDirectory, analysisFile: java.io.File = analysisFile, testResult: java.io.File = testResult): TestRemoteCacheArtifact = {
+    new TestRemoteCacheArtifact(artifact, packaged, extractDirectory, analysisFile, testResult)
+  }
+  def withArtifact(artifact: sbt.librarymanagement.Artifact): TestRemoteCacheArtifact = {
+    copy(artifact = artifact)
+  }
+  def withPackaged(packaged: sbt.TaskKey[java.io.File]): TestRemoteCacheArtifact = {
+    copy(packaged = packaged)
+  }
+  def withExtractDirectory(extractDirectory: java.io.File): TestRemoteCacheArtifact = {
+    copy(extractDirectory = extractDirectory)
+  }
+  def withAnalysisFile(analysisFile: java.io.File): TestRemoteCacheArtifact = {
+    copy(analysisFile = analysisFile)
+  }
+  def withTestResult(testResult: java.io.File): TestRemoteCacheArtifact = {
+    copy(testResult = testResult)
+  }
+}
+object TestRemoteCacheArtifact {
+  
+  def apply(artifact: sbt.librarymanagement.Artifact, packaged: sbt.TaskKey[java.io.File], extractDirectory: java.io.File, analysisFile: java.io.File, testResult: java.io.File): TestRemoteCacheArtifact = new TestRemoteCacheArtifact(artifact, packaged, extractDirectory, analysisFile, testResult)
+}
diff --git a/main/src/main/contraband/main.contra b/main/src/main/contraband/main.contra
new file mode 100644
index 000000000..2c0e64739
--- /dev/null
+++ b/main/src/main/contraband/main.contra
@@ -0,0 +1,31 @@
+package sbt
+@target(Scala)
+
+## Indicate whether the project was created organically, synthesized by a plugin,
+## or is a "generic root" project supplied by sbt when a project doesn't exist for `file(".")`.
+enum ProjectOrigin {
+  Organic
+  ExtraProject
+  DerivedProject
+  GenericRoot
+}
+
+## Type for AutoPlugin's trigger method.
+## Determines whether an AutoPlugin will be activated for a project when the
+## `requires` clause is satisfied.
+enum PluginTrigger {
+  AllRequirements
+  NoTrigger
+}
+
+type JavaVersion {
+  numbers: [Long] @since("1.2.0")
+  tags: [String] @since("1.3.0")
+  vendor: String @since("1.2.0")
+
+  #x def numberStr: String = numbers.mkString(".")
+  #x private def tagStr: String = if (tags.isEmpty) "" else tags.mkString("-", "-", "")
+  #xtostring vendor.map(_ + "@").getOrElse("") + numberStr + tagStr
+
+  #xcompanion def apply(version: String): JavaVersion = sbt.internal.CrossJava.parseJavaVersion(version)
+}
diff --git a/main/src/main/contraband/remotecache.json b/main/src/main/contraband/remotecache.json
new file mode 100644
index 000000000..486d25f9b
--- /dev/null
+++ b/main/src/main/contraband/remotecache.json
@@ -0,0 +1,83 @@
+{
+  "codecNamespace": "sbt.internal.remotecache",
+  "fullCodec": "RemoteCacheArtifactCodec",
+  "types": [
+    {
+      "name": "RemoteCacheArtifact",
+      "namespace": "sbt.internal.remotecache",
+      "target": "Scala",
+      "type": "interface",
+      "fields": [
+        {
+          "name": "artifact",
+          "type": "sbt.librarymanagement.Artifact"
+        },
+        {
+          "name": "packaged",
+          "type": "sbt.TaskKey[java.io.File]"
+        }
+      ],
+      "types": [
+        {
+          "name": "PomRemoteCacheArtifact",
+          "namespace": "sbt.internal.remotecache",
+          "target": "Scala",
+          "type": "record",
+          "fields": []
+        },
+        {
+          "name": "CompileRemoteCacheArtifact",
+          "namespace": "sbt.internal.remotecache",
+          "target": "Scala",
+          "type": "record",
+          "fields": [
+            {
+              "name": "extractDirectory",
+              "type": "java.io.File"
+            },
+            {
+              "name": "analysisFile",
+              "type": "java.io.File"
+            }
+          ]
+        },
+        {
+          "name": "TestRemoteCacheArtifact",
+          "namespace": "sbt.internal.remotecache",
+          "target": "Scala",
+          "type": "record",
+          "fields": [
+            {
+              "name": "extractDirectory",
+              "type": "java.io.File"
+            },
+            {
+              "name": "analysisFile",
+              "type": "java.io.File"
+            },
+            {
+              "name": "testResult",
+              "type": "java.io.File"
+            }
+          ]
+        },
+        {
+          "name": "CustomRemoteCacheArtifact",
+          "namespace": "sbt.internal.remotecache",
+          "target": "Scala",
+          "type": "record",
+          "fields": [
+            {
+              "name": "extractDirectory",
+              "type": "java.io.File"
+            },
+            {
+              "name": "preserveLastModified",
+              "type": "Boolean"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/main/src/main/java/sbt/internal/BottomClassLoader.java b/main/src/main/java/sbt/internal/BottomClassLoader.java
new file mode 100644
index 000000000..58997c4db
--- /dev/null
+++ b/main/src/main/java/sbt/internal/BottomClassLoader.java
@@ -0,0 +1,77 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import sbt.util.Logger;
+
+/**
+ * The bottom most layer in our layering hierarchy. This layer should never be cached. The
+ * dependency layer may need access to classes only available at this layer using java reflection.
+ * To make this work, we register this loader with the parent in its constructor. We also add the
+ * lookupClass method which gives ReverseLookupClassLoader a public interface to findClass.
+ *
+ * <p>To improve performance, when loading classes from the parent, we call the loadClass method
+ * with the reverseLookup flag set to false. This prevents the ReverseLookupClassLoader from trying
+ * to call back into this loader when it can't find a particular class.
+ */
+final class BottomClassLoader extends ManagedClassLoader {
+  private final ReverseLookupClassLoaderHolder holder;
+  private final ReverseLookupClassLoader parent;
+  private final ClassLoadingLock classLoadingLock = new ClassLoadingLock();
+
+  BottomClassLoader(
+      final ReverseLookupClassLoaderHolder holder,
+      final URL[] dynamicClasspath,
+      final ReverseLookupClassLoader reverseLookupClassLoader,
+      final File tempDir,
+      final boolean close,
+      final boolean allowZombies,
+      final Logger logger) {
+    super(dynamicClasspath, reverseLookupClassLoader, close, allowZombies, logger);
+    setTempDir(tempDir);
+    this.holder = holder;
+    this.parent = reverseLookupClassLoader;
+    parent.setDescendant(this);
+  }
+
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+
+  @Override
+  public Class<?> findClass(final String name) throws ClassNotFoundException {
+    return classLoadingLock.withLock(
+        name,
+        () -> {
+          final Class<?> prev = findLoadedClass(name);
+          if (prev != null) return prev;
+          return super.findClass(name);
+        });
+  }
+
+  @Override
+  protected Class<?> loadClass(final String name, final boolean resolve)
+      throws ClassNotFoundException {
+    try {
+      return parent.loadClass(name, resolve, false);
+    } catch (final ClassNotFoundException e) {
+      final Class<?> clazz = findClass(name);
+      if (resolve) resolveClass(clazz);
+      return clazz;
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    holder.checkin(parent);
+    super.close();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/ClassLoaderClose.java b/main/src/main/java/sbt/internal/ClassLoaderClose.java
new file mode 100644
index 000000000..70c7cf16c
--- /dev/null
+++ b/main/src/main/java/sbt/internal/ClassLoaderClose.java
@@ -0,0 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+public class ClassLoaderClose {
+  public static void close(ClassLoader classLoader) throws Exception {
+    if (classLoader instanceof AutoCloseable) ((AutoCloseable) classLoader).close();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/ClassLoadingLock.java b/main/src/main/java/sbt/internal/ClassLoadingLock.java
new file mode 100644
index 000000000..1c5307430
--- /dev/null
+++ b/main/src/main/java/sbt/internal/ClassLoadingLock.java
@@ -0,0 +1,37 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+final class ClassLoadingLock {
+  interface ThrowsClassNotFound<R> {
+    R get() throws ClassNotFoundException;
+  }
+
+  private final ConcurrentHashMap<String, Object> locks = new ConcurrentHashMap<>();
+
+  <R> R withLock(final String name, final ThrowsClassNotFound<R> supplier)
+      throws ClassNotFoundException {
+    final Object newLock = new Object();
+    Object prevLock;
+    synchronized (locks) {
+      prevLock = locks.putIfAbsent(name, newLock);
+    }
+    final Object lock = prevLock == null ? newLock : prevLock;
+    try {
+      synchronized (lock) {
+        return supplier.get();
+      }
+    } finally {
+      synchronized (locks) {
+        locks.remove(name);
+      }
+    }
+  }
+}
diff --git a/main/src/main/java/sbt/internal/FlatLoader.java b/main/src/main/java/sbt/internal/FlatLoader.java
new file mode 100644
index 000000000..203635412
--- /dev/null
+++ b/main/src/main/java/sbt/internal/FlatLoader.java
@@ -0,0 +1,40 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.File;
+import java.net.URL;
+import sbt.util.Logger;
+
+final class FlatLoader extends ManagedClassLoader {
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+
+  FlatLoader(
+      final URL[] urls,
+      final ClassLoader parent,
+      final File file,
+      final boolean close,
+      final boolean allowZombies,
+      final Logger logger) {
+    super(urls, parent, close, allowZombies, logger);
+    setTempDir(file);
+  }
+
+  @Override
+  public String toString() {
+    final StringBuilder jars = new StringBuilder();
+    for (final URL u : getURLs()) {
+      jars.append("    ");
+      jars.append(u);
+      jars.append("\n");
+    }
+    return "FlatLoader(\n  parent = " + getParent() + "\n  jars = " + jars.toString() + ")";
+  }
+}
diff --git a/main/src/main/java/sbt/internal/FullScalaLoader.java b/main/src/main/java/sbt/internal/FullScalaLoader.java
new file mode 100644
index 000000000..fd8d88236
--- /dev/null
+++ b/main/src/main/java/sbt/internal/FullScalaLoader.java
@@ -0,0 +1,36 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+final class FullScalaLoader extends URLClassLoader {
+  private final String jarString;
+
+  FullScalaLoader(final URL[] scalaRest, final URLClassLoader parent) {
+    super(scalaRest, parent);
+    final StringBuilder res = new StringBuilder();
+    int i = 0;
+    while (i < scalaRest.length) {
+      res.append(scalaRest[i].getPath());
+      res.append(", ");
+      i += 1;
+    }
+    jarString = res.toString();
+  }
+
+  @Override
+  public String toString() {
+    return "ScalaClassLoader(jars = " + jarString + ")";
+  }
+
+  static {
+    registerAsParallelCapable();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/JLineLoader.java b/main/src/main/java/sbt/internal/JLineLoader.java
new file mode 100644
index 000000000..098b21bc9
--- /dev/null
+++ b/main/src/main/java/sbt/internal/JLineLoader.java
@@ -0,0 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+class JLineLoader extends URLClassLoader {
+  JLineLoader(final URL[] urls, final ClassLoader parent) {
+    super(urls, parent);
+  }
+
+  @Override
+  public String toString() {
+    final StringBuilder result = new StringBuilder();
+    result.append("JLineLoader(");
+    final URL[] urls = getURLs();
+    for (int i = 0; i < urls.length; ++i) {
+      result.append(urls[i].toString());
+      if (i < urls.length - 1) result.append(", ");
+    }
+    result.append(")");
+    return result.toString();
+  }
+
+  static {
+    registerAsParallelCapable();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/LayeredClassLoader.java b/main/src/main/java/sbt/internal/LayeredClassLoader.java
new file mode 100644
index 000000000..457881816
--- /dev/null
+++ b/main/src/main/java/sbt/internal/LayeredClassLoader.java
@@ -0,0 +1,29 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.File;
+import java.net.URL;
+import sbt.util.Logger;
+
+final class LayeredClassLoader extends ManagedClassLoader {
+  LayeredClassLoader(
+      final URL[] classpath,
+      final ClassLoader parent,
+      final File tempDir,
+      final boolean close,
+      final boolean allowZombies,
+      final Logger logger) {
+    super(classpath, parent, close, allowZombies, logger);
+    setTempDir(tempDir);
+  }
+
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/ManagedClassLoader.java b/main/src/main/java/sbt/internal/ManagedClassLoader.java
new file mode 100644
index 000000000..048572fc0
--- /dev/null
+++ b/main/src/main/java/sbt/internal/ManagedClassLoader.java
@@ -0,0 +1,125 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
+import sbt.util.Logger;
+
+abstract class ManagedClassLoader extends URLClassLoader implements NativeLoader {
+  private final AtomicBoolean closed = new AtomicBoolean(false);
+  private final AtomicBoolean printedWarning = new AtomicBoolean(false);
+  private final AtomicReference<ZombieClassLoader> zombieLoader = new AtomicReference<>();
+  private final boolean close;
+  private final boolean allowZombies;
+  private final Logger logger;
+  private final NativeLookup nativeLookup = new NativeLookup();
+
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+
+  ManagedClassLoader(
+      final URL[] urls,
+      final ClassLoader parent,
+      final boolean close,
+      final boolean allowZombies,
+      final Logger logger) {
+    super(urls, parent);
+    this.close = close;
+    this.allowZombies = allowZombies;
+    this.logger = logger;
+  }
+
+  private class ZombieClassLoader extends URLClassLoader {
+    private final URL[] urls;
+
+    ZombieClassLoader(URL[] urls) {
+      super(urls, ManagedClassLoader.this.getParent());
+      this.urls = urls;
+    }
+
+    Class<?> lookupClass(final String name) throws ClassNotFoundException {
+      try {
+        synchronized (getClassLoadingLock(name)) {
+          final Class<?> previous = findLoadedClass(name);
+          return previous != null ? previous : findClass(name);
+        }
+      } catch (final ClassNotFoundException e) {
+        final StringBuilder builder = new StringBuilder();
+        for (final URL u : urls) {
+          final File f = new File(u.getPath());
+          if (f.exists()) builder.append(f.toString()).append('\n');
+        }
+        final String deleted = builder.toString();
+        if (!deleted.isEmpty()) {
+          final String msg =
+              "Couldn't load class $name. "
+                  + "The following urls on the classpath do not exist:\n"
+                  + deleted
+                  + "This may be due to shutdown hooks added during an invocation of `run`.";
+          System.err.println(msg);
+        }
+        throw e;
+      }
+    }
+  }
+
+  private ZombieClassLoader getZombieLoader(final String name) {
+    if (printedWarning.compareAndSet(false, true) && !allowZombies) {
+      final String msg =
+          (Thread.currentThread() + " loading " + name + " after test or run ")
+              + "has completed. This is a likely resource leak";
+      logger.warn((Supplier<String>) () -> msg);
+    }
+    final ZombieClassLoader maybeLoader = zombieLoader.get();
+    if (maybeLoader != null) return maybeLoader;
+    else {
+      final ZombieClassLoader zb = new ZombieClassLoader(getURLs());
+      zombieLoader.set(zb);
+      return zb;
+    }
+  }
+
+  @Override
+  public URL findResource(String name) {
+    return closed.get() ? getZombieLoader(name).findResource(name) : super.findResource(name);
+  }
+
+  @Override
+  protected Class<?> findClass(String name) throws ClassNotFoundException {
+    try {
+      return super.findClass(name);
+    } catch (final NoClassDefFoundError | ClassNotFoundException e) {
+      if (closed.get()) return getZombieLoader(name).lookupClass(name);
+      else throw e;
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    final ZombieClassLoader zb = zombieLoader.getAndSet(null);
+    if (zb != null && close) zb.close();
+    if (close && closed.compareAndSet(false, true)) super.close();
+  }
+
+  @Override
+  public String findLibrary(final String name) {
+    return nativeLookup.findLibrary(name);
+  }
+
+  @Override
+  public void setTempDir(final File file) {
+    nativeLookup.setTempDir(file);
+  }
+}
diff --git a/main/src/main/java/sbt/internal/MetaBuildLoader.java b/main/src/main/java/sbt/internal/MetaBuildLoader.java
new file mode 100644
index 000000000..f9cc8b9c7
--- /dev/null
+++ b/main/src/main/java/sbt/internal/MetaBuildLoader.java
@@ -0,0 +1,172 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.regex.Pattern;
+import xsbti.AppProvider;
+import xsbti.ScalaProvider;
+
+@SuppressWarnings("unused")
+public final class MetaBuildLoader extends URLClassLoader {
+  private final URLClassLoader fullScalaLoader;
+  private final URLClassLoader libraryLoader;
+  private final URLClassLoader interfaceLoader;
+  private final URLClassLoader jlineLoader;
+
+  MetaBuildLoader(
+      final URL[] urls,
+      final URLClassLoader fullScalaLoader,
+      final URLClassLoader libraryLoader,
+      final URLClassLoader interfaceLoader,
+      final URLClassLoader jlineLoader) {
+    super(urls, fullScalaLoader);
+    this.fullScalaLoader = fullScalaLoader;
+    this.libraryLoader = libraryLoader;
+    this.interfaceLoader = interfaceLoader;
+    this.jlineLoader = jlineLoader;
+  }
+
+  @Override
+  public String toString() {
+    return "SbtMetaBuildClassLoader";
+  }
+
+  @Override
+  public void close() throws IOException {
+    super.close();
+    fullScalaLoader.close();
+    libraryLoader.close();
+    interfaceLoader.close();
+    jlineLoader.close();
+  }
+
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+
+  /**
+   * Rearrange the classloaders so that test-interface is above the scala library. Implemented
+   * without using the scala standard library to minimize classloading.
+   *
+   * @param appProvider the appProvider that needs to be modified
+   * @return a ClassLoader with a URLClassLoader for the test-interface-1.0.jar above the scala
+   *     library.
+   */
+  public static MetaBuildLoader makeLoader(final AppProvider appProvider) throws IOException {
+    final String jlineJars = "jline-?[0-9.]+-sbt-.*|jline-terminal(-(jna|jansi))?-[0-9.]+";
+    final String testInterfaceJars = "test-interface-[0-9.]+";
+    final String compilerInterfaceJars = "compiler-interface(-.*)?";
+    final String jansiJars = "jansi-[0-9.]+";
+    final String jnaJars = "jna-(platform-)?[0-9.]+";
+    final String fullPattern =
+        String.format(
+            "^(%s|%s|%s|%s|%s)\\.jar",
+            jlineJars, testInterfaceJars, compilerInterfaceJars, jansiJars, jnaJars);
+    final Pattern pattern = Pattern.compile(fullPattern);
+    final File[] cp = appProvider.mainClasspath();
+    final URL[] interfaceURLs = new URL[2];
+    final URL[] jlineURLs = new URL[7];
+    final File[] extra =
+        appProvider.id().classpathExtra() == null ? new File[0] : appProvider.id().classpathExtra();
+    final Set<File> bottomClasspath = new LinkedHashSet<>();
+
+    {
+      int interfaceIndex = 0;
+      int jlineIndex = 0;
+      for (final File file : cp) {
+        final String name = file.getName();
+        if ((name.contains("test-interface") || name.contains("compiler-interface"))
+            && pattern.matcher(name).find()) {
+          interfaceURLs[interfaceIndex] = file.toURI().toURL();
+          interfaceIndex += 1;
+        } else if (pattern.matcher(name).find()) {
+          jlineURLs[jlineIndex] = file.toURI().toURL();
+          jlineIndex += 1;
+        } else {
+          bottomClasspath.add(file);
+        }
+      }
+      for (final File file : extra) {
+        bottomClasspath.add(file);
+      }
+    }
+    final URL[] rest = new URL[bottomClasspath.size()];
+    {
+      int i = 0;
+      for (final File file : bottomClasspath) {
+        rest[i] = file.toURI().toURL();
+        i += 1;
+      }
+    }
+    final ScalaProvider scalaProvider = appProvider.scalaProvider();
+    ClassLoader topLoader = scalaProvider.launcher().topLoader();
+    boolean foundSBTLoader = false;
+    while (!foundSBTLoader && topLoader != null) {
+      if (topLoader instanceof URLClassLoader) {
+        for (final URL u : ((URLClassLoader) topLoader).getURLs()) {
+          if (u.toString().contains("test-interface")) {
+            topLoader = topLoader.getParent();
+            foundSBTLoader = true;
+          }
+        }
+      }
+      if (!foundSBTLoader) topLoader = topLoader.getParent();
+    }
+    if (topLoader == null) topLoader = scalaProvider.launcher().topLoader();
+    // the bundled version of jansi with old versions of the launcher cause
+    // problems so we need to exclude it from classloading
+    topLoader =
+        new ClassLoader(topLoader) {
+          @Override
+          protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+            if (name.startsWith("org.fusesource")) throw new ClassNotFoundException(name);
+            return super.loadClass(name, resolve);
+          }
+
+          @Override
+          public String toString() {
+            return "JansiExclusionClassLoader";
+          }
+        };
+
+    final SbtInterfaceLoader interfaceLoader = new SbtInterfaceLoader(interfaceURLs, topLoader);
+    final JLineLoader jlineLoader = new JLineLoader(jlineURLs, interfaceLoader);
+    final File[] siJars = scalaProvider.jars();
+    final URL[] lib = new URL[1];
+    int scalaRestCount = siJars.length - 1;
+    for (final File file : siJars) {
+      if (pattern.matcher(file.getName()).find()) scalaRestCount -= 1;
+    }
+    final URL[] scalaRest = new URL[Math.max(0, scalaRestCount)];
+
+    {
+      int i = 0;
+      int j = 0; // index into scalaRest
+      while (i < siJars.length) {
+        final File file = siJars[i];
+        if (file.getName().equals("scala-library.jar")) {
+          lib[0] = file.toURI().toURL();
+        } else if (!pattern.matcher(file.getName()).find()) {
+          scalaRest[j] = file.toURI().toURL();
+          j += 1;
+        }
+        i += 1;
+      }
+    }
+    assert lib[0] != null : "no scala-library.jar";
+    final ScalaLibraryClassLoader libraryLoader = new ScalaLibraryClassLoader(lib, jlineLoader);
+    final FullScalaLoader fullScalaLoader = new FullScalaLoader(scalaRest, libraryLoader);
+    return new MetaBuildLoader(rest, fullScalaLoader, libraryLoader, interfaceLoader, jlineLoader);
+  }
+}
diff --git a/main/src/main/java/sbt/internal/ReverseLookupClassLoader.java b/main/src/main/java/sbt/internal/ReverseLookupClassLoader.java
new file mode 100644
index 000000000..c2c0d5088
--- /dev/null
+++ b/main/src/main/java/sbt/internal/ReverseLookupClassLoader.java
@@ -0,0 +1,143 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import sbt.util.Logger;
+
+/**
+ * A ClassLoader for the dependency layer of a run or test task. It is almost a normal
+ * URLClassLoader except that it has the ability to look one level down the classloading hierarchy
+ * to load a class via reflection that is not directly available to it. The ClassLoader that is
+ * below it in the hierarchy must be registered via setDescendant. If it ever loads a class from its
+ * descendant, then it cannot be used in a subsequent run because it will not be possible to reload
+ * that class.
+ *
+ * <p>The descendant classloader checks it in and out via [[checkout]] and [[checkin]]. When it
+ * returns the loader via [[checkin]], if the loader is dirty, we close it. Otherwise we cache it if
+ * there is no existing cache entry.
+ *
+ * <p>Performance degrades if loadClass is constantly looking back up to the provided
+ * BottomClassLoader so we provide an alternate loadClass definition that takes a reverseLookup
+ * boolean parameter. Because the [[BottomClassLoader]] knows what loader is calling into, when it
+ * delegates its search to the ReverseLookupClassLoader, it passes false for the reverseLookup flag.
+ * By default the flag is true. Most of the time, the default loadClass will only be invoked by java
+ * reflection calls. Even then, there's some chance that the class being loaded by java reflection
+ * is _not_ available on the bottom classpath so it is not guaranteed that performing the reverse
+ * lookup will invalidate this loader.
+ */
+final class ReverseLookupClassLoader extends ManagedClassLoader {
+  ReverseLookupClassLoader(
+      final URL[] urls,
+      final ClassLoader parent,
+      final boolean close,
+      final boolean allowZombies,
+      final Logger logger) {
+    super(urls, parent, close, allowZombies, logger);
+    this.parent = parent;
+  }
+
+  private final AtomicReference<BottomClassLoader> directDescendant = new AtomicReference<>();
+  private final AtomicBoolean dirty = new AtomicBoolean(false);
+  private final ClassLoadingLock classLoadingLock = new ClassLoadingLock();
+  private final ClassLoader parent;
+
+  boolean isDirty() {
+    return dirty.get();
+  }
+
+  void setDescendant(final BottomClassLoader bottomClassLoader) {
+    directDescendant.set(bottomClassLoader);
+  }
+
+  @Override
+  public URL findResource(String name) {
+    final URL url = super.findResource(name);
+    return url != null ? url : directDescendant.get().findResource(name);
+  }
+
+  @Override
+  public Enumeration<URL> findResources(String name) throws IOException {
+    final Enumeration<URL> parentResources = super.findResources(name);
+
+    if (directDescendant.get() == null) {
+      return parentResources;
+    }
+
+    final Enumeration<URL> directDescendantResources = directDescendant.get().findResources(name);
+    return new Enumeration<URL>() {
+      @Override
+      public boolean hasMoreElements() {
+        return parentResources.hasMoreElements() || directDescendantResources.hasMoreElements();
+      }
+
+      @Override
+      public URL nextElement() {
+        if (parentResources.hasMoreElements()) {
+          return parentResources.nextElement();
+        }
+        return directDescendantResources.nextElement();
+      }
+    };
+  }
+
+  void setup(final File tmpDir) {
+    setTempDir(tmpDir);
+  }
+
+  @Override
+  protected Class<?> loadClass(final String name, final boolean resolve)
+      throws ClassNotFoundException {
+    return loadClass(name, resolve, true);
+  }
+
+  Class<?> loadClass(final String name, final boolean resolve, final boolean childLookup)
+      throws ClassNotFoundException {
+    Class<?> result;
+    try {
+      result = parent.loadClass(name);
+    } catch (final ClassNotFoundException e) {
+      result = findClass(name, childLookup);
+    }
+    if (result == null) throw new ClassNotFoundException(name);
+    if (resolve) resolveClass(result);
+    return result;
+  }
+
+  private Class<?> findClass(final String name, final boolean childLookup)
+      throws ClassNotFoundException {
+    return classLoadingLock.withLock(
+        name,
+        () -> {
+          try {
+            final Class<?> prev = findLoadedClass(name);
+            if (prev != null) return prev;
+            return findClass(name);
+          } catch (final ClassNotFoundException e) {
+            if (childLookup) {
+              final BottomClassLoader loader = directDescendant.get();
+              if (loader == null) throw e;
+              final Class<?> clazz = loader.findClass(name);
+              dirty.set(true);
+              return clazz;
+            } else {
+              throw e;
+            }
+          }
+        });
+  }
+
+  static {
+    registerAsParallelCapable();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/SbtInterfaceLoader.java b/main/src/main/java/sbt/internal/SbtInterfaceLoader.java
new file mode 100644
index 000000000..27199529a
--- /dev/null
+++ b/main/src/main/java/sbt/internal/SbtInterfaceLoader.java
@@ -0,0 +1,27 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+// This ClassLoader must contain pure  sbt java interfaces
+class SbtInterfaceLoader extends URLClassLoader {
+  SbtInterfaceLoader(final URL[] urls, final ClassLoader parent) {
+    super(urls, parent);
+  }
+
+  @Override
+  public String toString() {
+    return "SbtInterfaceClassLoader(" + getURLs()[0] + ")";
+  }
+
+  static {
+    registerAsParallelCapable();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/ScalaLibraryClassLoader.java b/main/src/main/java/sbt/internal/ScalaLibraryClassLoader.java
new file mode 100644
index 000000000..6fe4403a6
--- /dev/null
+++ b/main/src/main/java/sbt/internal/ScalaLibraryClassLoader.java
@@ -0,0 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+final class ScalaLibraryClassLoader extends URLClassLoader {
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+
+  private final URL[] jars;
+
+  ScalaLibraryClassLoader(final URL[] jars, final ClassLoader parent) {
+    super(jars, parent);
+    this.jars = jars;
+  }
+
+  @Override
+  public String toString() {
+    final StringBuilder builder = new StringBuilder();
+    for (int i = 0; i < jars.length; ++i) {
+      builder.append(jars[i].toString());
+      if (i < jars.length - 2) builder.append(", ");
+    }
+    return "ScalaLibraryClassLoader(" + builder + " parent = " + getParent() + ")";
+  }
+}
diff --git a/main/src/main/java/sbt/internal/ScalaReflectClassLoader.java b/main/src/main/java/sbt/internal/ScalaReflectClassLoader.java
new file mode 100644
index 000000000..b8a3fff17
--- /dev/null
+++ b/main/src/main/java/sbt/internal/ScalaReflectClassLoader.java
@@ -0,0 +1,29 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+final class ScalaReflectClassLoader extends URLClassLoader {
+  static {
+    ClassLoader.registerAsParallelCapable();
+  }
+
+  private final URL jar;
+
+  ScalaReflectClassLoader(final URL jar, final ClassLoader parent) {
+    super(new URL[] {jar}, parent);
+    this.jar = jar;
+  }
+
+  @Override
+  public String toString() {
+    return "ScalaReflectClassLoader(" + jar + " parent = " + getParent() + ")";
+  }
+}
diff --git a/main/src/main/java/sbt/internal/XMainClassLoader.java b/main/src/main/java/sbt/internal/XMainClassLoader.java
new file mode 100644
index 000000000..2668a5db7
--- /dev/null
+++ b/main/src/main/java/sbt/internal/XMainClassLoader.java
@@ -0,0 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+class XMainClassLoader extends URLClassLoader {
+  XMainClassLoader(final URL[] urls, final ClassLoader parent) {
+    super(urls, parent);
+  }
+
+  @Override
+  protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+    if (name.startsWith("sbt.internal.XMainConfiguration")) {
+      synchronized (getClassLoadingLock(name)) {
+        Class<?> result = findLoadedClass(name);
+        if (result == null) result = findClass(name);
+        if (resolve) resolveClass(result);
+        return result;
+      }
+    }
+    return super.loadClass(name, resolve);
+  }
+
+  static {
+    registerAsParallelCapable();
+  }
+}
diff --git a/main/src/main/java/sbt/internal/XMainConfiguration.java b/main/src/main/java/sbt/internal/XMainConfiguration.java
new file mode 100644
index 000000000..9cebe23af
--- /dev/null
+++ b/main/src/main/java/sbt/internal/XMainConfiguration.java
@@ -0,0 +1,299 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import xsbti.*;
+
+/**
+ * Generates a new app configuration and invokes xMainImpl.run. For AppConfigurations generated by
+ * recent launchers, it is unnecessary to modify the original configuration, but configurations
+ * generated by older launchers need to be modified to place the test interface jar higher in the
+ * class hierarchy. The methods this object are implemented without using the scala library so that
+ * we can avoid loading any classes from the old scala provider.
+ */
+public class XMainConfiguration {
+  public xsbti.MainResult run(String moduleName, xsbti.AppConfiguration configuration) {
+    try {
+      ClassLoader topLoader = configuration.provider().scalaProvider().launcher().topLoader();
+      xsbti.AppConfiguration updatedConfiguration = null;
+      try {
+        Method method = topLoader.getClass().getMethod("getJLineJars");
+        URL[] jars = (URL[]) method.invoke(topLoader);
+        boolean canReuseConfiguration = jars.length == 3;
+        int j = 0;
+        while (j < jars.length && canReuseConfiguration) {
+          String s = jars[j].toString();
+          canReuseConfiguration = s.contains("jline") || s.contains("jansi");
+          j += 1;
+        }
+        if (canReuseConfiguration && j == 3) {
+          updatedConfiguration = configuration;
+        } else {
+          updatedConfiguration = makeConfiguration(configuration);
+        }
+      } catch (NoSuchMethodException e) {
+        updatedConfiguration = makeConfiguration(configuration);
+      }
+
+      ClassLoader loader = updatedConfiguration.provider().loader();
+      Thread.currentThread().setContextClassLoader(loader);
+      Class<?> clazz = loader.loadClass("sbt." + moduleName + "$");
+      Object instance = clazz.getField("MODULE$").get(null);
+      Method runMethod = clazz.getMethod("run", xsbti.AppConfiguration.class);
+      try {
+        Class<?> clw = loader.loadClass("sbt.internal.ClassLoaderWarmup$");
+        clw.getMethod("warmup").invoke(clw.getField("MODULE$").get(null));
+        return (xsbti.MainResult) runMethod.invoke(instance, updatedConfiguration);
+      } catch (InvocationTargetException e) {
+        // This propogates xsbti.FullReload to the launcher
+        throw (xsbti.FullReload) e.getCause();
+      }
+    } catch (ReflectiveOperationException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private xsbti.AppConfiguration makeConfiguration(xsbti.AppConfiguration configuration) {
+    try {
+      ClassLoader baseLoader = XMainConfiguration.class.getClassLoader();
+      String className = "sbt/internal/XMainConfiguration.class";
+      URL url = baseLoader.getResource(className);
+      String path = url.toString().replaceAll(className.concat("$"), "");
+      URL[] urlArray = new URL[1];
+      urlArray[0] = new URL(path);
+      ClassLoader topLoader = configuration.provider().scalaProvider().launcher().topLoader();
+      // This loader doesn't have the scala library in it so it's critical that none of the code
+      // in this file use the scala library.
+      ClassLoader modifiedLoader = new XMainClassLoader(urlArray, topLoader);
+      Class<?> xMainConfigurationClass =
+          modifiedLoader.loadClass("sbt.internal.XMainConfiguration");
+      Object instance = (Object) xMainConfigurationClass.getConstructor().newInstance();
+      Class<?> metaBuildLoaderClass = modifiedLoader.loadClass("sbt.internal.MetaBuildLoader");
+      Method method = metaBuildLoaderClass.getMethod("makeLoader", AppProvider.class);
+
+      ClassLoader loader = (ClassLoader) method.invoke(null, configuration.provider());
+
+      Thread.currentThread().setContextClassLoader(loader);
+      Class<?> modifiedConfigurationClass =
+          modifiedLoader.loadClass("sbt.internal.XMainConfiguration$ModifiedConfiguration");
+      Constructor<?> cons = modifiedConfigurationClass.getConstructors()[0];
+      ClassLoaderClose.close(configuration.provider().loader());
+      ScalaProvider scalaProvider = configuration.provider().scalaProvider();
+      Class<? extends ScalaProvider> providerClass = scalaProvider.getClass();
+      try {
+        Method method2 = providerClass.getMethod("loaderLibraryOnly");
+        ClassLoaderClose.close((ClassLoader) method2.invoke(scalaProvider));
+      } catch (NoSuchMethodException e) {
+      }
+      ClassLoaderClose.close(scalaProvider.loader());
+      ClassLoaderClose.close(configuration.provider().loader());
+      return (xsbti.AppConfiguration) cons.newInstance(instance, configuration, loader);
+    } catch (Throwable e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /*
+   * Replaces the AppProvider.loader method with a new loader that puts the sbt test interface
+   * jar ahead of the rest of the sbt classpath in the classloading hierarchy.
+   */
+  public class ModifiedConfiguration implements xsbti.AppConfiguration {
+    private xsbti.AppConfiguration configuration;
+    private ClassLoader metaLoader;
+
+    public ModifiedConfiguration(xsbti.AppConfiguration configuration, ClassLoader metaLoader) {
+      this.configuration = configuration;
+      this.metaLoader = metaLoader;
+    }
+
+    public class ModifiedAppProvider implements AppProvider {
+      private AppProvider appProvider;
+      private ScalaProvider instance;
+
+      public ModifiedAppProvider(AppProvider appProvider) throws ClassNotFoundException {
+        this.appProvider = appProvider;
+        ScalaProvider delegate = configuration.provider().scalaProvider();
+        this.instance =
+            new ScalaProvider() {
+              public Launcher _launcher =
+                  new Launcher() {
+                    private Launcher delegateLauncher = delegate.launcher();
+                    private ClassLoader interfaceLoader =
+                        metaLoader.loadClass("sbt.testing.Framework").getClassLoader();
+
+                    @Override
+                    public ScalaProvider getScala(String version) {
+                      return getScala(version, "");
+                    }
+
+                    @Override
+                    public ScalaProvider getScala(String version, String reason) {
+                      return getScala(version, reason, "org.scala-lang");
+                    }
+
+                    @Override
+                    public ScalaProvider getScala(String version, String reason, String scalaOrg) {
+                      return delegateLauncher.getScala(version, reason, scalaOrg);
+                    }
+
+                    @Override
+                    public AppProvider app(xsbti.ApplicationID id, String version) {
+                      return delegateLauncher.app(id, version);
+                    }
+
+                    @Override
+                    public ClassLoader topLoader() {
+                      return interfaceLoader;
+                    }
+
+                    @Override
+                    public GlobalLock globalLock() {
+                      return delegateLauncher.globalLock();
+                    }
+
+                    @Override
+                    public File bootDirectory() {
+                      return delegateLauncher.bootDirectory();
+                    }
+
+                    @Override
+                    public xsbti.Repository[] ivyRepositories() {
+                      return delegateLauncher.ivyRepositories();
+                    }
+
+                    @Override
+                    public xsbti.Repository[] appRepositories() {
+                      return delegateLauncher.appRepositories();
+                    }
+
+                    @Override
+                    public boolean isOverrideRepositories() {
+                      return delegateLauncher.isOverrideRepositories();
+                    }
+
+                    @Override
+                    public File ivyHome() {
+                      return delegateLauncher.ivyHome();
+                    }
+
+                    @Override
+                    public String[] checksums() {
+                      return delegateLauncher.checksums();
+                    }
+                  };
+
+              @Override
+              public Launcher launcher() {
+                return this._launcher;
+              }
+
+              @Override
+              public String version() {
+                return delegate.version();
+              }
+
+              @Override
+              public ClassLoader loader() {
+                return metaLoader.getParent();
+              }
+
+              @Override
+              public File[] jars() {
+                return delegate.jars();
+              }
+
+              @Override
+              @Deprecated()
+              public File libraryJar() {
+                return delegate.libraryJar();
+              }
+
+              @Override
+              @Deprecated()
+              public File compilerJar() {
+                return delegate.compilerJar();
+              }
+
+              @Override
+              public AppProvider app(xsbti.ApplicationID id) {
+                return delegate.app(id);
+              }
+
+              private ClassLoader loaderLibraryOnly() {
+                return metaLoader.getParent().getParent();
+              }
+            };
+      }
+
+      @Override
+      public ScalaProvider scalaProvider() {
+        return instance;
+      }
+
+      @Override
+      public xsbti.ApplicationID id() {
+        return appProvider.id();
+      }
+
+      @Override
+      public ClassLoader loader() {
+        return metaLoader;
+      }
+
+      @Override
+      @Deprecated()
+      public Class<? extends AppMain> mainClass() {
+        return appProvider.mainClass();
+      }
+
+      @Override
+      public Class<?> entryPoint() {
+        return appProvider.entryPoint();
+      }
+
+      @Override
+      public AppMain newMain() {
+        return appProvider.newMain();
+      }
+
+      @Override
+      public File[] mainClasspath() {
+        return appProvider.mainClasspath();
+      }
+
+      @Override
+      public ComponentProvider components() {
+        return appProvider.components();
+      }
+    }
+
+    @Override
+    public String[] arguments() {
+      return configuration.arguments();
+    }
+
+    @Override
+    public File baseDirectory() {
+      return configuration.baseDirectory();
+    }
+
+    @Override
+    public AppProvider provider() {
+      try {
+        return new ModifiedAppProvider(configuration.provider());
+      } catch (Throwable e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+}
diff --git a/main/src/main/resources/graph.html b/main/src/main/resources/graph.html
new file mode 100644
index 000000000..b8c4a45b2
--- /dev/null
+++ b/main/src/main/resources/graph.html
@@ -0,0 +1,115 @@
+<!doctype html>
+
+<!--
+
+Based on https://github.com/cpettitt/dagre-d3/blob/d215446e7e40ebfca303f4733e746e96420e3b46/demo/interactive-demo.html
+which is published under this license:
+
+Copyright (c) 2013 Chris Pettitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+-->
+
+<meta charset="utf-8">
+<title>Dependency Graph</title>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.17/d3.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/dagre-d3/0.4.16/dagre-d3.min.js"></script>
+<script src="https://dagrejs.github.io/project/graphlib-dot/v0.6.3/graphlib-dot.min.js"></script>
+<script src="dependencies.dot.js"></script>
+
+<style>
+    body {
+        margin: 0;
+        overflow: hidden;
+    }
+    .node {
+        white-space: nowrap;
+    }
+
+    .node rect,
+    .node circle,
+    .node ellipse {
+        stroke: #333;
+        fill: #fff;
+        stroke-width: 1.5px;
+    }
+
+    .cluster rect {
+        stroke: #333;
+        fill: #000;
+        fill-opacity: 0.1;
+        stroke-width: 1.5px;
+    }
+
+    .edgePath path.path {
+        stroke: #333;
+        stroke-width: 1.5px;
+        fill: none;
+    }
+</style>
+
+<style>
+    h1, h2 {
+        color: #333;
+    }
+</style>
+
+<body onLoad="initialize()">
+
+<svg width=1280 height=1024>
+    <g/>
+</svg>
+
+<script>
+function initialize() {
+    // Set up zoom support
+    var svg = d3.select("svg"),
+        inner = d3.select("svg g"),
+        zoom = d3.behavior.zoom().on("zoom", function() {
+          inner.attr("transform", "translate(" + d3.event.translate + ")" +
+                                      "scale(" + d3.event.scale + ")");
+        });
+    svg.attr("width", window.innerWidth);
+
+    svg.call(zoom);
+    // Create and configure the renderer
+    var render = dagreD3.render();
+    function tryDraw(inputGraph) {
+      var g;
+      {
+        g = graphlibDot.read(inputGraph);
+        g.graph().rankdir = "LR";
+        d3.select("svg g").call(render, g);
+
+        // Center the graph
+        var initialScale = 0.10;
+        zoom
+          .translate([(svg.attr("width") - g.graph().width * initialScale) / 2, 20])
+          .scale(initialScale)
+          .event(svg);
+        svg.attr('height', g.graph().height * initialScale + 40);
+      }
+    }
+    tryDraw(decodeURIComponent(data));
+}
+</script>
+</body>
diff --git a/main/src/main/resources/tree.html b/main/src/main/resources/tree.html
new file mode 100644
index 000000000..909a9b82e
--- /dev/null
+++ b/main/src/main/resources/tree.html
@@ -0,0 +1,49 @@
+<!doctype html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>dependencyBrowseTree</title>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.17/d3.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jstree/3.2.1/jstree.min.js"></script>
+    <script src="tree.data.js"></script>
+
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/jstree/3.2.1/themes/default/style.min.css"/>
+
+    <style>
+        #input-field {
+            display: inline;
+        }
+        #tree_div {
+            font-family: monospace
+        }
+    </style>
+</head>
+<body>
+<h1>Dependencies</h1>
+Search: <input type="search" id="input-field" value="">
+<div id="tree_div" class="jstree-no-icons"></div>
+
+<script>
+$(function() {
+    $('#tree_div').jstree({
+        "plugins": ["search", "sort"],
+        "core": {
+            "data": tree_data
+        }
+    });
+    var to = false;
+    $('#input-field').keyup(function() {
+        if (to) {
+            clearTimeout(to);
+        }
+        to = setTimeout(function() {
+            var v = $('#input-field').val();
+            $('#tree_div').jstree(true).search(v);
+        }, 250);
+    });
+});
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/main/src/main/scala/sbt/BackgroundJobService.scala b/main/src/main/scala/sbt/BackgroundJobService.scala
new file mode 100644
index 000000000..1cbff3f2d
--- /dev/null
+++ b/main/src/main/scala/sbt/BackgroundJobService.scala
@@ -0,0 +1,102 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.io.Closeable
+
+import sbt.util.Logger
+import Def.{ Classpath, ScopedKey }
+import sbt.internal.util.complete._
+import java.io.File
+
+import scala.util.control.NonFatal
+import scala.util.{ Failure, Success, Try }
+
+abstract class BackgroundJobService extends Closeable {
+
+  /**
+   * Launch a background job which is a function that runs inside another thread;
+   *  killing the job will interrupt() the thread. If your thread blocks on a process,
+   *  then you should get an InterruptedException while blocking on the process, and
+   *  then you could process.destroy() for example.
+   */
+  def runInBackground(spawningTask: ScopedKey[_], state: State)(
+      start: (Logger, File) => Unit
+  ): JobHandle
+
+  /**
+   * Launch a background job which is a function that runs inside another thread.
+   *  Differs from [[BackgroundJobService.runInBackground]] in that the start task
+   *  provides both an optional classloader and the work to run in the background thread.
+   *  The service should close the classloader when the task completes.
+   *  killing the job will interrupt() the thread. If your thread blocks on a process,
+   *  then you should get an InterruptedException while blocking on the process, and
+   *  then you could process.destroy() for example.
+   */
+  private[sbt] def runInBackgroundWithLoader(spawningTask: ScopedKey[_], state: State)(
+      start: (Logger, File) => (Option[ClassLoader], () => Unit)
+  ): JobHandle = runInBackground(spawningTask, state) { (logger, file) =>
+    start(logger, file)._2.apply()
+  }
+
+  /** Same as shutown. */
+  def close(): Unit
+
+  /** Shuts down all background jobs. */
+  def shutdown(): Unit
+  def jobs: Vector[JobHandle]
+  def stop(job: JobHandle): Unit
+
+  /**
+   * Delegate to waitFor but catches any exceptions and returns the result in an instance of `Try`.
+   * @param job the job to wait for
+   * @return the result of waiting for the job to complete.
+   */
+  def waitForTry(job: JobHandle): Try[Unit] = {
+    try Success(waitFor(job))
+    catch {
+      case NonFatal(e) =>
+        try stop(job)
+        catch { case NonFatal(_) => }
+        Failure(e)
+    }
+  }
+
+  def waitFor(job: JobHandle): Unit
+
+  /** Copies classpath to temporary directories. */
+  def copyClasspath(products: Classpath, full: Classpath, workingDirectory: File): Classpath
+
+  private[sbt] def copyClasspath(
+      products: Classpath,
+      full: Classpath,
+      workingDirectory: File,
+      hashContents: Boolean
+  ): Classpath = copyClasspath(products, full, workingDirectory)
+}
+
+object BackgroundJobService {
+  private[sbt] def jobIdParser: (State, Seq[JobHandle]) => Parser[Seq[JobHandle]] = {
+    import DefaultParsers._
+    (state, handles) => {
+      val stringIdParser: Parser[Seq[String]] = Space ~> token(
+        NotSpace examples handles.map(_.id.toString).toSet,
+        description = "<job id>"
+      ).+
+      stringIdParser.map { strings =>
+        strings.map(Integer.parseInt(_)).flatMap(id => handles.find(_.id == id))
+      }
+    }
+  }
+}
+
+abstract class JobHandle {
+  def id: Long
+  def humanReadableName: String
+  def spawningTask: ScopedKey[_]
+}
diff --git a/main/src/main/scala/sbt/BuildPaths.scala b/main/src/main/scala/sbt/BuildPaths.scala
index a187d01c4..064f50107 100644
--- a/main/src/main/scala/sbt/BuildPaths.scala
+++ b/main/src/main/scala/sbt/BuildPaths.scala
@@ -1,82 +1,133 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
+import java.util.Locale
 import KeyRanks.DSetting
 
 import sbt.io.{ GlobFilter, Path }
 import sbt.internal.util.AttributeKey
-import sbt.util.Logger
 
 object BuildPaths {
-  val globalBaseDirectory = AttributeKey[File]("global-base-directory", "The base directory for global sbt configuration and staging.", DSetting)
-  val globalPluginsDirectory = AttributeKey[File]("global-plugins-directory", "The base directory for global sbt plugins.", DSetting)
-  val globalSettingsDirectory = AttributeKey[File]("global-settings-directory", "The base directory for global sbt settings.", DSetting)
-  val stagingDirectory = AttributeKey[File]("staging-directory", "The directory for staging remote projects.", DSetting)
-  val dependencyBaseDirectory = AttributeKey[File]("dependency-base-directory", "The base directory for caching dependency resolution.", DSetting)
+  val globalBaseDirectory = AttributeKey[File](
+    "global-base-directory",
+    "The base directory for global sbt configuration and staging.",
+    DSetting
+  )
+  val globalPluginsDirectory = AttributeKey[File](
+    "global-plugins-directory",
+    "The base directory for global sbt plugins.",
+    DSetting
+  )
+  val globalSettingsDirectory = AttributeKey[File](
+    "global-settings-directory",
+    "The base directory for global sbt settings.",
+    DSetting
+  )
+  val stagingDirectory =
+    AttributeKey[File]("staging-directory", "The directory for staging remote projects.", DSetting)
+  val dependencyBaseDirectory = AttributeKey[File](
+    "dependency-base-directory",
+    "The base directory for caching dependency resolution.",
+    DSetting
+  )
+
+  val globalZincDirectory =
+    AttributeKey[File]("global-zinc-directory", "The base directory for Zinc internals.", DSetting)
 
   import sbt.io.syntax._
 
   def getGlobalBase(state: State): File = {
     val default = defaultVersionedGlobalBase(binarySbtVersion(state))
-    def getDefault = { checkTransition(state, default); default }
-    getFileSetting(globalBaseDirectory, GlobalBaseProperty, getDefault)(state)
-  }
-  private[this] def checkTransition(state: State, versioned: File): Unit = {
-    val unversioned = defaultGlobalBase
-    def globalDefined(base: File): Boolean =
-      getGlobalPluginsDirectory(state, base).exists ||
-        configurationSources(getGlobalSettingsDirectory(state, base)).exists(_.exists)
-    val warnTransition = !globalDefined(versioned) && globalDefined(unversioned)
-    if (warnTransition)
-      state.log.warn(globalDirTransitionWarning(unversioned, versioned))
+    getFileSetting(globalBaseDirectory, GlobalBaseProperty, default)(state)
   }
 
   def getStagingDirectory(state: State, globalBase: File): File =
     fileSetting(stagingDirectory, StagingProperty, defaultStaging(globalBase))(state)
 
   def getGlobalPluginsDirectory(state: State, globalBase: File): File =
-    fileSetting(globalPluginsDirectory, GlobalPluginsProperty, defaultGlobalPlugins(globalBase))(state)
+    fileSetting(globalPluginsDirectory, GlobalPluginsProperty, defaultGlobalPlugins(globalBase))(
+      state
+    )
 
   def getGlobalSettingsDirectory(state: State, globalBase: File): File =
     fileSetting(globalSettingsDirectory, GlobalSettingsProperty, globalBase)(state)
 
   def getDependencyDirectory(state: State, globalBase: File): File =
-    fileSetting(dependencyBaseDirectory, DependencyBaseProperty, defaultDependencyBase(globalBase))(state)
+    fileSetting(dependencyBaseDirectory, DependencyBaseProperty, defaultDependencyBase(globalBase))(
+      state
+    )
 
-  private[this] def fileSetting(stateKey: AttributeKey[File], property: String, default: File)(state: State): File =
+  def getZincDirectory(state: State, globalBase: File): File =
+    fileSetting(globalZincDirectory, GlobalZincProperty, defaultGlobalZinc(globalBase))(state)
+
+  private[this] def fileSetting(stateKey: AttributeKey[File], property: String, default: File)(
+      state: State
+  ): File =
     getFileSetting(stateKey, property, default)(state)
 
-  def getFileSetting(stateKey: AttributeKey[File], property: String, default: => File)(state: State): File =
+  def getFileSetting(stateKey: AttributeKey[File], property: String, default: => File)(
+      state: State
+  ): File =
     state get stateKey orElse getFileProperty(property) getOrElse default
 
-  def getFileProperty(name: String): Option[File] = Option(System.getProperty(name)) flatMap { path =>
-    if (path.isEmpty) None else Some(new File(path))
+  def getFileProperty(name: String): Option[File] = Option(System.getProperty(name)) flatMap {
+    path =>
+      if (path.isEmpty) None
+      else {
+        if (path.head == '~') {
+          val tildePath = expandTildePrefix(path)
+          Some(new File(tildePath))
+        } else {
+          Some(new File(path))
+        }
+      }
+  }
+
+  def expandTildePrefix(path: String): String = {
+    val tildePath = path.split("\\/").headOption match {
+      case Some("~")  => sys.env.getOrElse("HOME", "")
+      case Some("~+") => sys.env.getOrElse("PWD", "")
+      case Some("~-") => sys.env.getOrElse("OLDPWD", "")
+      case _          => ""
+    }
+
+    path.indexOf("/") match {
+      case -1 => tildePath
+      case _  => tildePath + path.substring(path.indexOf("/"))
+    }
   }
 
   def defaultVersionedGlobalBase(sbtVersion: String): File = defaultGlobalBase / sbtVersion
   def defaultGlobalBase = Path.userHome / ConfigDirectoryName
 
   private[this] def binarySbtVersion(state: State): String =
-    sbt.internal.librarymanagement.cross.CrossVersionUtil.binarySbtVersion(state.configuration.provider.id.version)
+    sbt.internal.librarymanagement.cross.CrossVersionUtil
+      .binarySbtVersion(state.configuration.provider.id.version)
   private[this] def defaultStaging(globalBase: File) = globalBase / "staging"
   private[this] def defaultGlobalPlugins(globalBase: File) = globalBase / PluginsDirectoryName
   private[this] def defaultDependencyBase(globalBase: File) = globalBase / "dependency"
+  private[this] def defaultGlobalZinc(globalBase: File) = globalBase / "zinc"
 
-  def configurationSources(base: File): Seq[File] = (base * (GlobFilter("*.sbt") - ".sbt")).get
+  def configurationSources(base: File): Seq[File] =
+    (base * (GlobFilter("*.sbt") - ".sbt")).get
+      .sortBy(_.getName.toLowerCase(Locale.ENGLISH))
   def pluginDirectory(definitionBase: File) = definitionBase / PluginsDirectoryName
 
   def evalOutputDirectory(base: File) = outputDirectory(base) / "config-classes"
   def outputDirectory(base: File) = base / DefaultTargetName
 
   def projectStandard(base: File) = base / "project"
-
-  @deprecated("Use projectStandard.  The alternative project directory location has been removed.", "0.13.0")
-  def projectHidden(base: File) = projectStandard(base)
-  @deprecated("Use projectStandard.  The alternative project directory location has been removed.", "0.13.0")
-  def selectProjectDir(base: File, log: Logger) = projectStandard(base)
+  def globalLoggingStandard(base: File): File =
+    base.getCanonicalFile / DefaultTargetName / GlobalLogging
+  def globalTaskDirectoryStandard(base: File): File =
+    base.getCanonicalFile / DefaultTargetName / TaskTempDirectory
 
   final val PluginsDirectoryName = "plugins"
   final val DefaultTargetName = "target"
@@ -86,12 +137,10 @@ object BuildPaths {
   final val GlobalPluginsProperty = "sbt.global.plugins"
   final val GlobalSettingsProperty = "sbt.global.settings"
   final val DependencyBaseProperty = "sbt.dependency.base"
+  final val GlobalZincProperty = "sbt.global.zinc"
+  final val GlobalLogging = "global-logging"
+  final val TaskTempDirectory = "task-temp-directory"
 
-  def crossPath(base: File, instance: xsbti.compile.ScalaInstance): File = base / ("scala_" + instance.version)
-
-  private[this] def globalDirTransitionWarning(unversioned: File, versioned: File): String =
-    s"""The global sbt directory is now versioned and is located at $versioned.
-  You are seeing this warning because there is global configuration in $unversioned but not in $versioned.
-  The global sbt directory may be changed via the $GlobalBaseProperty system property.
-"""
+  def crossPath(base: File, instance: xsbti.compile.ScalaInstance): File =
+    base / ("scala_" + instance.version)
 }
diff --git a/main/src/main/scala/sbt/BuildSyntax.scala b/main/src/main/scala/sbt/BuildSyntax.scala
new file mode 100644
index 000000000..b2038c4a3
--- /dev/null
+++ b/main/src/main/scala/sbt/BuildSyntax.scala
@@ -0,0 +1,29 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import sbt.internal.DslEntry
+import sbt.librarymanagement.Configuration
+
+private[sbt] trait BuildSyntax {
+  import scala.language.experimental.macros
+  def settingKey[T](description: String): SettingKey[T] = macro std.KeyMacro.settingKeyImpl[T]
+  def taskKey[T](description: String): TaskKey[T] = macro std.KeyMacro.taskKeyImpl[T]
+  def inputKey[T](description: String): InputKey[T] = macro std.KeyMacro.inputKeyImpl[T]
+
+  def enablePlugins(ps: AutoPlugin*): DslEntry = DslEntry.DslEnablePlugins(ps)
+  def disablePlugins(ps: AutoPlugin*): DslEntry = DslEntry.DslDisablePlugins(ps)
+  def configs(cs: Configuration*): DslEntry = DslEntry.DslConfigs(cs)
+  def dependsOn(deps: ClasspathDep[ProjectReference]*): DslEntry = DslEntry.DslDependsOn(deps)
+  // avoid conflict with `sbt.Keys.aggregate`
+  def aggregateProjects(refs: ProjectReference*): DslEntry = DslEntry.DslAggregate(refs)
+
+  implicit def sbtStateToUpperStateOps(s: State): UpperStateOps =
+    new UpperStateOps.UpperStateOpsImpl(s)
+}
+private[sbt] object BuildSyntax extends BuildSyntax
diff --git a/main/src/main/scala/sbt/ClassLoaderLayeringStrategy.scala b/main/src/main/scala/sbt/ClassLoaderLayeringStrategy.scala
new file mode 100644
index 000000000..cfb360fc4
--- /dev/null
+++ b/main/src/main/scala/sbt/ClassLoaderLayeringStrategy.scala
@@ -0,0 +1,100 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+/**
+ * Represents a ClassLoader layering strategy. By providing an instance of [[ClassLoaderLayeringStrategy]],
+ * users can configure the strategy that they want to use in various sbt tasks, most importantly
+ * [[Keys.run]] and [[Keys.test]]. This setting is only relevant if fork := false in the task for
+ * which we obtain a ClassLoaderLayeringStrategy.
+ *
+ * ClassLoaders can be composed of multiple ClassLoaders
+ * to form a graph for loading a class. The different portions of the graph may be cached and
+ * reused to minimize both the memory taken up by ClassLoaders (and the classes that they load) and
+ * the startup time for tasks like test and run. For example, the scala library is large and takes
+ * a while just to load the classes in predef. The [[Keys.scalaInstance]] task provides access to
+ * a classloader that can load all of the java bootstrap classes and scala.*. Supposing that we want
+ * to run code in a jar containing scala code called "foo_2.12.jar" in the base directory and that
+ * we have a scala instance in scope and suppose further that "foo_2.12.jar" contains a main method
+ * in the class foo.Main, then we can invoke foo.Main.main like so
+ *
+ * {{{
+ *   val fooJarFile = new File("foo_2.12.jar")
+ *   val classLoader = new URLClassLoader(
+ *     Array(fooJarFile.toURI.toURL), scalaInstance.loaderLibraryOnly)
+ *   val main = classLoader.loadClass("foo.Main").getDeclaredMethod("main", classOf[Array[String]])
+ *   main.invoke(null, Array.empty[String])
+ * }}}
+ *
+ * Now suppose that we have an alternative jar "foo_alt_2.12.jar" that also provides foo.Main, then
+ * we can run that main method:
+ *
+ * {{{
+ *   val fooJarFile = new File("foo_alt_2.12.jar")
+ *   val altClassLoader = new URLClassLoader(
+ *     Array(fooAltJarFile.toURI.toURL), scalaInstance.loaderLibraryOnly)
+ *   val altMain = classLoader.loadClass("foo.Main").getDeclaredMethod("main", classOf[Array[String]])
+ *   altMain.invoke(null, Array.empty[String])
+ * }}}
+ *
+ * In the second invocation, the scala library will have already been loaded by the
+ * scalaInstance.loaderLibraryOnly ClassLoader. This can reduce the startup time by O(500ms) and
+ * prevents an accumulation of scala related Class objects. Note that these ClassLoaders should
+ * only be used at a code boundary such that their loaded classes do not leak outside of the
+ * defining scope. This is because the layered class loaders can create mutually incompatible
+ * classes. For example, in the example above, suppose that there is a class foo.Bar provided
+ * by both "foo_2.12.jar" and "foo_2.12.jar" and that both also provide a static method
+ * "foo.Foo$.bar" that returns an instance of foo.Bar, then the following code will not work:
+ *
+ * {{{
+ *  Thread.currentThread.setContextClassLoader(altClassLoader)
+ *  val bar: Object = classLoader.loadClass("foo.Foo$").getDeclaredMethod("bar").invoke(null)
+ *  val barTyped: foo.Bar = bar.asInstanceOf[foo.Bar]
+ *  // throws ClassCastException because the thread context class loader is altClassLoader, but
+ *  // but bar was loaded by classLoader.
+ * }}}
+ *
+ * In general, this should only happen if the user explicitly overrides the thread context
+ * ClassLoader or uses reflection to manipulate classes loaded by different loaders.
+ */
+sealed trait ClassLoaderLayeringStrategy
+
+/**
+ * Provides instances of [[ClassLoaderLayeringStrategy]] that can be used to define the ClassLoader used by
+ * [[Keys.run]], [[Keys.test]] or any other task that runs java code inside of the sbt jvm.
+ */
+object ClassLoaderLayeringStrategy {
+
+  /**
+   * Include all of the dependencies in the loader. The base loader will be the Application
+   * ClassLoader. All classes apart from system classes will be reloaded with each run.
+   */
+  case object Flat extends ClassLoaderLayeringStrategy
+
+  /**
+   * Add a layer for the scala library class loader.
+   */
+  sealed trait ScalaLibrary extends ClassLoaderLayeringStrategy
+
+  /**
+   * This should indicate that we use a two layer ClassLoader where the top layer is the scala
+   * instance and all of the dependencies and project class paths are included in the search path
+   * of the second layer.
+   */
+  case object ScalaLibrary extends ScalaLibrary
+
+  /**
+   * Add a layer on top of the ScalaLibrary layer for all of the task jar dependencies.
+   */
+  sealed trait AllLibraryJars extends ScalaLibrary
+
+  /**
+   * Add a layer on top of the ScalaLibrary layer for all of the jar dependencies.
+   */
+  case object AllLibraryJars extends AllLibraryJars
+}
diff --git a/main/src/main/scala/sbt/CommandLineUIService.scala b/main/src/main/scala/sbt/CommandLineUIService.scala
new file mode 100644
index 000000000..39c3db302
--- /dev/null
+++ b/main/src/main/scala/sbt/CommandLineUIService.scala
@@ -0,0 +1,35 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import sbt.internal.util.{ SimpleReader, Terminal => ITerminal }
+
+trait CommandLineUIService extends InteractionService {
+  override def readLine(prompt: String, mask: Boolean): Option[String] = {
+    val maskChar = if (mask) Some('*') else None
+    SimpleReader(ITerminal.get).readLine(prompt, maskChar)
+  }
+  // TODO - Implement this better.
+  override def confirm(msg: String): Boolean = {
+    object Assent {
+      def unapply(in: String): Boolean = {
+        (in == "y" || in == "yes")
+      }
+    }
+    SimpleReader(ITerminal.get).readLine(msg + " (yes/no): ", None) match {
+      case Some(Assent()) => true
+      case _              => false
+    }
+  }
+
+  override def terminalWidth: Int = ITerminal.get.getWidth
+
+  override def terminalHeight: Int = ITerminal.get.getHeight
+}
+
+object CommandLineUIService extends CommandLineUIService
diff --git a/main/src/main/scala/sbt/Cross.scala b/main/src/main/scala/sbt/Cross.scala
index 53ac58ba4..8bb001d04 100644
--- a/main/src/main/scala/sbt/Cross.scala
+++ b/main/src/main/scala/sbt/Cross.scala
@@ -1,30 +1,41 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import Keys._
-import sbt.internal.util.complete.{ DefaultParsers, Parser }
-import sbt.internal.util.AttributeKey
-import DefaultParsers._
-import Def.{ ScopedKey, Setting }
-import sbt.internal.CommandStrings.{ CrossCommand, CrossRestoreSessionCommand, SwitchCommand, crossHelp, crossRestoreSessionHelp, switchHelp }
 import java.io.File
 
+import sbt.Def.{ ScopedKey, Setting }
+import sbt.Keys._
+import sbt.SlashSyntax0._
+import sbt.internal.Act
+import sbt.internal.CommandStrings._
 import sbt.internal.inc.ScalaInstance
+import sbt.internal.util.AttributeKey
+import sbt.internal.util.complete.DefaultParsers._
+import sbt.internal.util.complete.{ DefaultParsers, Parser }
 import sbt.io.IO
 import sbt.librarymanagement.CrossVersion
 
+/**
+ * Cross implements the Scala cross building commands:
+ * + ("cross") command and ++ ("switch") command.
+ */
 object Cross {
 
-  private def spacedFirst(name: String) = opOrIDSpaced(name) ~ any.+
+  private[sbt] def spacedFirst(name: String) = opOrIDSpaced(name) ~ any.+
 
   private case class Switch(version: ScalaVersion, verbose: Boolean, command: Option[String])
   private trait ScalaVersion {
     def force: Boolean
   }
   private case class NamedScalaVersion(name: String, force: Boolean) extends ScalaVersion
-  private case class ScalaHomeVersion(home: File, resolveVersion: Option[String], force: Boolean) extends ScalaVersion
+  private case class ScalaHomeVersion(home: File, resolveVersion: Option[String], force: Boolean)
+      extends ScalaVersion
 
   private def switchParser(state: State): Parser[Switch] = {
     import DefaultParsers._
@@ -36,21 +47,30 @@ object Cross {
         val force = arg.endsWith("!")
         val versionArg = if (force) arg.dropRight(1) else arg
         versionArg.split("=", 2) match {
-          case Array(home) if new File(home).exists() => ScalaHomeVersion(new File(home), None, force)
-          case Array(v)                               => NamedScalaVersion(v, force)
-          case Array(v, home)                         => ScalaHomeVersion(new File(home), Some(v).filterNot(_.isEmpty), force)
+          case Array(home) if new File(home).exists() =>
+            ScalaHomeVersion(new File(home), None, force)
+          case Array(v) => NamedScalaVersion(v, force)
+          case Array(v, home) =>
+            ScalaHomeVersion(new File(home), Some(v).filterNot(_.isEmpty), force)
         }
       }
       val spacedVersion = if (spacePresent) version else version & spacedFirst(SwitchCommand)
-      val verbose = Parser.opt(token(Space ~> "-v"))
+      val verboseOpt = Parser.opt(token(Space ~> "-v"))
       val optionalCommand = Parser.opt(token(Space ~> matched(state.combinedParser)))
-      (spacedVersion ~ verbose ~ optionalCommand).map {
+      val switch1 = (token(Space ~> "-v") ~> (Space ~> version) ~ optionalCommand) map {
+        case v ~ command =>
+          Switch(v, true, command)
+      }
+      val switch2 = (spacedVersion ~ verboseOpt ~ optionalCommand) map {
         case v ~ verbose ~ command =>
           Switch(v, verbose.isDefined, command)
       }
+      switch1 | switch2
     }
 
-    token(SwitchCommand ~> OptSpace) flatMap { sp => versionAndCommand(sp.nonEmpty) }
+    token(SwitchCommand ~> OptSpace) flatMap { sp =>
+      versionAndCommand(sp.nonEmpty)
+    }
   }
 
   private case class CrossArgs(command: String, verbose: Boolean)
@@ -59,92 +79,145 @@ object Cross {
     token(CrossCommand <~ OptSpace) flatMap { _ =>
       (token(Parser.opt("-v" <~ Space)) ~ token(matched(state.combinedParser))).map {
         case (verbose, command) => CrossArgs(command, verbose.isDefined)
-      } & spacedFirst(CrossCommand)
+      }
     }
 
-  private def crossRestoreSessionParser(state: State): Parser[String] = token(CrossRestoreSessionCommand)
+  private def crossRestoreSessionParser: Parser[String] = token(CrossRestoreSessionCommand)
 
-  private def requireSession[T](p: State => Parser[T]): State => Parser[T] = s =>
-    if (s get sessionSettings isEmpty) failure("No project loaded") else p(s)
+  private[sbt] def requireSession[T](p: State => Parser[T]): State => Parser[T] =
+    s => if (s get sessionSettings isEmpty) failure("No project loaded") else p(s)
 
   private def resolveAggregates(extracted: Extracted): Seq[ProjectRef] = {
-    import extracted._
 
-    def findAggregates(project: ProjectRef): List[ProjectRef] = {
-      project :: (structure.allProjects(project.build).find(_.id == project.project) match {
+    def findAggregates(project: ProjectRef): Seq[ProjectRef] = {
+      project :: (extracted.structure
+        .allProjects(project.build)
+        .find(_.id == project.project) match {
         case Some(resolved) => resolved.aggregate.toList.flatMap(findAggregates)
         case None           => Nil
       })
     }
 
-    (currentRef :: currentProject.aggregate.toList.flatMap(findAggregates)).distinct
+    (extracted.currentRef +: extracted.currentProject.aggregate.flatMap(findAggregates)).distinct
   }
 
-  private def crossVersions(extracted: Extracted, proj: ProjectRef): Seq[String] = {
+  private def crossVersions(extracted: Extracted, proj: ResolvedReference): Seq[String] = {
     import extracted._
-    (crossScalaVersions in proj get structure.data) getOrElse {
+    ((proj / crossScalaVersions) get structure.data) getOrElse {
       // reading scalaVersion is a one-time deal
-      (scalaVersion in proj get structure.data).toSeq
+      ((proj / scalaVersion) get structure.data).toSeq
     }
   }
 
   /**
-   * Parse the given command into either an aggregate command or a command for a project
+   * Parse the given command into a list of aggregate projects and command to issue.
    */
-  private def parseCommand(command: String): Either[String, (String, String)] = {
+  private[sbt] def parseSlashCommand(
+      extracted: Extracted
+  )(command: String): (Seq[ProjectRef], String) = {
+    import extracted._
     import DefaultParsers._
     val parser = (OpOrID <~ charClass(_ == '/', "/")) ~ any.* map {
-      case project ~ cmd => (project, cmd.mkString)
+      case seg1 ~ cmd => (seg1, cmd.mkString)
+    }
+    Parser.parse(command, parser) match {
+      case Right((seg1, cmd)) =>
+        structure.allProjectRefs.find(_.project == seg1) match {
+          case Some(proj) => (Seq(proj), cmd)
+          case _          => (resolveAggregates(extracted), command)
+        }
+      case _ => (resolveAggregates(extracted), command)
     }
-    Parser.parse(command, parser).left.map(_ => command)
   }
 
   def crossBuild: Command =
     Command.arb(requireSession(crossParser), crossHelp)(crossBuildCommandImpl)
 
   private def crossBuildCommandImpl(state: State, args: CrossArgs): State = {
-    val x = Project.extract(state)
-    import x._
-
-    val (aggs, aggCommand) = parseCommand(args.command) match {
-      case Right((project, cmd)) =>
-        (structure.allProjectRefs.filter(_.project == project), cmd)
-      case Left(cmd) => (resolveAggregates(x), cmd)
-    }
-
-    // if we support scalaVersion, projVersions should be cached somewhere since
-    // running ++2.11.1 is at the root level is going to mess with the scalaVersion for the aggregated subproj
-    val projVersions = (aggs flatMap { proj =>
-      crossVersions(x, proj) map { (proj.project, _) }
-    }).toList
-
+    val extracted = Project.extract(state)
+    val parser = Act.aggregatedKeyParser(extracted) ~ matched(any.*)
     val verbose = if (args.verbose) "-v" else ""
+    val allCommands = Parser.parse(args.command, parser) match {
+      case Left(_) =>
+        val (aggs, aggCommand) = parseSlashCommand(extracted)(args.command)
+        val projCrossVersions = aggs map { proj =>
+          proj -> crossVersions(extracted, proj)
+        }
+        // It's definitely not a task, check if it's a valid command, because we don't want to emit the warning
+        // message below for typos.
+        val validCommand = Parser.parse(aggCommand, state.combinedParser).isRight
 
-    if (projVersions.isEmpty) {
-      state
-    } else {
-      // Group all the projects by scala version
-      val allCommands = projVersions.groupBy(_._2).mapValues(_.map(_._1)).toSeq.flatMap {
-        case (version, Seq(project)) =>
-          // If only one project for a version, issue it directly
-          Seq(s"$SwitchCommand $verbose $version $project/$aggCommand")
-        case (version, projects) if aggCommand.contains(" ") =>
-          // If the command contains a space, then the all command won't work because it doesn't support issuing
-          // commands with spaces, so revert to running the command on each project one at a time
-          s"$SwitchCommand $verbose $version" :: projects.map(project => s"$project/$aggCommand")
-        case (version, projects) =>
-          // First switch scala version, then use the all command to run the command on each project concurrently
-          Seq(s"$SwitchCommand $verbose $version", projects.map(_ + "/" + aggCommand).mkString("all ", " ", ""))
-      }
+        val distinctCrossConfigs = projCrossVersions.map(_._2.toSet).distinct
+        if (validCommand && distinctCrossConfigs.size > 1) {
+          state.log.warn(
+            "Issuing a cross building command, but not all sub projects have the same cross build " +
+              "configuration. This could result in subprojects cross building against Scala versions that they are " +
+              "not compatible with. Try issuing cross building command with tasks instead, since sbt will be able " +
+              "to ensure that cross building is only done using configured project and Scala version combinations " +
+              "that are configured."
+          )
+          state.log.debug("Scala versions configuration is:")
+          projCrossVersions.foreach {
+            case (project, versions) => state.log.debug(s"$project: $versions")
+          }
+        }
 
-      allCommands ::: CrossRestoreSessionCommand :: captureCurrentSession(state, x)
+        // Execute using a blanket switch
+        projCrossVersions.toMap.apply(extracted.currentRef).flatMap { version =>
+          // Force scala version
+          Seq(s"$SwitchCommand $verbose $version!", aggCommand)
+        }
+      case Right((keys, taskArgs)) =>
+        def project(key: ScopedKey[_]): Option[ProjectRef] = key.scope.project.toOption match {
+          case Some(p: ProjectRef) => Some(p)
+          case _                   => None
+        }
+        val fullArgs = if (taskArgs.trim.isEmpty) "" else s" ${taskArgs.trim}"
+        val keysByVersion = keys
+          .flatMap { k =>
+            project(k).toSeq.flatMap(crossVersions(extracted, _).map(v => v -> k))
+          }
+          .groupBy(_._1)
+          .mapValues(_.map(_._2).toSet)
+        val commandsByVersion = keysByVersion.toSeq
+          .flatMap {
+            case (v, keys) =>
+              val projects = keys.flatMap(project)
+              keys.toSeq.flatMap { k =>
+                project(k).filter(projects.contains).flatMap { p =>
+                  if (p == extracted.currentRef || !projects.contains(extracted.currentRef)) {
+                    val parts = project(k).map(_.project) ++ k.scope.config.toOption.map {
+                      case ConfigKey(n) => n.head.toUpper + n.tail
+                    } ++ k.scope.task.toOption.map(_.label) ++ Some(k.key.label)
+                    Some(v -> parts.mkString("", "/", fullArgs))
+                  } else None
+                }
+              }
+          }
+          .groupBy(_._1)
+          .mapValues(_.map(_._2))
+          .toSeq
+          .sortBy(_._1)
+        commandsByVersion.flatMap {
+          case (v, commands) =>
+            commands match {
+              case Seq(c) => Seq(s"$SwitchCommand $verbose $v $c")
+              case Seq()  => Nil // should be unreachable
+              case multi if fullArgs.isEmpty =>
+                Seq(s"$SwitchCommand $verbose $v all ${multi.mkString(" ")}")
+              case multi => Seq(s"$SwitchCommand $verbose $v") ++ multi
+            }
+        }
     }
+    allCommands.toList ::: CrossRestoreSessionCommand :: captureCurrentSession(state, extracted)
   }
 
   def crossRestoreSession: Command =
-    Command.arb(crossRestoreSessionParser, crossRestoreSessionHelp)(crossRestoreSessionImpl)
+    Command.arb(_ => crossRestoreSessionParser, crossRestoreSessionHelp)(
+      (s, _) => crossRestoreSessionImpl(s)
+    )
 
-  private def crossRestoreSessionImpl(state: State, arg: String): State = {
+  private def crossRestoreSessionImpl(state: State): State = {
     restoreCapturedSession(state, Project.extract(state))
   }
 
@@ -158,7 +231,9 @@ object Cross {
     state.get(CapturedSession) match {
       case Some(rawAppend) =>
         val restoredSession = extracted.session.copy(rawAppend = rawAppend)
-        BuiltinCommands.reapply(restoredSession, extracted.structure, state).remove(CapturedSession)
+        BuiltinCommands
+          .reapply(restoredSession, extracted.structure, state)
+          .remove(CapturedSession)
       case None => state
     }
   }
@@ -167,18 +242,37 @@ object Cross {
     Command.arb(requireSession(switchParser), switchHelp)(switchCommandImpl)
 
   private def switchCommandImpl(state: State, args: Switch): State = {
-    val switchedState = switchScalaVersion(args, state)
+    val (switchedState, affectedRefs) = switchScalaVersion(args, state)
 
-    args.command.toSeq ::: switchedState
+    val strictCmd =
+      if (args.version.force) {
+        // The Scala version was forced on the whole build, run as is
+        args.command
+      } else
+        args.command.map { rawCmd =>
+          // for now, treat `all` command specially
+          if (rawCmd.startsWith("all ")) rawCmd
+          else {
+            val (aggs, aggCommand) = parseSlashCommand(Project.extract(state))(rawCmd)
+            aggs
+              .intersect(affectedRefs)
+              .map({ case ProjectRef(_, proj) => s"$proj/$aggCommand" })
+              .mkString("all ", " ", "")
+          }
+        }
+
+    strictCmd.toList ::: switchedState
   }
 
-  private def switchScalaVersion(switch: Switch, state: State): State = {
-    val x = Project.extract(state)
-    import x._
+  private def switchScalaVersion(switch: Switch, state: State): (State, Seq[ResolvedReference]) = {
+    val extracted = Project.extract(state)
+    import extracted._
+
+    type ScalaVersion = String
 
     val (version, instance) = switch.version match {
       case ScalaHomeVersion(homePath, resolveVersion, _) =>
-        val home = IO.resolve(x.currentProject.base, homePath)
+        val home = IO.resolve(extracted.currentProject.base, homePath)
         if (home.exists()) {
           val instance = ScalaInstance(home)(state.classLoaderCache.apply _)
           val version = resolveVersion.getOrElse(instance.actualVersion)
@@ -189,9 +283,10 @@ object Cross {
       case NamedScalaVersion(v, _) => (v, None)
     }
 
-    val binaryVersion = CrossVersion.binaryScalaVersion(version)
-
-    def logSwitchInfo(included: Seq[(ProjectRef, Seq[String])], excluded: Seq[(ProjectRef, Seq[String])]) = {
+    def logSwitchInfo(
+        included: Seq[(ProjectRef, Seq[ScalaVersion])],
+        excluded: Seq[(ProjectRef, Seq[ScalaVersion])]
+    ) = {
 
       instance.foreach {
         case (home, instance) =>
@@ -206,9 +301,10 @@ object Cross {
         state.log.info(s"Excluded ${excluded.size} projects, run ++ $version -v for more details.")
       }
 
-      def detailedLog(msg: => String) = if (switch.verbose) state.log.info(msg) else state.log.debug(msg)
+      def detailedLog(msg: => String) =
+        if (switch.verbose) state.log.info(msg) else state.log.debug(msg)
 
-      def logProject: (ProjectRef, Seq[String]) => Unit = (proj, scalaVersions) => {
+      def logProject: (ProjectRef, Seq[ScalaVersion]) => Unit = (proj, scalaVersions) => {
         val current = if (proj == currentRef) "*" else " "
         detailedLog(s"  $current ${proj.project} ${scalaVersions.mkString("(", ", ", ")")}")
       }
@@ -218,49 +314,74 @@ object Cross {
       excluded.foreach(logProject.tupled)
     }
 
-    val projects: Seq[Reference] = {
-      val projectScalaVersions = structure.allProjectRefs.map(proj => proj -> crossVersions(x, proj))
+    val projects: Seq[(ResolvedReference, Seq[ScalaVersion])] = {
+      val projectScalaVersions =
+        structure.allProjectRefs.map(proj => proj -> crossVersions(extracted, proj))
       if (switch.version.force) {
         logSwitchInfo(projectScalaVersions, Nil)
-        structure.allProjectRefs ++ structure.units.keys.map(BuildRef.apply)
+        projectScalaVersions ++ structure.units.keys
+          .map(BuildRef.apply)
+          .map(proj => proj -> crossVersions(extracted, proj))
       } else {
+        val binaryVersion = CrossVersion.binaryScalaVersion(version)
 
         val (included, excluded) = projectScalaVersions.partition {
-          case (proj, scalaVersions) => scalaVersions.exists(v => CrossVersion.binaryScalaVersion(v) == binaryVersion)
+          case (_, scalaVersions) =>
+            scalaVersions.exists(v => CrossVersion.binaryScalaVersion(v) == binaryVersion)
+        }
+        if (included.isEmpty) {
+          sys.error(
+            s"""Switch failed: no subprojects list "$version" (or compatible version) in crossScalaVersions setting.
+               |If you want to force it regardless, call ++ $version!""".stripMargin
+          )
         }
         logSwitchInfo(included, excluded)
-        included.map(_._1)
+        included
       }
     }
 
-    setScalaVersionForProjects(version, instance, projects, state, x)
+    (setScalaVersionForProjects(version, instance, projects, state, extracted), projects.map(_._1))
   }
 
-  private def setScalaVersionForProjects(version: String, instance: Option[(File, ScalaInstance)],
-    projects: Seq[Reference], state: State, extracted: Extracted): State = {
+  private def setScalaVersionForProjects(
+      version: String,
+      instance: Option[(File, ScalaInstance)],
+      projects: Seq[(ResolvedReference, Seq[String])],
+      state: State,
+      extracted: Extracted
+  ): State = {
     import extracted._
 
-    val newSettings = projects.flatMap { project =>
-      val scope = Scope(Select(project), Global, Global, Global)
+    val newSettings = projects.flatMap {
+      case (project, scalaVersions) =>
+        val scope = Scope(Select(project), Zero, Zero, Zero)
 
-      instance match {
-        case Some((home, inst)) => Seq(
-          scalaVersion in scope := version,
-          scalaHome in scope := Some(home),
-          scalaInstance in scope := inst
-        )
-        case None => Seq(
-          scalaVersion in scope := version,
-          scalaHome in scope := None
-        )
-      }
+        instance match {
+          case Some((home, inst)) =>
+            Seq(
+              scope / scalaVersion := version,
+              scope / crossScalaVersions := scalaVersions,
+              scope / scalaHome := Some(home),
+              scope / scalaInstance := inst
+            )
+          case None =>
+            Seq(
+              scope / scalaVersion := version,
+              scope / crossScalaVersions := scalaVersions,
+              scope / scalaHome := None
+            )
+        }
     }
 
     val filterKeys: Set[AttributeKey[_]] = Set(scalaVersion, scalaHome, scalaInstance).map(_.key)
 
+    val projectsContains: Reference => Boolean = projects.map(_._1).toSet.contains
+
     // Filter out any old scala version settings that were added, this is just for hygiene.
     val filteredRawAppend = session.rawAppend.filter(_.key match {
-      case ScopedKey(Scope(Select(ref), Global, Global, Global), key) if filterKeys.contains(key) && projects.contains(ref) => false
+      case ScopedKey(Scope(Select(ref), Zero, Zero, Zero), key)
+          if filterKeys.contains(key) && projectsContains(ref) =>
+        false
       case _ => true
     })
 
diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala
old mode 100755
new mode 100644
index 049bdbcfa..5a491f973
--- a/main/src/main/scala/sbt/Defaults.scala
+++ b/main/src/main/scala/sbt/Defaults.scala
@@ -1,62 +1,126 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import scala.concurrent.duration.FiniteDuration
-import sbt.internal._
-import sbt.internal.util.Attributed.data
-import Scope.{ fillTaskAxis, GlobalScope, ThisScope }
-import sbt.internal.librarymanagement.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties }
-import Project.{ inConfig, inScope, inTask, richInitialize, richInitializeTask, richTaskSessionVar }
-import Def.{ Initialize, ScopedKey, Setting, SettingsDefinition }
-import sbt.librarymanagement.Artifact.{ DocClassifier, SourceClassifier }
-import sbt.librarymanagement.Configurations.{ Compile, CompilerPlugin, IntegrationTest, names, Provided, Runtime, Test }
-import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion }
-import sbt.internal.util.complete._
-import std.TaskExtra._
-import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint }
-
-import sbt.librarymanagement.{ `package` => _, _ }
-import sbt.internal.librarymanagement._
-import sbt.internal.librarymanagement.syntax._
-import sbt.internal.util._
-import sbt.util.{ Level, Logger }
-
-import sys.error
-import scala.xml.NodeSeq
-import scala.util.control.NonFatal
-import org.apache.ivy.core.module.{ descriptor, id }
-import descriptor.ModuleDescriptor, id.ModuleRevisionId
 import java.io.{ File, PrintWriter }
 import java.net.{ URI, URL }
-import java.util.concurrent.{ TimeUnit, Callable }
-import sbinary.DefaultProtocol.StringFormat
-import sbt.internal.util.Cache.seqFormat
+import java.nio.file.{ Paths, Path => NioPath }
+import java.util.Optional
+import java.util.concurrent.TimeUnit
+
+import lmcoursier.CoursierDependencyResolution
+import lmcoursier.definitions.{ Configuration => CConfiguration }
+import org.apache.ivy.core.module.descriptor.ModuleDescriptor
+import org.apache.ivy.core.module.id.ModuleRevisionId
+import org.apache.logging.log4j.core.{ Appender => XAppender }
+import org.scalasbt.ipcsocket.Win32SecurityLevel
+import sbt.Def.{ Initialize, ScopedKey, Setting, SettingsDefinition }
+import sbt.Keys._
+import sbt.OptionSyntax._
+import sbt.Project.{
+  inConfig,
+  inScope,
+  inTask,
+  richInitialize,
+  richInitializeTask,
+  richTaskSessionVar,
+  sbtRichTaskPromise
+}
+import sbt.Scope.{ GlobalScope, ThisScope, fillTaskAxis }
+import sbt.coursierint._
 import sbt.internal.CommandStrings.ExportStream
-
-import xsbti.{ CrossValue, Maybe }
-import sbt.util.InterfaceUtil.{ f1, o2m }
-
+import sbt.internal._
+import sbt.internal.classpath.{ AlternativeZincUtil, ClassLoaderCache }
+import sbt.internal.inc.JavaInterfaceUtil._
+import sbt.internal.inc.classpath.{ ClasspathFilter, ClasspathUtil }
+import sbt.internal.inc.{ CompileOutput, MappedFileConverter, Stamps, ZincLmUtil, ZincUtil }
+import sbt.internal.io.{ Source, WatchState }
+import sbt.internal.librarymanagement.mavenint.{
+  PomExtraDependencyAttributes,
+  SbtPomExtraProperties
+}
+import sbt.internal.librarymanagement.{ CustomHttp => _, _ }
+import sbt.internal.nio.{ CheckBuildSources, Globs }
+import sbt.internal.server.{
+  BspCompileTask,
+  BuildServerProtocol,
+  BuildServerReporter,
+  Definition,
+  LanguageServerProtocol,
+  ServerHandler,
+  VirtualTerminal
+}
+import sbt.internal.testing.TestLogger
+import sbt.internal.util.Attributed.data
 import sbt.internal.util.Types._
-
-import sbt.internal.io.WatchState
-import sbt.io.{ AllPassFilter, FileFilter, GlobFilter, HiddenFileFilter, IO, NameFilter, NothingFilter, Path, PathFinder, SimpleFileFilter, DirectoryFilter, Hash }
-
-import Path._
+import sbt.internal.util.{ Terminal => ITerminal, _ }
+import sbt.internal.util.complete._
+import sbt.io.Path._
+import sbt.io._
 import sbt.io.syntax._
-import Keys._
+import sbt.librarymanagement.Artifact.{ DocClassifier, SourceClassifier }
+import sbt.librarymanagement.Configurations.{
+  Compile,
+  CompilerPlugin,
+  IntegrationTest,
+  Provided,
+  Runtime,
+  Test
+}
+import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion }
+import sbt.librarymanagement._
+import sbt.librarymanagement.ivy._
+import sbt.librarymanagement.syntax._
+import sbt.nio.FileStamp
+import sbt.nio.Keys._
+import sbt.nio.file.syntax._
+import sbt.nio.file.{ FileTreeView, Glob, RecursiveGlob }
+import sbt.nio.Watch
+import sbt.std.TaskExtra._
+import sbt.testing.{ AnnotatedFingerprint, Framework, Runner, SubclassFingerprint }
+import sbt.util.CacheImplicits._
+import sbt.util.InterfaceUtil.{ t2, toJavaFunction => f1 }
+import sbt.util._
+import sjsonnew._
+import sjsonnew.support.scalajson.unsafe.Converter
+import xsbti.compile.TastyFiles
+import xsbti.{ FileConverter, Position }
+
+import scala.annotation.nowarn
+import scala.collection.immutable.ListMap
+import scala.concurrent.duration._
+import scala.util.control.NonFatal
+import scala.xml.NodeSeq
 
 // incremental compiler
-import xsbt.api.Discovery
+import sbt.SlashSyntax0._
+import sbt.internal.inc.{
+  Analysis,
+  AnalyzingCompiler,
+  ManagedLoggedReporter,
+  MixedAnalyzingCompiler,
+  ScalaInstance
+}
+import xsbti.{ CrossValue, VirtualFile, VirtualFileRef }
 import xsbti.compile.{
-  Compilers,
+  AnalysisContents,
+  ClassFileManagerType,
+  ClasspathOptionsUtil,
   CompileAnalysis,
   CompileOptions,
   CompileOrder,
   CompileResult,
+  CompileProgress,
+  CompilerCache,
+  Compilers,
   DefinesClass,
-  IncOptionsUtil,
+  IncOptions,
+  IncToolOptionsUtil,
   Inputs,
   MiniSetup,
   PerClasspathEntryLookup,
@@ -64,44 +128,53 @@ import xsbti.compile.{
   Setup,
   TransactionalManagerType
 }
-import sbt.internal.inc.{
-  AnalyzingCompiler,
-  Analysis,
-  CompilerCache,
-  FileValueCache,
-  Locate,
-  LoggerReporter,
-  MixedAnalyzingCompiler,
-  ScalaInstance,
-  ClasspathOptionsUtil
-}
 
 object Defaults extends BuildCommon {
   final val CacheDirectoryName = "cache"
 
-  def configSrcSub(key: SettingKey[File]): Initialize[File] = (key in ThisScope.copy(config = Global), configuration) { (src, conf) => src / nameForSrc(conf.name) }
+  def configSrcSub(key: SettingKey[File]): Initialize[File] =
+    Def.setting {
+      (ThisScope.copy(config = Zero) / key).value / nameForSrc(configuration.value.name)
+    }
   def nameForSrc(config: String) = if (config == Configurations.Compile.name) "main" else config
   def prefix(config: String) = if (config == Configurations.Compile.name) "" else config + "-"
 
-  def lock(app: xsbti.AppConfiguration): xsbti.GlobalLock = app.provider.scalaProvider.launcher.globalLock
+  def lock(app: xsbti.AppConfiguration): xsbti.GlobalLock = LibraryManagement.lock(app)
 
   def extractAnalysis[T](a: Attributed[T]): (T, CompileAnalysis) =
     (a.data, a.metadata get Keys.analysis getOrElse Analysis.Empty)
 
-  def analysisMap[T](cp: Seq[Attributed[T]]): T => Option[CompileAnalysis] =
-    {
-      val m = (for (a <- cp; an <- a.metadata get Keys.analysis) yield (a.data, an)).toMap
-      m.get _
-    }
-  private[sbt] def globalDefaults(ss: Seq[Setting[_]]): Seq[Setting[_]] = Def.defaultSettings(inScope(GlobalScope)(ss))
+  def analysisMap[T](cp: Seq[Attributed[T]]): T => Option[CompileAnalysis] = {
+    val m = (for (a <- cp; an <- a.metadata get Keys.analysis) yield (a.data, an)).toMap
+    m.get _
+  }
+  private[sbt] def globalDefaults(ss: Seq[Setting[_]]): Seq[Setting[_]] =
+    Def.defaultSettings(inScope(GlobalScope)(ss))
 
   def buildCore: Seq[Setting[_]] = thisBuildCore ++ globalCore
-  def thisBuildCore: Seq[Setting[_]] = inScope(GlobalScope.copy(project = Select(ThisBuild)))(Seq(
-    managedDirectory := baseDirectory.value / "lib_managed"
-  ))
-  private[sbt] lazy val globalCore: Seq[Setting[_]] = globalDefaults(defaultTestTasks(test) ++ defaultTestTasks(testOnly) ++ defaultTestTasks(testQuick) ++ Seq(
-    excludeFilter :== HiddenFileFilter
-  ) ++ globalIvyCore ++ globalJvmCore) ++ globalSbtCore
+  def thisBuildCore: Seq[Setting[_]] =
+    inScope(GlobalScope.copy(project = Select(ThisBuild)))(
+      Seq(
+        managedDirectory := baseDirectory.value / "lib_managed"
+      )
+    )
+  private[sbt] lazy val globalCore: Seq[Setting[_]] = globalDefaults(
+    defaultTestTasks(test) ++ defaultTestTasks(testOnly) ++ defaultTestTasks(testQuick) ++ Seq(
+      excludeFilter :== HiddenFileFilter,
+      fileInputs :== Nil,
+      fileInputIncludeFilter :== AllPassFilter.toNio,
+      fileInputExcludeFilter :== DirectoryFilter.toNio || HiddenFileFilter,
+      fileOutputIncludeFilter :== AllPassFilter.toNio,
+      fileOutputExcludeFilter :== NothingFilter.toNio,
+      inputFileStamper :== sbt.nio.FileStamper.Hash,
+      outputFileStamper :== sbt.nio.FileStamper.LastModified,
+      onChangedBuildSource :== SysProp.onChangedBuildSource,
+      clean := { () },
+      unmanagedFileStampCache :=
+        state.value.get(persistentFileStampCache).getOrElse(new sbt.nio.FileStamp.Cache),
+      managedFileStampCache := new sbt.nio.FileStamp.Cache,
+    ) ++ globalIvyCore ++ globalJvmCore ++ Watch.defaults
+  ) ++ globalSbtCore
 
   private[sbt] lazy val globalJvmCore: Seq[Setting[_]] =
     Seq(
@@ -111,27 +184,47 @@ object Defaults extends BuildCommon {
       apiMappings := Map.empty,
       autoScalaLibrary :== true,
       managedScalaInstance :== true,
-      classpathEntryDefinesClass :== FileValueCache(Locate.definesClass _).get,
-      traceLevel in run :== 0,
-      traceLevel in runMain :== 0,
-      traceLevel in console :== Int.MaxValue,
-      traceLevel in consoleProject :== Int.MaxValue,
+      classpathEntryDefinesClass := { (file: File) =>
+        sys.error("use classpathEntryDefinesClassVF instead")
+      },
+      extraIncOptions :== Seq("JAVA_CLASS_VERSION" -> sys.props("java.class.version")),
+      allowMachinePath :== true,
+      reportAbsolutePath := true,
+      run / traceLevel :== 0,
+      runMain / traceLevel :== 0,
+      bgRun / traceLevel :== 0,
+      fgRun / traceLevel :== 0,
+      console / traceLevel :== Int.MaxValue,
+      consoleProject / traceLevel :== Int.MaxValue,
       autoCompilerPlugins :== true,
       scalaHome :== None,
       apiURL := None,
       javaHome :== None,
+      discoveredJavaHomes := CrossJava.discoverJavaHomes,
+      javaHomes :== ListMap.empty,
+      fullJavaHomes := CrossJava.expandJavaHomes(discoveredJavaHomes.value ++ javaHomes.value),
       testForkedParallel :== false,
       javaOptions :== Nil,
       sbtPlugin :== false,
+      isMetaBuild :== false,
+      reresolveSbtArtifacts :== false,
       crossPaths :== true,
       sourcePositionMappers :== Nil,
-      artifactClassifier in packageSrc :== Some(SourceClassifier),
-      artifactClassifier in packageDoc :== Some(DocClassifier),
+      packageSrc / artifactClassifier :== Some(SourceClassifier),
+      packageDoc / artifactClassifier :== Some(DocClassifier),
       includeFilter :== NothingFilter,
-      includeFilter in unmanagedSources :== ("*.java" | "*.scala") && new SimpleFileFilter(_.isFile),
-      includeFilter in unmanagedJars :== "*.jar" | "*.so" | "*.dll" | "*.jnilib" | "*.zip",
-      includeFilter in unmanagedResources :== AllPassFilter
-    )
+      unmanagedSources / includeFilter :== ("*.java" | "*.scala"),
+      unmanagedJars / includeFilter :== "*.jar" | "*.so" | "*.dll" | "*.jnilib" | "*.zip",
+      unmanagedResources / includeFilter :== AllPassFilter,
+      bgList := { bgJobService.value.jobs },
+      ps := psTask.value,
+      bgStop := bgStopTask.evaluated,
+      bgWaitFor := bgWaitForTask.evaluated,
+      bgCopyClasspath :== true,
+      closeClassLoaders :== SysProp.closeClassLoaders,
+      allowZombieClassLoaders :== true,
+      packageTimestamp :== Package.defaultTimestamp,
+    ) ++ BuildServerProtocol.globalSettings
 
   private[sbt] lazy val globalIvyCore: Seq[Setting[_]] =
     Seq(
@@ -140,86 +233,335 @@ object Defaults extends BuildCommon {
       exportJars :== false,
       trackInternalDependencies :== TrackLevel.TrackAlways,
       exportToInternal :== TrackLevel.TrackAlways,
+      useCoursier :== SysProp.defaultUseCoursier,
       retrieveManaged :== false,
       retrieveManagedSync :== false,
       configurationsToRetrieve :== None,
       scalaOrganization :== ScalaArtifacts.Organization,
-      sbtResolver := { if (sbtVersion.value endsWith "-SNAPSHOT") Classpaths.sbtIvySnapshots else Classpaths.typesafeReleases },
-      crossVersion :== CrossVersion.Disabled,
+      scalaArtifacts :== ScalaArtifacts.Artifacts,
+      sbtResolver := {
+        val v = sbtVersion.value
+        if (v.endsWith("-SNAPSHOT") || v.contains("-bin-")) Classpaths.sbtMavenSnapshots
+        else Resolver.DefaultMavenRepository
+      },
+      sbtResolvers := {
+        // TODO: Remove Classpaths.typesafeReleases for sbt 2.x
+        // We need to keep it around for sbt 1.x to cross build plugins with sbt 0.13 - https://github.com/sbt/sbt/issues/4698
+        Vector(sbtResolver.value, Classpaths.sbtPluginReleases, Classpaths.typesafeReleases)
+      },
+      crossVersion :== Disabled(),
       buildDependencies := Classpaths.constructBuildDependencies.value,
-      version :== "0.1-SNAPSHOT",
-      classpathTypes :== Set("jar", "bundle") ++ CustomPomParser.JarPackagings,
+      version :== "0.1.0-SNAPSHOT",
+      versionScheme :== None,
+      classpathTypes :== Set("jar", "bundle", "maven-plugin", "test-jar") ++ CustomPomParser.JarPackagings,
       artifactClassifier :== None,
       checksums := Classpaths.bootChecksums(appConfiguration.value),
       conflictManager := ConflictManager.default,
+      CustomHttp.okhttpClientBuilder :== CustomHttp.defaultHttpClientBuilder,
+      CustomHttp.okhttpClient := CustomHttp.okhttpClientBuilder.value.build,
       pomExtra :== NodeSeq.Empty,
       pomPostProcess :== idFun,
       pomAllRepositories :== false,
       pomIncludeRepository :== Classpaths.defaultRepositoryFilter,
       updateOptions := UpdateOptions(),
-      forceUpdatePeriod :== None
+      forceUpdatePeriod :== None,
+      // coursier settings
+      csrExtraCredentials :== Nil,
+      csrLogger := LMCoursier.coursierLoggerTask.value,
+      csrMavenProfiles :== Set.empty,
+      csrReconciliations :== LMCoursier.relaxedForAllModules,
     )
 
   /** Core non-plugin settings for sbt builds.  These *must* be on every build or the sbt engine will fail to run at all. */
-  private[sbt] lazy val globalSbtCore: Seq[Setting[_]] = globalDefaults(Seq(
-    outputStrategy :== None, // TODO - This might belong elsewhere.
-    buildStructure := Project.structure(state.value),
-    settingsData := buildStructure.value.data,
-    trapExit :== true,
-    connectInput :== false,
-    cancelable :== false,
-    taskCancelStrategy := { state: State =>
-      if (cancelable.value) TaskCancellationStrategy.Signal
-      else TaskCancellationStrategy.Null
+  private[sbt] lazy val globalSbtCore: Seq[Setting[_]] = globalDefaults(
+    Seq(
+      outputStrategy :== None, // TODO - This might belong elsewhere.
+      buildStructure := Project.structure(state.value),
+      settingsData := buildStructure.value.data,
+      checkBuildSources / aggregate :== false,
+      checkBuildSources / changedInputFiles / aggregate := false,
+      checkBuildSources / Continuous.dynamicInputs := None,
+      checkBuildSources / fileInputs := CheckBuildSources.buildSourceFileInputs.value,
+      checkBuildSources := CheckBuildSources.needReloadImpl.value,
+      fileCacheSize := "128M",
+      trapExit :== true,
+      connectInput :== false,
+      cancelable :== true,
+      taskCancelStrategy := { state: State =>
+        if (cancelable.value) TaskCancellationStrategy.Signal
+        else TaskCancellationStrategy.Null
+      },
+      envVars :== Map.empty,
+      sbtVersion := appConfiguration.value.provider.id.version,
+      sbtBinaryVersion := binarySbtVersion(sbtVersion.value),
+      // `pluginCrossBuild` scoping is based on sbt-cross-building plugin.
+      // The idea here is to be able to define a `sbtVersion in pluginCrossBuild`, which
+      // directs the dependencies of the plugin to build to the specified sbt plugin version.
+      pluginCrossBuild / sbtVersion := sbtVersion.value,
+      onLoad := idFun[State],
+      onUnload := idFun[State],
+      onUnload := { s =>
+        try onUnload.value(s)
+        finally IO.delete(taskTemporaryDirectory.value)
+      },
+      // extraLoggers is deprecated
+      SettingKey[ScopedKey[_] => Seq[XAppender]]("extraLoggers") :== { _ =>
+        Nil
+      },
+      extraAppenders := {
+        val f = SettingKey[ScopedKey[_] => Seq[XAppender]]("extraLoggers").value
+        s =>
+          f(s).map {
+            case a: Appender => a
+            case a           => new ConsoleAppenderFromLog4J(a.getName, a)
+          }
+      },
+      useLog4J :== SysProp.useLog4J,
+      watchSources :== Nil, // Although this is deprecated, it can't be removed or it breaks += for legacy builds.
+      skip :== false,
+      taskTemporaryDirectory := {
+        val base = BuildPaths.globalTaskDirectoryStandard(appConfiguration.value.baseDirectory)
+        val dir = IO.createUniqueDirectory(base)
+        ShutdownHooks.add(() => IO.delete(dir))
+        dir
+      },
+      onComplete := {
+        val tempDirectory = taskTemporaryDirectory.value
+        () => Clean.deleteContents(tempDirectory, _ => false)
+      },
+      turbo :== SysProp.turbo,
+      usePipelining :== SysProp.pipelining,
+      exportPipelining := usePipelining.value,
+      useScalaReplJLine :== false,
+      scalaInstanceTopLoader := {
+        // the JLineLoader contains the SbtInterfaceClassLoader
+        if (!useScalaReplJLine.value)
+          classOf[org.jline.terminal.Terminal].getClassLoader // the JLineLoader
+        else classOf[Compilers].getClassLoader // the SbtInterfaceClassLoader
+      },
+      useSuperShell := { if (insideCI.value) false else ITerminal.console.isSupershellEnabled },
+      superShellThreshold :== SysProp.supershellThreshold,
+      superShellMaxTasks :== SysProp.supershellMaxTasks,
+      superShellSleep :== SysProp.supershellSleep.millis,
+      progressReports := {
+        val rs = EvaluateTask.taskTimingProgress.toVector ++ EvaluateTask.taskTraceEvent.toVector
+        rs map { Keys.TaskProgress(_) }
+      },
+      // progressState is deprecated
+      SettingKey[Option[ProgressState]]("progressState") := None,
+      Previous.cache := new Previous(
+        Def.streamsManagerKey.value,
+        Previous.references.value.getReferences
+      ),
+      Previous.references :== new Previous.References,
+      concurrentRestrictions := defaultRestrictions.value,
+      parallelExecution :== true,
+      fileTreeView :== FileTreeView.default,
+      Continuous.dynamicInputs := Continuous.dynamicInputsImpl.value,
+      logBuffered :== false,
+      commands :== Nil,
+      showSuccess :== true,
+      showTiming :== true,
+      timingFormat :== Aggregation.defaultFormat,
+      aggregate :== true,
+      maxErrors :== 100,
+      fork :== false,
+      initialize :== {},
+      templateResolverInfos :== Nil,
+      forcegc :== sys.props
+        .get("sbt.task.forcegc")
+        .map(java.lang.Boolean.parseBoolean)
+        .getOrElse(GCUtil.defaultForceGarbageCollection),
+      minForcegcInterval :== GCUtil.defaultMinForcegcInterval,
+      interactionService :== CommandLineUIService,
+      autoStartServer := true,
+      serverHost := "127.0.0.1",
+      serverIdleTimeout := Some(new FiniteDuration(7, TimeUnit.DAYS)),
+      serverPort := 5000 + (Hash
+        .toHex(Hash(appConfiguration.value.baseDirectory.toString))
+        .## % 1000),
+      serverConnectionType := ConnectionType.Local,
+      serverAuthentication := {
+        if (serverConnectionType.value == ConnectionType.Tcp) Set(ServerAuthentication.Token)
+        else Set()
+      },
+      serverHandlers :== Nil,
+      windowsServerSecurityLevel := Win32SecurityLevel.OWNER_DACL, // allows any owner logon session to access the server
+      serverUseJni := BootServerSocket.requiresJNI || SysProp.serverUseJni,
+      fullServerHandlers := Nil,
+      insideCI :== sys.env.contains("BUILD_NUMBER") ||
+        sys.env.contains("CI") || SysProp.ci,
+      // watch related settings
+      pollInterval :== Watch.defaultPollInterval,
+      canonicalInput :== true,
+      echoInput :== true,
+      terminal := state.value.get(terminalKey).getOrElse(Terminal(ITerminal.get)),
+      InstallSbtn.installSbtn := InstallSbtn.installSbtnImpl.evaluated,
+      InstallSbtn.installSbtn / aggregate := false,
+    ) ++ LintUnused.lintSettings
+      ++ DefaultBackgroundJobService.backgroundJobServiceSettings
+      ++ RemoteCache.globalSettings
+  )
+
+  private[sbt] lazy val buildLevelJvmSettings: Seq[Setting[_]] = Seq(
+    exportPipelining := usePipelining.value,
+    rootPaths := {
+      val app = appConfiguration.value
+      val base = app.baseDirectory.getCanonicalFile
+      val boot = app.provider.scalaProvider.launcher.bootDirectory
+      val ih = app.provider.scalaProvider.launcher.ivyHome
+      val coursierCache = csrCacheDirectory.value
+      val javaHome = Paths.get(sys.props("java.home"))
+      Map(
+        "BASE" -> base.toPath,
+        "SBT_BOOT" -> boot.toPath,
+        "CSR_CACHE" -> coursierCache.toPath,
+        "IVY_HOME" -> ih.toPath,
+        "JAVA_HOME" -> javaHome,
+      )
     },
-    envVars :== Map.empty,
-    sbtVersion := appConfiguration.value.provider.id.version,
-    sbtBinaryVersion := binarySbtVersion(sbtVersion.value),
-    watchingMessage := Watched.defaultWatchingMessage,
-    triggeredMessage := Watched.defaultTriggeredMessage,
-    onLoad := idFun[State],
-    onUnload := idFun[State],
-    onUnload := { s => try onUnload.value(s) finally IO.delete(taskTemporaryDirectory.value) },
-    extraLoggers :== { _ => Nil },
-    watchSources :== Nil,
-    skip :== false,
-    taskTemporaryDirectory := { val dir = IO.createTemporaryDirectory; dir.deleteOnExit(); dir },
-    onComplete := { val dir = taskTemporaryDirectory.value; () => { IO.delete(dir); IO.createDirectory(dir) } },
-    Previous.cache := Previous.cacheSetting.value,
-    Previous.references :== new Previous.References,
-    concurrentRestrictions := defaultRestrictions.value,
-    parallelExecution :== true,
-    pollInterval :== 500,
-    logBuffered :== false,
-    commands :== Nil,
-    showSuccess :== true,
-    showTiming :== true,
-    timingFormat :== Aggregation.defaultFormat,
-    aggregate :== true,
-    maxErrors :== 100,
-    fork :== false,
-    initialize :== {},
-    forcegc :== sys.props.get("sbt.task.forcegc").map(java.lang.Boolean.parseBoolean).getOrElse(GCUtil.defaultForceGarbageCollection),
-    minForcegcInterval :== GCUtil.defaultMinForcegcInterval,
-    serverPort := 5000 + (Hash.toHex(Hash(appConfiguration.value.baseDirectory.toString)).## % 1000)
-  ))
-  def defaultTestTasks(key: Scoped): Seq[Setting[_]] = inTask(key)(Seq(
-    tags := Seq(Tags.Test -> 1),
-    logBuffered := true
-  ))
+    fileConverter := MappedFileConverter(rootPaths.value, allowMachinePath.value),
+    sourcePositionMappers := Nil, // Never set a default sourcePositionMapper, see #6352! Whatever you are trying to solve, do it in the foldMappers method.
+    // The virtual file value cache needs to be global or sbt will run out of direct byte buffer memory.
+    classpathDefinesClassCache := VirtualFileValueCache.definesClassCache(fileConverter.value),
+    fullServerHandlers := {
+      Seq(
+        LanguageServerProtocol.handler(fileConverter.value),
+        BuildServerProtocol.handler(
+          loadedBuild.value,
+          bspWorkspace.value,
+          sbtVersion.value,
+          semanticdbEnabled.value,
+          semanticdbVersion.value
+        ),
+        VirtualTerminal.handler,
+      ) ++ serverHandlers.value :+ ServerHandler.fallback
+    },
+    timeWrappedStamper := Stamps
+      .timeWrapBinaryStamps(Stamps.uncachedStamps(fileConverter.value), fileConverter.value),
+    reusableStamper := {
+      val converter = fileConverter.value
+      val unmanagedCache = unmanagedFileStampCache.value
+      val managedCache = managedFileStampCache.value
+      val backing = timeWrappedStamper.value
+      new xsbti.compile.analysis.ReadStamps {
+        def getAllLibraryStamps()
+            : java.util.Map[xsbti.VirtualFileRef, xsbti.compile.analysis.Stamp] =
+          backing.getAllLibraryStamps()
+        def getAllProductStamps()
+            : java.util.Map[xsbti.VirtualFileRef, xsbti.compile.analysis.Stamp] =
+          backing.getAllProductStamps()
+        def getAllSourceStamps()
+            : java.util.Map[xsbti.VirtualFileRef, xsbti.compile.analysis.Stamp] =
+          new java.util.HashMap[xsbti.VirtualFileRef, xsbti.compile.analysis.Stamp]
+        def library(fr: xsbti.VirtualFileRef): xsbti.compile.analysis.Stamp = backing.library(fr)
+        def product(fr: xsbti.VirtualFileRef): xsbti.compile.analysis.Stamp = backing.product(fr)
+        def source(fr: xsbti.VirtualFile): xsbti.compile.analysis.Stamp = {
+          val path = converter.toPath(fr)
+          unmanagedCache
+            .get(path)
+            .orElse(managedCache.getOrElseUpdate(path, sbt.nio.FileStamper.Hash))
+            .map(_.stamp)
+            .getOrElse(backing.source(fr))
+        }
+      }
+    },
+  )
+
+  private[sbt] def toAbsoluteSource(fc: FileConverter)(pos: Position): Position = {
+    val newPath: Option[NioPath] = pos
+      .sourcePath()
+      .asScala
+      .flatMap { path =>
+        try {
+          Some(fc.toPath(VirtualFileRef.of(path)))
+        } catch {
+          // catch all to trap wierd path injected by compiler, users, or plugins
+          case NonFatal(_) => None
+        }
+      }
+
+    newPath
+      .map { path =>
+        new Position {
+          override def line(): Optional[Integer] = pos.line()
+
+          override def lineContent(): String = pos.lineContent()
+
+          override def offset(): Optional[Integer] = pos.offset()
+
+          override def pointer(): Optional[Integer] = pos.pointer()
+
+          override def pointerSpace(): Optional[String] = pos.pointerSpace()
+
+          override def sourcePath(): Optional[String] = Optional.of(path.toAbsolutePath.toString)
+
+          override def sourceFile(): Optional[File] =
+            (try {
+              Some(path.toFile.getAbsoluteFile)
+            } catch {
+              case NonFatal(_) => None
+            }).toOptional
+
+          override def startOffset(): Optional[Integer] = pos.startOffset()
+
+          override def endOffset(): Optional[Integer] = pos.endOffset()
+
+          override def startLine(): Optional[Integer] = pos.startLine()
+
+          override def startColumn(): Optional[Integer] = pos.startColumn()
+
+          override def endLine(): Optional[Integer] = pos.endLine()
+
+          override def endColumn(): Optional[Integer] = pos.endColumn()
+        }
+      }
+      .getOrElse(pos)
+  }
+
+  // csrCacheDirectory is scoped to ThisBuild to allow customization.
+  private[sbt] lazy val buildLevelIvySettings: Seq[Setting[_]] = Seq(
+    csrCacheDirectory := {
+      if (useCoursier.value) LMCoursier.defaultCacheLocation
+      else Classpaths.dummyCoursierDirectory(appConfiguration.value)
+    },
+  )
+
+  def defaultTestTasks(key: Scoped): Seq[Setting[_]] =
+    inTask(key)(
+      Seq(
+        tags := Seq(Tags.Test -> 1),
+        logBuffered := true
+      )
+    )
+
   // TODO: This should be on the new default settings for a project.
   def projectCore: Seq[Setting[_]] = Seq(
     name := thisProject.value.id,
-    logManager := LogManager.defaults(extraLoggers.value, StandardMain.console),
-    onLoadMessage := (onLoadMessage or (name, thisProjectRef)("Set current project to " + _ + " (in build " + _.build + ")")).value
+    logManager := LogManager.defaults(extraAppenders.value, ConsoleOut.terminalOut),
+    onLoadMessage := (onLoadMessage or
+      Def.setting {
+        s"set current project to ${name.value} (in build ${thisProjectRef.value.build})"
+      }).value
   )
-  def paths = Seq(
+
+  // Appended to JvmPlugin.projectSettings
+  def paths: Seq[Setting[_]] = Seq(
     baseDirectory := thisProject.value.base,
     target := baseDirectory.value / "target",
-    historyPath := (historyPath or target(t => Option(t / ".history"))).value,
+    // Use a different history path for jline3 because the jline2 format is
+    // incompatible. By sbt 1.4.0, we should consider revering this to t / ".history"
+    // and possibly rewriting the jline2 history in a jline3 compatible format if the
+    // history file is incompatible. For now, just use a different file to facilitate
+    // going back and forth between 1.3.x and 1.4.x.
+    historyPath := (historyPath or target(t => Option(t / ".history3"))).value,
     sourceDirectory := baseDirectory.value / "src",
     sourceManaged := crossTarget.value / "src_managed",
-    resourceManaged := crossTarget.value / "resource_managed"
+    resourceManaged := crossTarget.value / "resource_managed",
+    // Adds subproject build.sbt files to the global list of build files to monitor
+    Scope.Global / checkBuildSources / pollInterval :==
+      new FiniteDuration(Int.MinValue, TimeUnit.MILLISECONDS),
+    Scope.Global / checkBuildSources / fileInputs += baseDirectory.value.toGlob / "*.sbt",
   )
 
   lazy val configPaths = sourceConfigPaths ++ resourceConfigPaths ++ outputConfigPaths
@@ -228,138 +570,446 @@ object Defaults extends BuildCommon {
     sourceManaged := configSrcSub(sourceManaged).value,
     scalaSource := sourceDirectory.value / "scala",
     javaSource := sourceDirectory.value / "java",
-    unmanagedSourceDirectories := makeCrossSources(scalaSource.value, javaSource.value, scalaBinaryVersion.value, crossPaths.value),
-    unmanagedSources := collectFiles(unmanagedSourceDirectories, includeFilter in unmanagedSources, excludeFilter in unmanagedSources).value,
-    watchSources in ConfigGlobal ++= unmanagedSources.value,
+    unmanagedSourceDirectories := {
+      val isDotty = ScalaInstance.isDotty(scalaVersion.value)
+      val epochVersion = if (isDotty) "3" else "2"
+      makeCrossSources(
+        scalaSource.value,
+        javaSource.value,
+        scalaBinaryVersion.value,
+        epochVersion,
+        crossPaths.value
+      ) ++
+        makePluginCrossSources(
+          sbtPlugin.value,
+          scalaSource.value,
+          (pluginCrossBuild / sbtBinaryVersion).value,
+          crossPaths.value
+        )
+    },
+    unmanagedSources / fileInputs := {
+      val include = (unmanagedSources / includeFilter).value
+      val filter = (unmanagedSources / excludeFilter).value match {
+        // Hidden files are already filtered out by the FileStamps method
+        case NothingFilter | HiddenFileFilter => include
+        case exclude                          => include -- exclude
+      }
+      val baseSources =
+        if (sourcesInBase.value) Globs(baseDirectory.value.toPath, recursive = false, filter) :: Nil
+        else Nil
+      unmanagedSourceDirectories.value
+        .map(d => Globs(d.toPath, recursive = true, filter)) ++ baseSources
+    },
+    unmanagedSources := (unmanagedSources / inputFileStamps).value.map(_._1.toFile),
     managedSourceDirectories := Seq(sourceManaged.value),
-    managedSources := generate(sourceGenerators).value,
+    managedSources := {
+      val stamper = inputFileStamper.value
+      val cache = managedFileStampCache.value
+      val res = generate(sourceGenerators).value
+      res.foreach { f =>
+        cache.putIfAbsent(f.toPath, stamper)
+      }
+      res
+    },
+    managedSourcePaths / outputFileStamper := sbt.nio.FileStamper.Hash,
+    managedSourcePaths := managedSources.value.map(_.toPath),
     sourceGenerators :== Nil,
-    sourceDirectories := Classpaths.concatSettings(unmanagedSourceDirectories, managedSourceDirectories).value,
-    sources := Classpaths.concat(unmanagedSources, managedSources).value
+    sourceDirectories := Classpaths
+      .concatSettings(unmanagedSourceDirectories, managedSourceDirectories)
+      .value,
+    sources := Classpaths.concatDistinct(unmanagedSources, managedSources).value
   )
   lazy val resourceConfigPaths = Seq(
     resourceDirectory := sourceDirectory.value / "resources",
     resourceManaged := configSrcSub(resourceManaged).value,
     unmanagedResourceDirectories := Seq(resourceDirectory.value),
     managedResourceDirectories := Seq(resourceManaged.value),
-    resourceDirectories := Classpaths.concatSettings(unmanagedResourceDirectories, managedResourceDirectories).value,
-    unmanagedResources := collectFiles(unmanagedResourceDirectories, includeFilter in unmanagedResources, excludeFilter in unmanagedResources).value,
-    watchSources in ConfigGlobal ++= unmanagedResources.value,
+    resourceDirectories := Classpaths
+      .concatSettings(unmanagedResourceDirectories, managedResourceDirectories)
+      .value,
+    unmanagedResources / fileInputs := {
+      val include = (unmanagedResources / includeFilter).value
+      val filter = (unmanagedResources / excludeFilter).value match {
+        // Hidden files are already filtered out by the FileStamps method
+        case NothingFilter | HiddenFileFilter => include
+        case exclude                          => include -- exclude
+      }
+      unmanagedResourceDirectories.value.map(d => Globs(d.toPath, recursive = true, filter))
+    },
+    unmanagedResources := (unmanagedResources / inputFileStamps).value.map(_._1.toFile),
     resourceGenerators :== Nil,
-    resourceGenerators += ((discoveredSbtPlugins, resourceManaged) map PluginDiscovery.writeDescriptors).taskValue,
+    resourceGenerators += Def.task {
+      PluginDiscovery.writeDescriptors(discoveredSbtPlugins.value, resourceManaged.value)
+    },
     managedResources := generate(resourceGenerators).value,
     resources := Classpaths.concat(managedResources, unmanagedResources).value
   )
-  lazy val outputConfigPaths = Seq(
+  // This exists for binary compatibility and probably never should have been public.
+  def addBaseSources: Seq[Def.Setting[Task[Seq[File]]]] = Nil
+  lazy val outputConfigPaths: Seq[Setting[_]] = Seq(
     classDirectory := crossTarget.value / (prefix(configuration.value.name) + "classes"),
-    target in doc := crossTarget.value / (prefix(configuration.value.name) + "api")
-  )
-  def addBaseSources = Seq(
-    unmanagedSources := {
-      val srcs = unmanagedSources.value
-      val f = (includeFilter in unmanagedSources).value
-      val excl = (excludeFilter in unmanagedSources).value
-      if (sourcesInBase.value) (srcs +++ baseDirectory.value * (f -- excl)).get else srcs
-    }
+    backendOutput := {
+      val converter = fileConverter.value
+      val dir = classDirectory.value
+      converter.toVirtualFile(dir.toPath)
+    },
+    earlyOutput / artifactPath := configArtifactPathSetting(artifact, "early").value,
+    earlyOutput := {
+      val converter = fileConverter.value
+      val jar = (earlyOutput / artifactPath).value
+      converter.toVirtualFile(jar.toPath)
+    },
+    semanticdbTargetRoot := crossTarget.value / (prefix(configuration.value.name) + "meta"),
+    compileAnalysisTargetRoot := crossTarget.value / (prefix(configuration.value.name) + "zinc"),
+    earlyCompileAnalysisTargetRoot := crossTarget.value / (prefix(configuration.value.name) + "early-zinc"),
+    doc / target := crossTarget.value / (prefix(configuration.value.name) + "api")
   )
 
+  // This is included into JvmPlugin.projectSettings
   def compileBase = inTask(console)(compilersSetting :: Nil) ++ compileBaseGlobal ++ Seq(
-    incOptions := incOptions.value.withClassfileManagerType(
-      Maybe.just(new TransactionalManagerType(crossTarget.value / "classes.bak", sbt.util.Logger.Null))),
     scalaInstance := scalaInstanceTask.value,
-    crossVersion := (if (crossPaths.value) CrossVersion.binary else CrossVersion.Disabled),
-    crossTarget := makeCrossTarget(target.value, scalaBinaryVersion.value, sbtBinaryVersion.value, sbtPlugin.value, crossPaths.value),
-    clean := {
-      val _ = clean.value
-      IvyActions.cleanCachedResolutionCache(ivyModule.value, streams.value.log)
+    crossVersion := (if (crossPaths.value) CrossVersion.binary else CrossVersion.disabled),
+    pluginCrossBuild / sbtBinaryVersion := binarySbtVersion(
+      (pluginCrossBuild / sbtVersion).value
+    ),
+    // Use (sbtVersion in pluginCrossBuild) to pick the sbt module to depend from the plugin.
+    // Because `sbtVersion in pluginCrossBuild` can be scoped to project level,
+    // this setting needs to be set here too.
+    pluginCrossBuild / sbtDependency := {
+      val app = appConfiguration.value
+      val id = app.provider.id
+      val sv = (pluginCrossBuild / sbtVersion).value
+      val scalaV = (pluginCrossBuild / scalaVersion).value
+      val binVersion = (pluginCrossBuild / scalaBinaryVersion).value
+      val cross = id.crossVersionedValue match {
+        case CrossValue.Disabled => Disabled()
+        case CrossValue.Full     => CrossVersion.full
+        case CrossValue.Binary   => CrossVersion.binary
+      }
+      val base = ModuleID(id.groupID, id.name, sv).withCrossVersion(cross)
+      CrossVersion(scalaV, binVersion)(base).withCrossVersion(Disabled())
     },
-    scalaCompilerBridgeSource := Compiler.defaultCompilerBridgeSource(scalaVersion.value)
+    crossSbtVersions := Vector((pluginCrossBuild / sbtVersion).value),
+    crossTarget := makeCrossTarget(
+      target.value,
+      scalaBinaryVersion.value,
+      (pluginCrossBuild / sbtBinaryVersion).value,
+      sbtPlugin.value,
+      crossPaths.value
+    ),
+    cleanIvy := IvyActions.cleanCachedResolutionCache(ivyModule.value, streams.value.log),
+    clean := clean.dependsOn(cleanIvy).value,
+    scalaCompilerBridgeBinaryJar := Def.settingDyn {
+      val sv = scalaVersion.value
+      if (ScalaArtifacts.isScala3(sv)) fetchBridgeBinaryJarTask(sv)
+      else Def.task[Option[File]](None)
+    }.value,
+    scalaCompilerBridgeSource := ZincLmUtil.getDefaultBridgeSourceModule(scalaVersion.value),
+    auxiliaryClassFiles ++= {
+      if (ScalaArtifacts.isScala3(scalaVersion.value)) List(TastyFiles.instance)
+      else Nil
+    },
+    consoleProject / scalaCompilerBridgeBinaryJar := None,
+    consoleProject / scalaCompilerBridgeSource := ZincLmUtil.getDefaultBridgeSourceModule(
+      appConfiguration.value.provider.scalaProvider.version
+    ),
   )
   // must be a val: duplication detected by object identity
-  private[this] lazy val compileBaseGlobal: Seq[Setting[_]] = globalDefaults(Seq(
-    incOptions := IncOptionsUtil.defaultIncOptions,
-    classpathOptions :== ClasspathOptionsUtil.boot,
-    classpathOptions in console :== ClasspathOptionsUtil.repl,
-    compileOrder :== CompileOrder.Mixed,
-    javacOptions :== Nil,
-    scalacOptions :== Nil,
-    scalaVersion := appConfiguration.value.provider.scalaProvider.version,
-    derive(crossScalaVersions := Seq(scalaVersion.value)),
-    derive(compilersSetting),
-    derive(scalaBinaryVersion := binaryScalaVersion(scalaVersion.value))
-  ))
+  private[this] lazy val compileBaseGlobal: Seq[Setting[_]] = globalDefaults(
+    Seq(
+      auxiliaryClassFiles :== Nil,
+      incOptions := IncOptions.of(),
+      classpathOptions :== ClasspathOptionsUtil.boot,
+      console / classpathOptions :== ClasspathOptionsUtil.repl,
+      compileOrder :== CompileOrder.Mixed,
+      javacOptions :== Nil,
+      scalacOptions :== Nil,
+      scalaVersion := appConfiguration.value.provider.scalaProvider.version,
+      derive(crossScalaVersions := Seq(scalaVersion.value)),
+      derive(compilersSetting),
+      derive(scalaBinaryVersion := binaryScalaVersion(scalaVersion.value))
+    )
+  )
 
-  def makeCrossSources(scalaSrcDir: File, javaSrcDir: File, sv: String, cross: Boolean): Seq[File] = {
+  def makeCrossSources(
+      scalaSrcDir: File,
+      javaSrcDir: File,
+      sv: String,
+      epochVersion: String,
+      cross: Boolean
+  ): Seq[File] = {
+    if (cross)
+      Seq(
+        scalaSrcDir,
+        scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-$sv",
+        scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-$epochVersion",
+        javaSrcDir,
+      )
+    else
+      Seq(scalaSrcDir, javaSrcDir)
+  }
+
+  def makeCrossSources(
+      scalaSrcDir: File,
+      javaSrcDir: File,
+      sv: String,
+      cross: Boolean
+  ): Seq[File] = {
     if (cross)
       Seq(scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-$sv", scalaSrcDir, javaSrcDir)
     else
       Seq(scalaSrcDir, javaSrcDir)
   }
 
-  def makeCrossTarget(t: File, sv: String, sbtv: String, plugin: Boolean, cross: Boolean): File =
-    {
-      val scalaBase = if (cross) t / ("scala-" + sv) else t
-      if (plugin) scalaBase / ("sbt-" + sbtv) else scalaBase
+  def makePluginCrossSources(
+      isPlugin: Boolean,
+      scalaSrcDir: File,
+      sbtBinaryV: String,
+      cross: Boolean
+  ): Seq[File] = {
+    if (cross && isPlugin)
+      Vector(scalaSrcDir.getParentFile / s"${scalaSrcDir.name}-sbt-$sbtBinaryV")
+    else Vector()
+  }
+
+  def makeCrossTarget(t: File, sv: String, sbtv: String, plugin: Boolean, cross: Boolean): File = {
+    val scalaBase = if (cross) t / ("scala-" + sv) else t
+    if (plugin) scalaBase / ("sbt-" + sbtv) else scalaBase
+  }
+
+  private def fetchBridgeBinaryJarTask(scalaVersion: String): Initialize[Task[Option[File]]] =
+    Def.task {
+      val bridgeJar = ZincLmUtil.fetchDefaultBridgeModule(
+        scalaVersion,
+        dependencyResolution.value,
+        updateConfiguration.value,
+        (update / unresolvedWarningConfiguration).value,
+        streams.value.log
+      )
+      Some(bridgeJar)
     }
 
-  def compilersSetting = compilers := Compiler.compilers(scalaInstance.value, classpathOptions.value, javaHome.value,
-    bootIvyConfiguration.value, scalaCompilerBridgeSource.value)(appConfiguration.value, streams.value.log)
+  def compilersSetting = {
+    compilers := {
+      val st = state.value
+      val g = BuildPaths.getGlobalBase(st)
+      val zincDir = BuildPaths.getZincDirectory(st, g)
+      val app = appConfiguration.value
+      val launcher = app.provider.scalaProvider.launcher
+      val dr = scalaCompilerBridgeDependencyResolution.value
+      val scalac =
+        scalaCompilerBridgeBinaryJar.value match {
+          case Some(jar) =>
+            AlternativeZincUtil.scalaCompiler(
+              scalaInstance = scalaInstance.value,
+              classpathOptions = classpathOptions.value,
+              compilerBridgeJar = jar,
+              classLoaderCache = st.get(BasicKeys.classLoaderCache)
+            )
+          case _ =>
+            ZincLmUtil.scalaCompiler(
+              scalaInstance = scalaInstance.value,
+              classpathOptions = classpathOptions.value,
+              globalLock = launcher.globalLock,
+              componentProvider = app.provider.components,
+              secondaryCacheDir = Option(zincDir),
+              dependencyResolution = dr,
+              compilerBridgeSource = scalaCompilerBridgeSource.value,
+              scalaJarsTarget = zincDir,
+              classLoaderCache = st.get(BasicKeys.classLoaderCache),
+              log = streams.value.log
+            )
+        }
+      val compilers = ZincUtil.compilers(
+        instance = scalaInstance.value,
+        classpathOptions = classpathOptions.value,
+        javaHome = javaHome.value.map(_.toPath),
+        scalac
+      )
+      val classLoaderCache = state.value.classLoaderCache
+      if (java.lang.Boolean.getBoolean("sbt.disable.interface.classloader.cache")) compilers
+      else {
+        compilers.withScalac(
+          compilers.scalac match {
+            case x: AnalyzingCompiler => x.withClassLoaderCache(classLoaderCache)
+            case x                    => x
+          }
+        )
+      }
+    }
+  }
 
-  lazy val configTasks = docTaskSettings(doc) ++ inTask(compile)(compileInputsSettings) ++ configGlobal ++ compileAnalysisSettings ++ Seq(
+  def defaultCompileSettings: Seq[Setting[_]] =
+    globalDefaults(enableBinaryCompileAnalysis := true)
+
+  lazy val configTasks: Seq[Setting[_]] = docTaskSettings(doc) ++
+    inTask(compile)(compileInputsSettings) ++
+    inTask(compileJava)(
+      Seq(
+        compileInputs := {
+          val opts = (compileJava / compileOptions).value
+          (compile / compileInputs).value.withOptions(opts)
+        },
+        compileOptions := {
+          val opts = (compile / compileOptions).value
+          val cp0 = dependencyVirtualClasspath.value
+          val cp = backendOutput.value +: data(cp0)
+          opts.withClasspath(cp.toArray)
+        }
+      )
+    ) ++
+    configGlobal ++ defaultCompileSettings ++ compileAnalysisSettings ++ Seq(
+    compileOutputs := {
+      import scala.collection.JavaConverters._
+      val c = fileConverter.value
+      val classFiles =
+        manipulateBytecode.value.analysis.readStamps.getAllProductStamps.keySet.asScala
+      (classFiles.toSeq map { x =>
+        c.toPath(x)
+      }) :+ compileAnalysisFile.value.toPath
+    },
+    compileOutputs := compileOutputs.triggeredBy(compile).value,
+    tastyFiles := Def.taskIf {
+      if (ScalaArtifacts.isScala3(scalaVersion.value)) {
+        val _ = compile.value
+        val tastyFiles = classDirectory.value.**("*.tasty").get
+        tastyFiles.map(_.getAbsoluteFile)
+      } else Nil
+    }.value,
+    clean := (compileOutputs / clean).value,
+    earlyOutputPing := Def.promise[Boolean],
+    compileProgress := {
+      val s = streams.value
+      val promise = earlyOutputPing.value
+      val mn = moduleName.value
+      val c = configuration.value
+      new CompileProgress {
+        override def afterEarlyOutput(isSuccess: Boolean): Unit = {
+          if (isSuccess) s.log.debug(s"[$mn / $c] early output is success")
+          else s.log.debug(s"[$mn / $c] early output can't be made because of macros")
+          promise.complete(Value(isSuccess))
+        }
+      }
+    },
+    compileEarly := compileEarlyTask.value,
     compile := compileTask.value,
-    manipulateBytecode := compileIncremental.value,
-    compileIncremental := (compileIncrementalTask tag (Tags.Compile, Tags.CPU)).value,
+    compileScalaBackend := compileScalaBackendTask.value,
+    compileJava := compileJavaTask.value,
+    compileSplit := {
+      // conditional task
+      if (incOptions.value.pipelining) compileJava.value
+      else compileScalaBackend.value
+    },
+    internalDependencyConfigurations := InternalDependencies.configurations.value,
+    manipulateBytecode := compileSplit.value,
+    compileIncremental := compileIncrementalTask.tag(Tags.Compile, Tags.CPU).value,
     printWarnings := printWarningsTask.value,
     compileAnalysisFilename := {
       // Here, if the user wants cross-scala-versioning, we also append it
       // to the analysis cache, so we keep the scala versions separated.
+      val binVersion = scalaBinaryVersion.value
       val extra =
-        if (crossPaths.value) s"_${scalaBinaryVersion.value}"
+        if (crossPaths.value) s"_$binVersion"
         else ""
-      s"inc_compile${extra}.zip"
+      s"inc_compile$extra.zip"
+    },
+    earlyCompileAnalysisFile := {
+      earlyCompileAnalysisTargetRoot.value / compileAnalysisFilename.value
+    },
+    compileAnalysisFile := {
+      compileAnalysisTargetRoot.value / compileAnalysisFilename.value
+    },
+    externalHooks := IncOptions.defaultExternal,
+    incOptions := {
+      val old = incOptions.value
+      old
+        .withAuxiliaryClassFiles(auxiliaryClassFiles.value.toArray)
+        .withExternalHooks(externalHooks.value)
+        .withClassfileManagerType(
+          Option(
+            TransactionalManagerType
+              .of( // https://github.com/sbt/sbt/issues/1673
+                crossTarget.value / s"${prefix(configuration.value.name)}classes.bak",
+                streams.value.log
+              ): ClassFileManagerType
+          ).toOptional
+        )
+        .withPipelining(usePipelining.value)
+    },
+    scalacOptions := {
+      val old = scalacOptions.value
+      val converter = fileConverter.value
+      if (exportPipelining.value)
+        Vector("-Ypickle-java", "-Ypickle-write", converter.toPath(earlyOutput.value).toString) ++ old
+      else old
+    },
+    persistJarClasspath :== true,
+    classpathEntryDefinesClassVF := {
+      (if (persistJarClasspath.value) classpathDefinesClassCache.value
+       else VirtualFileValueCache.definesClassCache(fileConverter.value)).get
     },
     compileIncSetup := compileIncSetupTask.value,
     console := consoleTask.value,
+    collectAnalyses := Definition.collectAnalysesTask.map(_ => ()).value,
     consoleQuick := consoleQuickTask.value,
     discoveredMainClasses := (compile map discoverMainClasses storeAs discoveredMainClasses xtriggeredBy compile).value,
     discoveredSbtPlugins := discoverSbtPluginNames.value,
-    inTask(run)(runnerTask :: Nil).head,
+    // This fork options, scoped to the configuration is used for tests
+    forkOptions := forkOptionsTask.value,
     selectMainClass := mainClass.value orElse askForMainClass(discoveredMainClasses.value),
-    mainClass in run := (selectMainClass in run).value,
-    mainClass := pickMainClassOrWarn(discoveredMainClasses.value, streams.value.log),
-    run := runTask(fullClasspath, mainClass in run, runner in run).evaluated,
-    runMain := runMainTask(fullClasspath, runner in run).evaluated,
-    copyResources := copyResourcesTask.value
-  )
+    run / mainClass := (run / selectMainClass).value,
+    mainClass := {
+      val logWarning = state.value.currentCommand
+        .flatMap(_.commandLine.split(" ").headOption.map(_.trim))
+        .fold(true) {
+          case "run" | "runMain" => false
+          case _                 => true
+        }
+      pickMainClassOrWarn(discoveredMainClasses.value, streams.value.log, logWarning)
+    },
+    runMain := foregroundRunMainTask.evaluated,
+    run := foregroundRunTask.evaluated,
+    fgRun := runTask(fullClasspath, (run / mainClass), (run / runner)).evaluated,
+    fgRunMain := runMainTask(fullClasspath, (run / runner)).evaluated,
+    copyResources := copyResourcesTask.value,
+    // note that we use the same runner and mainClass as plain run
+    mainBgRunMainTaskForConfig(This),
+    mainBgRunTaskForConfig(This)
+  ) ++ inTask(run)(runnerSettings ++ newRunnerSettings)
 
-  private[this] lazy val configGlobal = globalDefaults(Seq(
-    initialCommands :== "",
-    cleanupCommands :== ""
-  ))
+  private[this] lazy val configGlobal = globalDefaults(
+    Seq(
+      initialCommands :== "",
+      cleanupCommands :== "",
+      asciiGraphWidth :== 80
+    )
+  )
 
   lazy val projectTasks: Seq[Setting[_]] = Seq(
-    cleanFiles := Seq(managedDirectory.value, target.value),
-    cleanKeepFiles := historyPath.value.toList,
-    clean := doClean(cleanFiles.value, cleanKeepFiles.value),
+    cleanFiles := cleanFilesTask.value,
+    cleanKeepFiles := Vector.empty,
+    cleanKeepGlobs ++= historyPath.value.map(_.toGlob).toVector,
+    clean := Def.taskDyn(Clean.task(resolvedScoped.value.scope, full = true)).value,
     consoleProject := consoleProjectTask.value,
-    watchTransitiveSources := watchTransitiveSourcesTask.value,
-    watch := watchSetting.value
+    transitiveDynamicInputs := WatchTransitiveDependencies.task.value,
+  ) ++ sbt.internal.DeprecatedContinuous.taskDefinitions
+
+  def generate(generators: SettingKey[Seq[Task[Seq[File]]]]): Initialize[Task[Seq[File]]] =
+    generators { _.join.map(_.flatten) }
+
+  @deprecated(
+    "The watchTransitiveSourcesTask is used only for legacy builds and will be removed in a future version of sbt.",
+    "1.3.0"
   )
+  def watchTransitiveSourcesTask: Initialize[Task[Seq[Source]]] =
+    watchTransitiveSourcesTaskImpl(watchSources)
 
-  def generate(generators: SettingKey[Seq[Task[Seq[File]]]]): Initialize[Task[Seq[File]]] = generators { _.join.map(_.flatten) }
-
-  @deprecated("Use the new <key>.all(<ScopeFilter>) API", "0.13.0")
-  def inAllConfigurations[T](key: TaskKey[T]): Initialize[Task[Seq[T]]] = (state, thisProjectRef) flatMap { (state, ref) =>
-    val structure = Project structure state
-    val configurations = Project.getProject(ref, structure).toList.flatMap(_.configurations)
-    configurations.flatMap { conf =>
-      key in (ref, conf) get structure.data
-    } join
-  }
-  def watchTransitiveSourcesTask: Initialize[Task[Seq[File]]] = {
+  private def watchTransitiveSourcesTaskImpl(
+      key: TaskKey[Seq[Source]]
+  ): Initialize[Task[Seq[Source]]] = {
     import ScopeFilter.Make.{ inDependencies => inDeps, _ }
     val selectDeps = ScopeFilter(inAggregates(ThisProject) || inDeps(ThisProject))
-    val allWatched = (watchSources ?? Nil).all(selectDeps)
+    val allWatched = (key ?? Nil).all(selectDeps)
     Def.task { allWatched.value.flatten }
   }
 
@@ -371,23 +1021,32 @@ object Defaults extends BuildCommon {
     Def.task { allUpdates.value.flatten ++ globalPluginUpdate.?.value }
   }
 
-  def watchSetting: Initialize[Watched] = (pollInterval, thisProjectRef, watchingMessage, triggeredMessage) { (interval, base, msg, trigMsg) =>
-    new Watched {
-      val scoped = watchTransitiveSources in base
-      val key = ScopedKey(scoped.scope, scoped.key)
-      override def pollInterval = interval
-      override def watchingMessage(s: WatchState) = msg(s)
-      override def triggeredMessage(s: WatchState) = trigMsg(s)
-      override def watchPaths(s: State) = EvaluateTask(Project structure s, key, s, base) match {
-        case Some((_, Value(ps))) => ps
-        case Some((_, Inc(i)))    => throw i
-        case None                 => sys.error("key not found: " + Def.displayFull(key))
+  @deprecated("This is no longer used to implement continuous execution", "1.3.0")
+  def watchSetting: Initialize[Watched] =
+    Def.setting {
+      val getService = watchService.value
+      val interval = pollInterval.value
+      val _antiEntropy = watchAntiEntropy.value
+      val base = thisProjectRef.value
+      val msg = watchingMessage.?.value.getOrElse(Watched.defaultWatchingMessage)
+      val trigMsg = triggeredMessage.?.value.getOrElse(Watched.defaultTriggeredMessage)
+      new Watched {
+        val scoped = (base / watchTransitiveSources)
+        val key = scoped.scopedKey
+        override def antiEntropy: FiniteDuration = _antiEntropy
+        override def pollInterval: FiniteDuration = interval
+        override def watchingMessage(s: WatchState) = msg(s)
+        override def triggeredMessage(s: WatchState) = trigMsg(s)
+        override def watchService() = getService()
+        override def watchSources(s: State) =
+          EvaluateTask(Project structure s, key, s, base) match {
+            case Some((_, Value(ps))) => ps
+            case Some((_, Inc(i)))    => throw i
+            case None                 => sys.error("key not found: " + Def.displayFull(key))
+          }
       }
     }
-  }
 
-  @deprecated("Use scalaInstanceTask.", "0.13.0")
-  def scalaInstanceSetting = scalaInstanceTask
   def scalaInstanceTask: Initialize[Task[ScalaInstance]] = Def.taskDyn {
     // if this logic changes, ensure that `unmanagedScalaInstanceOnly` and `update` are changed
     //  appropriately to avoid cycles
@@ -397,193 +1056,382 @@ object Defaults extends BuildCommon {
         val scalaProvider = appConfiguration.value.provider.scalaProvider
         val version = scalaVersion.value
         if (version == scalaProvider.version) // use the same class loader as the Scala classes used by sbt
-          Def.task(ScalaInstance(version, scalaProvider))
-        else
+          Def.task {
+            val allJars = scalaProvider.jars
+            val libraryJars = allJars.filter(_.getName == "scala-library.jar")
+            allJars.filter(_.getName == "scala-compiler.jar") match {
+              case Array(compilerJar) if libraryJars.nonEmpty =>
+                val cache = state.value.extendedClassLoaderCache
+                mkScalaInstance(
+                  version,
+                  libraryJars,
+                  allJars,
+                  Seq.empty,
+                  cache,
+                  scalaInstanceTopLoader.value
+                )
+              case _ => ScalaInstance(version, scalaProvider)
+            }
+          } else
           scalaInstanceFromUpdate
     }
   }
+
   // Returns the ScalaInstance only if it was not constructed via `update`
   //  This is necessary to prevent cycles between `update` and `scalaInstance`
-  private[sbt] def unmanagedScalaInstanceOnly: Initialize[Task[Option[ScalaInstance]]] = Def.taskDyn {
-    if (scalaHome.value.isDefined) Def.task(Some(scalaInstance.value)) else Def.task(None)
-  }
-
-  private[this] def noToolConfiguration(autoInstance: Boolean): String =
-    {
-      val pre = "Missing Scala tool configuration from the 'update' report.  "
-      val post =
-        if (autoInstance)
-          "'scala-tool' is normally added automatically, so this may indicate a bug in sbt or you may be removing it from ivyConfigurations, for example."
-        else
-          "Explicitly define scalaInstance or scalaHome or include Scala dependencies in the 'scala-tool' configuration."
-      pre + post
+  private[sbt] def unmanagedScalaInstanceOnly: Initialize[Task[Option[ScalaInstance]]] =
+    Def.taskDyn {
+      if (scalaHome.value.isDefined) Def.task(Some(scalaInstance.value)) else Def.task(None)
     }
 
+  private[this] def noToolConfiguration(autoInstance: Boolean): String = {
+    val pre = "Missing Scala tool configuration from the 'update' report.  "
+    val post =
+      if (autoInstance)
+        "'scala-tool' is normally added automatically, so this may indicate a bug in sbt or you may be removing it from ivyConfigurations, for example."
+      else
+        "Explicitly define scalaInstance or scalaHome or include Scala dependencies in the 'scala-tool' configuration."
+    pre + post
+  }
+
   def scalaInstanceFromUpdate: Initialize[Task[ScalaInstance]] = Def.task {
-    val toolReport = update.value.configuration(Configurations.ScalaTool.name) getOrElse
-      sys.error(noToolConfiguration(managedScalaInstance.value))
-    def files(id: String) =
-      for {
-        m <- toolReport.modules if m.module.name == id;
+    val sv = scalaVersion.value
+    val fullReport = update.value
+
+    val toolReport = fullReport
+      .configuration(Configurations.ScalaTool)
+      .getOrElse(sys.error(noToolConfiguration(managedScalaInstance.value)))
+
+    def file(id: String): File = {
+      val files = for {
+        m <- toolReport.modules if m.module.name.startsWith(id)
         (art, file) <- m.artifacts if art.`type` == Artifact.DefaultType
       } yield file
-    def file(id: String) = files(id).headOption getOrElse sys.error(s"Missing ${id}.jar")
-    val allFiles = toolReport.modules.flatMap(_.artifacts.map(_._2))
-    val libraryJar = file(ScalaArtifacts.LibraryID)
-    val compilerJar =
-      if (ScalaInstance.isDotty(scalaVersion.value))
-        file(ScalaArtifacts.dottyID(scalaBinaryVersion.value))
-      else
-        file(ScalaArtifacts.CompilerID)
-    val otherJars = allFiles.filterNot(x => x == libraryJar || x == compilerJar)
-    new ScalaInstance(scalaVersion.value, makeClassLoader(state.value)(libraryJar :: compilerJar :: otherJars.toList), libraryJar, compilerJar, otherJars.toArray, None)
+      files.headOption getOrElse sys.error(s"Missing $id jar file")
+    }
+
+    val allCompilerJars = toolReport.modules.flatMap(_.artifacts.map(_._2))
+    val allDocJars =
+      fullReport
+        .configuration(Configurations.ScalaDocTool)
+        .toSeq
+        .flatMap(_.modules)
+        .flatMap(_.artifacts.map(_._2))
+    val libraryJars = ScalaArtifacts.libraryIds(sv).map(file)
+
+    mkScalaInstance(
+      sv,
+      libraryJars,
+      allCompilerJars,
+      allDocJars,
+      state.value.extendedClassLoaderCache,
+      scalaInstanceTopLoader.value,
+    )
+  }
+  private[this] def mkScalaInstance(
+      version: String,
+      libraryJars: Array[File],
+      allCompilerJars: Seq[File],
+      allDocJars: Seq[File],
+      classLoaderCache: ClassLoaderCache,
+      topLoader: ClassLoader,
+  ): ScalaInstance = {
+    // Scala 2.10 shades jline in the console so we need to make sure that it loads a compatible
+    // jansi version. Because of the shading, console does not work with the thin client for 2.10.x.
+    val jansiExclusionLoader = if (version.startsWith("2.10.")) new ClassLoader(topLoader) {
+      override protected def loadClass(name: String, resolve: Boolean): Class[_] = {
+        if (name.startsWith("org.fusesource")) throw new ClassNotFoundException(name)
+        super.loadClass(name, resolve)
+      }
+    }
+    else topLoader
+
+    val compilerJars = allCompilerJars.filterNot(libraryJars.contains).distinct.toArray
+    val docJars = allDocJars
+      .filterNot(jar => libraryJars.contains(jar) || compilerJars.contains(jar))
+      .distinct
+      .toArray
+    val allJars = libraryJars ++ compilerJars ++ docJars
+
+    val libraryLoader = classLoaderCache(libraryJars.toList, jansiExclusionLoader)
+    val compilerLoader = classLoaderCache(
+      // It should be `compilerJars` but it would break on `3.0.0-M2` because of
+      // https://github.com/lampepfl/dotty/blob/d932af954ef187d7bdb87500d49ed0ff530bd1e7/sbt-bridge/src/xsbt/CompilerClassLoader.java#L108-L117
+      allCompilerJars.toList,
+      libraryLoader
+    )
+    val fullLoader =
+      if (docJars.isEmpty) compilerLoader
+      else classLoaderCache(docJars.distinct.toList, compilerLoader)
+    new ScalaInstance(
+      version = version,
+      loader = fullLoader,
+      loaderCompilerOnly = compilerLoader,
+      loaderLibraryOnly = libraryLoader,
+      libraryJars = libraryJars,
+      compilerJars = compilerJars,
+      allJars = allJars,
+      explicitActual = Some(version)
+    )
   }
   def scalaInstanceFromHome(dir: File): Initialize[Task[ScalaInstance]] = Def.task {
-    ScalaInstance(dir)(makeClassLoader(state.value))
+    val dummy = ScalaInstance(dir)(state.value.classLoaderCache.apply)
+    Seq(dummy.loader, dummy.loaderLibraryOnly).foreach {
+      case a: AutoCloseable => a.close()
+      case _                =>
+    }
+    mkScalaInstance(
+      dummy.version,
+      dummy.libraryJars,
+      dummy.compilerJars,
+      dummy.allJars,
+      state.value.extendedClassLoaderCache,
+      scalaInstanceTopLoader.value,
+    )
   }
-  private[this] def makeClassLoader(state: State) = state.classLoaderCache.apply _
 
-  private[this] def testDefaults = Defaults.globalDefaults(Seq(
-    testFrameworks :== {
-      import sbt.TestFrameworks._
-      Seq(ScalaCheck, Specs2, Specs, ScalaTest, JUnit)
+  private[this] def testDefaults =
+    Defaults.globalDefaults(
+      Seq(
+        testFrameworks :== {
+          import sbt.TestFrameworks._
+          Seq(ScalaCheck, Specs2, Specs, ScalaTest, JUnit, MUnit)
+        },
+        testListeners :== Nil,
+        testOptions :== Nil,
+        testResultLogger :== TestResultLogger.Default,
+        testOnly / testFilter :== (selectedFilter _)
+      )
+    )
+  lazy val testTasks
+      : Seq[Setting[_]] = testTaskOptions(test) ++ testTaskOptions(testOnly) ++ testTaskOptions(
+    testQuick
+  ) ++ testDefaults ++ Seq(
+    testLoader := ClassLoaders.testTask.value,
+    loadedTestFrameworks := {
+      val loader = testLoader.value
+      val log = streams.value.log
+      testFrameworks.value.flatMap(f => f.create(loader, log).map(x => (f, x)).toIterable).toMap
     },
-    testListeners :== Nil,
-    testOptions :== Nil,
-    testResultLogger :== TestResultLogger.Default,
-    testFilter in testOnly :== (selectedFilter _)
-  ))
-  lazy val testTasks: Seq[Setting[_]] = testTaskOptions(test) ++ testTaskOptions(testOnly) ++ testTaskOptions(testQuick) ++ testDefaults ++ Seq(
-    testLoader := TestFramework.createTestLoader(data(fullClasspath.value), scalaInstance.value, IO.createUniqueDirectory(taskTemporaryDirectory.value)),
-    loadedTestFrameworks := testFrameworks.value.flatMap(f => f.create(testLoader.value, streams.value.log).map(x => (f, x)).toIterable).toMap,
     definedTests := detectTests.value,
     definedTestNames := (definedTests map (_.map(_.name).distinct) storeAs definedTestNames triggeredBy compile).value,
-    testFilter in testQuick := testQuickFilter.value,
-    executeTests := ((streams in test, loadedTestFrameworks, testLoader, testGrouping in test, testExecution in test, fullClasspath in test, javaHome in test, testForkedParallel, javaOptions in test) flatMap allTestGroupsTask).value,
-    testResultLogger in (Test, test) :== TestResultLogger.SilentWhenNoTests, // https://github.com/sbt/sbt/issues/1185
+    testQuick / testFilter := testQuickFilter.value,
+    executeTests := (
+      Def.taskDyn {
+        allTestGroupsTask(
+          (test / streams).value,
+          loadedTestFrameworks.value,
+          testLoader.value,
+          (test / testGrouping).value,
+          (test / testExecution).value,
+          (test / fullClasspath).value,
+          testForkedParallel.value,
+          (test / javaOptions).value,
+          (classLoaderLayeringStrategy).value,
+          projectId = s"${thisProject.value.id} / ",
+        )
+      }
+    ).value,
+    // ((streams in test, loadedTestFrameworks, testLoader, testGrouping in test, testExecution in test, fullClasspath in test, javaHome in test, testForkedParallel, javaOptions in test) flatMap allTestGroupsTask).value,
+    Test / test / testResultLogger :== TestResultLogger.SilentWhenNoTests, // https://github.com/sbt/sbt/issues/1185
     test := {
-      val trl = (testResultLogger in (Test, test)).value
-      val taskName = Project.showContextKey(state.value)(resolvedScoped.value)
-      trl.run(streams.value.log, executeTests.value, taskName)
+      val trl = (Test / test / testResultLogger).value
+      val taskName = Project.showContextKey(state.value).show(resolvedScoped.value)
+      try trl.run(streams.value.log, executeTests.value, taskName)
+      finally close(testLoader.value)
     },
-    testOnly := inputTests(testOnly).evaluated,
-    testQuick := inputTests(testQuick).evaluated
+    testOnly := {
+      try inputTests(testOnly).evaluated
+      finally close(testLoader.value)
+    },
+    testQuick := {
+      try inputTests(testQuick).evaluated
+      finally close(testLoader.value)
+    }
   )
-  lazy val TaskGlobal: Scope = ThisScope.copy(task = Global)
-  lazy val ConfigGlobal: Scope = ThisScope.copy(config = Global)
-  def testTaskOptions(key: Scoped): Seq[Setting[_]] = inTask(key)(Seq(
-    testListeners := {
-      TestLogger.make(streams.value.log, closeableTestLogger(streamsManager.value, test in resolvedScoped.value.scope, logBuffered.value)) +:
-        new TestStatusReporter(succeededFile(streams.in(test).value.cacheDirectory)) +:
-        testListeners.in(TaskGlobal).value
-    },
-    testOptions := Tests.Listeners(testListeners.value) +: (testOptions in TaskGlobal).value,
-    testExecution := testExecutionTask(key).value
-  )) ++ inScope(GlobalScope)(Seq(
-    derive(testGrouping := singleTestGroupDefault.value)
-  ))
-  @deprecated("Doesn't provide for closing the underlying resources.", "0.13.1")
-  def testLogger(manager: Streams, baseKey: Scoped)(tdef: TestDefinition): Logger =
-    {
-      val scope = baseKey.scope
-      val extra = scope.extra match { case Select(x) => x; case _ => AttributeMap.empty }
-      val key = ScopedKey(scope.copy(extra = Select(testExtra(extra, tdef))), baseKey.key)
-      manager(key).log
+  private def close(sbtLoader: ClassLoader): Unit = sbtLoader match {
+    case u: AutoCloseable   => u.close()
+    case c: ClasspathFilter => c.close()
+    case _                  =>
+  }
+
+  /**
+   * A scope whose task axis is set to Zero.
+   */
+  lazy val TaskZero: Scope = ThisScope.copy(task = Zero)
+  lazy val TaskGlobal: Scope = TaskZero
+
+  /**
+   * A scope whose configuration axis is set to Zero.
+   */
+  lazy val ConfigZero: Scope = ThisScope.copy(config = Zero)
+  lazy val ConfigGlobal: Scope = ConfigZero
+  def testTaskOptions(key: Scoped): Seq[Setting[_]] =
+    inTask(key)(
+      Seq(
+        testListeners := {
+          val stateLogLevel = state.value.get(Keys.logLevel.key).getOrElse(Level.Info)
+          TestLogger.make(
+            streams.value.log,
+            closeableTestLogger(
+              streamsManager.value,
+              (resolvedScoped.value.scope / test),
+              logBuffered.value
+            ),
+            Keys.logLevel.?.value.getOrElse(stateLogLevel),
+          ) +:
+            new TestStatusReporter(succeededFile((test / streams).value.cacheDirectory)) +:
+            (TaskZero / testListeners).value
+        },
+        testOptions := Tests.Listeners(testListeners.value) +: (TaskZero / testOptions).value,
+        testExecution := testExecutionTask(key).value
+      )
+    ) ++ inScope(GlobalScope)(
+      Seq(
+        derive(testGrouping := singleTestGroupDefault.value)
+      )
+    )
+
+  private[this] def closeableTestLogger(manager: Streams, baseKey: Scoped, buffered: Boolean)(
+      tdef: TestDefinition
+  ): TestLogger.PerTest = {
+    val scope = baseKey.scope
+    val extra = scope.extra match { case Select(x) => x; case _ => AttributeMap.empty }
+    val key = ScopedKey(scope.copy(extra = Select(testExtra(extra, tdef))), baseKey.key)
+    val s = manager(key)
+    new TestLogger.PerTest(s.log, () => s.close(), buffered)
+  }
+
+  def testExtra(extra: AttributeMap, tdef: TestDefinition): AttributeMap = {
+    val mod = tdef.fingerprint match {
+      case f: SubclassFingerprint  => f.isModule
+      case f: AnnotatedFingerprint => f.isModule
+      case _                       => false
     }
-  private[this] def closeableTestLogger(manager: Streams, baseKey: Scoped, buffered: Boolean)(tdef: TestDefinition): TestLogger.PerTest =
-    {
-      val scope = baseKey.scope
-      val extra = scope.extra match { case Select(x) => x; case _ => AttributeMap.empty }
-      val key = ScopedKey(scope.copy(extra = Select(testExtra(extra, tdef))), baseKey.key)
-      val s = manager(key)
-      new TestLogger.PerTest(s.log, () => s.close(), buffered)
-    }
-  def buffered(log: Logger): Logger = new BufferedLogger(FullLogger(log))
-  def testExtra(extra: AttributeMap, tdef: TestDefinition): AttributeMap =
-    {
-      val mod = tdef.fingerprint match { case f: SubclassFingerprint => f.isModule; case f: AnnotatedFingerprint => f.isModule; case _ => false }
-      extra.put(name.key, tdef.name).put(isModule, mod)
-    }
-  def singleTestGroup(key: Scoped): Initialize[Task[Seq[Tests.Group]]] = inTask(key, singleTestGroupDefault)
+    extra.put(name.key, tdef.name).put(isModule, mod)
+  }
+
+  def singleTestGroup(key: Scoped): Initialize[Task[Seq[Tests.Group]]] =
+    inTask(key, singleTestGroupDefault)
   def singleTestGroupDefault: Initialize[Task[Seq[Tests.Group]]] = Def.task {
     val tests = definedTests.value
     val fk = fork.value
     val opts = forkOptions.value
-    Seq(new Tests.Group("<default>", tests, if (fk) Tests.SubProcess(opts) else Tests.InProcess))
+    Seq(
+      new Tests.Group(
+        "<default>",
+        tests,
+        if (fk) Tests.SubProcess(opts) else Tests.InProcess,
+        Seq.empty
+      )
+    )
   }
-  private[this] def forkOptions: Initialize[Task[ForkOptions]] =
-    (baseDirectory, javaOptions, outputStrategy, envVars, javaHome, connectInput) map {
-      (base, options, strategy, env, javaHomeDir, connectIn) =>
+  def forkOptionsTask: Initialize[Task[ForkOptions]] =
+    Def.task {
+      ForkOptions(
+        javaHome = javaHome.value,
+        outputStrategy = outputStrategy.value,
         // bootJars is empty by default because only jars on the user's classpath should be on the boot classpath
-        ForkOptions(bootJars = Nil, javaHome = javaHomeDir, connectInput = connectIn, outputStrategy = strategy, runJVMOptions = options, workingDirectory = Some(base), envVars = env)
+        bootJars = Vector(),
+        workingDirectory = Some(baseDirectory.value),
+        runJVMOptions = javaOptions.value.toVector,
+        connectInput = connectInput.value,
+        envVars = envVars.value
+      )
     }
 
   def testExecutionTask(task: Scoped): Initialize[Task[Tests.Execution]] =
-    (testOptions in task, parallelExecution in task, tags in task) map {
-      (opts, par, ts) =>
-        new Tests.Execution(opts, par, ts)
+    Def.task {
+      new Tests.Execution(
+        (task / testOptions).value,
+        (task / parallelExecution).value,
+        (task / tags).value
+      )
     }
 
   def testQuickFilter: Initialize[Task[Seq[String] => Seq[String => Boolean]]] =
-    (fullClasspath in test, streams in test) map {
-      (cp, s) =>
-        val ans: Seq[Analysis] = cp.flatMap(_.metadata get Keys.analysis) map { case a0: Analysis => a0 }
-        val succeeded = TestStatus.read(succeededFile(s.cacheDirectory))
-        val stamps = collection.mutable.Map.empty[String, Long]
-        def stamp(dep: String): Long = {
-          val stamps = for (a <- ans) yield intlStamp(dep, a, Set.empty)
-          if (stamps.isEmpty) Long.MinValue
-          else stamps.max
-        }
-        def intlStamp(c: String, analysis: Analysis, s: Set[String]): Long = {
-          if (s contains c) Long.MinValue
-          else {
-            val x = {
-              import analysis.{ relations => rel, apis }
-              rel.internalClassDeps(c).map(intlStamp(_, analysis, s + c)) ++
-                rel.externalDeps(c).map(stamp) +
-                (apis.internal.get(c) match {
-                  case Some(x) => x.compilation.startTime
-                  case _       => Long.MinValue
-                })
-            }.max
-            if (x != Long.MinValue) {
-              stamps(c) = x
+    Def.task {
+      val cp = (test / fullClasspath).value
+      val s = (test / streams).value
+      val ans: Seq[Analysis] = cp.flatMap(_.metadata get Keys.analysis) map {
+        case a0: Analysis => a0
+      }
+      val succeeded = TestStatus.read(succeededFile(s.cacheDirectory))
+      val stamps = collection.mutable.Map.empty[String, Long]
+      def stamp(dep: String): Long = {
+        val stamps = for (a <- ans) yield intlStamp(dep, a, Set.empty)
+        if (stamps.isEmpty) Long.MinValue
+        else stamps.max
+      }
+      def intlStamp(c: String, analysis: Analysis, s: Set[String]): Long = {
+        if (s contains c) Long.MinValue
+        else
+          stamps.getOrElse(
+            c, {
+              val x = {
+                import analysis.{ apis, relations => rel }
+                rel.internalClassDeps(c).map(intlStamp(_, analysis, s + c)) ++
+                  rel.externalDeps(c).map(stamp) +
+                  (apis.internal.get(c) match {
+                    case Some(x) => x.compilationTimestamp
+                    case _       => Long.MinValue
+                  })
+              }.max
+              if (x != Long.MinValue) {
+                stamps(c) = x
+              }
+              x
             }
-            x
-          }
-        }
-        def noSuccessYet(test: String) = succeeded.get(test) match {
-          case None     => true
-          case Some(ts) => stamp(test) > ts
-        }
-
-        args => for (filter <- selectedFilter(args)) yield (test: String) => filter(test) && noSuccessYet(test)
+          )
+      }
+      def noSuccessYet(test: String) = succeeded.get(test) match {
+        case None     => true
+        case Some(ts) => stamps.synchronized(stamp(test)) > ts
+      }
+      args =>
+        for (filter <- selectedFilter(args))
+          yield (test: String) => filter(test) && noSuccessYet(test)
     }
   def succeededFile(dir: File) = dir / "succeeded_tests"
 
-  def inputTests(key: InputKey[_]): Initialize[InputTask[Unit]] = inputTests0.mapReferenced(Def.mapScope(_ in key.key))
-  private[this] lazy val inputTests0: Initialize[InputTask[Unit]] =
-    {
-      val parser = loadForParser(definedTestNames)((s, i) => testOnlyParser(s, i getOrElse Nil))
-      Def.inputTaskDyn {
-        val (selected, frameworkOptions) = parser.parsed
-        val s = streams.value
-        val filter = testFilter.value
-        val config = testExecution.value
+  @nowarn
+  def inputTests(key: InputKey[_]): Initialize[InputTask[Unit]] =
+    inputTests0.mapReferenced(Def.mapScope(_ in key.key))
 
-        implicit val display = Project.showContextKey(state.value)
-        val modifiedOpts = Tests.Filters(filter(selected)) +: Tests.Argument(frameworkOptions: _*) +: config.options
-        val newConfig = config.copy(options = modifiedOpts)
-        val output = allTestGroupsTask(s, loadedTestFrameworks.value, testLoader.value, testGrouping.value, newConfig, fullClasspath.value, javaHome.value, testForkedParallel.value, javaOptions.value)
-        val taskName = display(resolvedScoped.value)
-        val trl = testResultLogger.value
-        val processed = output.map(out => trl.run(s.log, out, taskName))
-        Def.value(processed)
-      }
+  private[this] lazy val inputTests0: Initialize[InputTask[Unit]] = {
+    val parser = loadForParser(definedTestNames)((s, i) => testOnlyParser(s, i getOrElse Nil))
+    Def.inputTaskDyn {
+      val (selected, frameworkOptions) = parser.parsed
+      val s = streams.value
+      val filter = testFilter.value
+      val config = testExecution.value
+
+      implicit val display = Project.showContextKey(state.value)
+      val modifiedOpts = Tests.Filters(filter(selected)) +: Tests.Argument(frameworkOptions: _*) +: config.options
+      val newConfig = config.copy(options = modifiedOpts)
+      val output = allTestGroupsTask(
+        s,
+        loadedTestFrameworks.value,
+        testLoader.value,
+        testGrouping.value,
+        newConfig,
+        fullClasspath.value,
+        testForkedParallel.value,
+        javaOptions.value,
+        classLoaderLayeringStrategy.value,
+        projectId = s"${thisProject.value.id} / ",
+      )
+      val taskName = display.show(resolvedScoped.value)
+      val trl = testResultLogger.value
+      output.map(out => trl.run(s.log, out, taskName))
     }
+  }
 
-  def createTestRunners(frameworks: Map[TestFramework, Framework], loader: ClassLoader, config: Tests.Execution): Map[TestFramework, Runner] = {
+  def createTestRunners(
+      frameworks: Map[TestFramework, Framework],
+      loader: ClassLoader,
+      config: Tests.Execution
+  ): Map[TestFramework, Runner] = {
     import Tests.Argument
     val opts = config.options.toList
     frameworks.map {
@@ -597,33 +1445,154 @@ object Defaults extends BuildCommon {
     }
   }
 
-  def allTestGroupsTask(s: TaskStreams, frameworks: Map[TestFramework, Framework], loader: ClassLoader, groups: Seq[Tests.Group], config: Tests.Execution, cp: Classpath, javaHome: Option[File]): Task[Tests.Output] = {
-    allTestGroupsTask(s, frameworks, loader, groups, config, cp, javaHome, forkedParallelExecution = false, javaOptions = Nil)
+  private[sbt] def allTestGroupsTask(
+      s: TaskStreams,
+      frameworks: Map[TestFramework, Framework],
+      loader: ClassLoader,
+      groups: Seq[Tests.Group],
+      config: Tests.Execution,
+      cp: Classpath,
+  ): Initialize[Task[Tests.Output]] = {
+    allTestGroupsTask(
+      s,
+      frameworks,
+      loader,
+      groups,
+      config,
+      cp,
+      forkedParallelExecution = false,
+      javaOptions = Nil,
+      strategy = ClassLoaderLayeringStrategy.ScalaLibrary,
+      projectId = "",
+    )
   }
 
-  def allTestGroupsTask(s: TaskStreams, frameworks: Map[TestFramework, Framework], loader: ClassLoader, groups: Seq[Tests.Group], config: Tests.Execution, cp: Classpath, javaHome: Option[File], forkedParallelExecution: Boolean): Task[Tests.Output] = {
-    allTestGroupsTask(s, frameworks, loader, groups, config, cp, javaHome, forkedParallelExecution, javaOptions = Nil)
+  private[sbt] def allTestGroupsTask(
+      s: TaskStreams,
+      frameworks: Map[TestFramework, Framework],
+      loader: ClassLoader,
+      groups: Seq[Tests.Group],
+      config: Tests.Execution,
+      cp: Classpath,
+      forkedParallelExecution: Boolean
+  ): Initialize[Task[Tests.Output]] = {
+    allTestGroupsTask(
+      s,
+      frameworks,
+      loader,
+      groups,
+      config,
+      cp,
+      forkedParallelExecution,
+      javaOptions = Nil,
+      strategy = ClassLoaderLayeringStrategy.ScalaLibrary,
+      projectId = "",
+    )
   }
 
-  def allTestGroupsTask(s: TaskStreams, frameworks: Map[TestFramework, Framework], loader: ClassLoader, groups: Seq[Tests.Group], config: Tests.Execution, cp: Classpath, javaHome: Option[File], forkedParallelExecution: Boolean, javaOptions: Seq[String]): Task[Tests.Output] = {
-    val runners = createTestRunners(frameworks, loader, config)
-    val groupTasks = groups map {
-      case Tests.Group(name, tests, runPolicy) =>
-        runPolicy match {
-          case Tests.SubProcess(opts) =>
-            s.log.debug(s"javaOptions: ${opts.runJVMOptions}")
-            val forkedConfig = config.copy(parallel = config.parallel && forkedParallelExecution)
-            s.log.debug(s"Forking tests - parallelism = ${forkedConfig.parallel}")
-            ForkTests(runners, tests.toList, forkedConfig, cp.files, opts, s.log) tag Tags.ForkedTestGroup
-          case Tests.InProcess =>
-            if (javaOptions.nonEmpty) {
-              s.log.warn("javaOptions will be ignored, fork is set to false")
-            }
-            Tests(frameworks, loader, runners, tests, config, s.log)
+  private[sbt] def allTestGroupsTask(
+      s: TaskStreams,
+      frameworks: Map[TestFramework, Framework],
+      loader: ClassLoader,
+      groups: Seq[Tests.Group],
+      config: Tests.Execution,
+      cp: Classpath,
+      forkedParallelExecution: Boolean,
+      javaOptions: Seq[String],
+      strategy: ClassLoaderLayeringStrategy,
+      projectId: String
+  ): Initialize[Task[Tests.Output]] = {
+    val processedOptions: Map[Tests.Group, Tests.ProcessedOptions] =
+      groups
+        .map(
+          group => group -> Tests.processOptions(config, group.tests.toVector, s.log)
+        )
+        .toMap
+
+    val testDefinitions: Iterable[TestDefinition] = processedOptions.values.flatMap(_.tests)
+
+    val filteredFrameworks: Map[TestFramework, Framework] = frameworks.filter {
+      case (_, framework) =>
+        TestFramework.getFingerprints(framework).exists { t =>
+          testDefinitions.exists { test =>
+            TestFramework.matches(t, test.fingerprint)
+          }
         }
     }
+
+    val runners = createTestRunners(filteredFrameworks, loader, config)
+
+    val groupTasks = groups map { group =>
+      group.runPolicy match {
+        case Tests.SubProcess(opts) =>
+          s.log.debug(s"javaOptions: ${opts.runJVMOptions}")
+          val forkedConfig = config.copy(parallel = config.parallel && forkedParallelExecution)
+          s.log.debug(s"Forking tests - parallelism = ${forkedConfig.parallel}")
+          ForkTests(
+            runners,
+            processedOptions(group),
+            forkedConfig,
+            cp.files,
+            opts,
+            s.log,
+            (Tags.ForkedTestGroup, 1) +: group.tags: _*
+          )
+        case Tests.InProcess =>
+          if (javaOptions.nonEmpty) {
+            s.log.warn("javaOptions will be ignored, fork is set to false")
+          }
+          Tests(
+            frameworks,
+            loader,
+            runners,
+            processedOptions(group),
+            config.copy(tags = config.tags ++ group.tags),
+            s.log
+          )
+      }
+    }
     val output = Tests.foldTasks(groupTasks, config.parallel)
-    output map { out =>
+    val result = output map { out =>
+      out.events.foreach {
+        case (suite, e) =>
+          if (strategy != ClassLoaderLayeringStrategy.Flat ||
+              strategy != ClassLoaderLayeringStrategy.ScalaLibrary) {
+            (e.throwables ++ e.throwables.flatMap(t => Option(t.getCause)))
+              .find { t =>
+                t.isInstanceOf[NoClassDefFoundError] ||
+                t.isInstanceOf[IllegalAccessError] ||
+                t.isInstanceOf[ClassNotFoundException]
+              }
+              .foreach { t =>
+                s.log.error(
+                  s"Test suite $suite failed with $t.\nThis may be due to the "
+                    + s"ClassLoaderLayeringStrategy ($strategy) used by your task.\n"
+                    + "To improve performance and reduce memory, sbt attempts to cache the"
+                    + " class loaders used to load the project dependencies.\n"
+                    + "The project class files are loaded in a separate class loader that is"
+                    + " created for each test run.\nThe test class loader accesses the project"
+                    + " dependency classes using the cached project dependency classloader.\nWith"
+                    + " this approach, class loading may fail under the following conditions:\n\n"
+                    + " * Dependencies use reflection to access classes in your project's"
+                    + " classpath.\n   Java serialization/deserialization may cause this.\n"
+                    + " * An open package is accessed across layers. If the project's classes"
+                    + " access or extend\n   jvm package private classes defined in a"
+                    + " project dependency, it may cause an IllegalAccessError\n   because the"
+                    + " jvm enforces package private at the classloader level.\n\n"
+                    + "These issues, along with others that were not enumerated above, may be"
+                    + " resolved by changing the class loader layering strategy.\n"
+                    + "The Flat and ScalaLibrary strategies bundle the full project classpath in"
+                    + " the same class loader.\nTo use one of these strategies, set the "
+                    + " ClassLoaderLayeringStrategy key\nin your configuration, for example:\n\n"
+                    + s"set ${projectId}Test / classLoaderLayeringStrategy :="
+                    + " ClassLoaderLayeringStrategy.ScalaLibrary\n"
+                    + s"set ${projectId}Test / classLoaderLayeringStrategy :="
+                    + " ClassLoaderLayeringStrategy.Flat\n\n"
+                    + "See ClassLoaderLayeringStrategy.scala for the full list of options."
+                )
+              }
+          }
+      }
       val summaries =
         runners map {
           case (tf, r) =>
@@ -631,586 +1600,1291 @@ object Defaults extends BuildCommon {
         }
       out.copy(summaries = summaries)
     }
+    Def.value { result }
   }
 
-  def selectedFilter(args: Seq[String]): Seq[String => Boolean] =
-    {
-      def matches(nfs: Seq[NameFilter], s: String) = nfs.exists(_.accept(s))
+  def selectedFilter(args: Seq[String]): Seq[String => Boolean] = {
+    def matches(nfs: Seq[NameFilter], s: String) = nfs.exists(_.accept(s))
 
-      val (excludeArgs, includeArgs) = args.partition(_.startsWith("-"))
+    val (excludeArgs, includeArgs) = args.partition(_.startsWith("-"))
 
-      val includeFilters = includeArgs map GlobFilter.apply
-      val excludeFilters = excludeArgs.map(_.substring(1)).map(GlobFilter.apply)
+    val includeFilters = includeArgs map GlobFilter.apply
+    val excludeFilters = excludeArgs.map(_.substring(1)).map(GlobFilter.apply)
 
-      (includeFilters, excludeArgs) match {
-        case (Nil, Nil) => Seq(const(true))
-        case (Nil, _)   => Seq((s: String) => !matches(excludeFilters, s))
-        case _          => includeFilters.map(f => (s: String) => (f.accept(s) && !matches(excludeFilters, s)))
-      }
+    (includeFilters, excludeArgs) match {
+      case (Nil, Nil) => Seq(const(true))
+      case (Nil, _)   => Seq((s: String) => !matches(excludeFilters, s))
+      case _ =>
+        includeFilters.map(f => (s: String) => (f.accept(s) && !matches(excludeFilters, s)))
     }
-  def detectTests: Initialize[Task[Seq[TestDefinition]]] = (loadedTestFrameworks, compile, streams) map { (frameworkMap, analysis, s) =>
-    Tests.discover(frameworkMap.values.toList, analysis, s.log)._1
-  }
-  def defaultRestrictions: Initialize[Seq[Tags.Rule]] = parallelExecution { par =>
-    val max = EvaluateTask.SystemProcessors
-    Tags.limitAll(if (par) max else 1) :: Tags.limit(Tags.ForkedTestGroup, 1) :: Nil
   }
+  def detectTests: Initialize[Task[Seq[TestDefinition]]] =
+    Def.task {
+      Tests.discover(loadedTestFrameworks.value.values.toList, compile.value, streams.value.log)._1
+    }
+  def defaultRestrictions: Initialize[Seq[Tags.Rule]] =
+    Def.setting {
+      val par = parallelExecution.value
+      val max = EvaluateTask.SystemProcessors
+      Tags.limitAll(if (par) max else 1) ::
+        Tags.limit(Tags.ForkedTestGroup, 1) ::
+        Tags.exclusiveGroup(Tags.Clean) ::
+        Nil
+    }
 
   lazy val packageBase: Seq[Setting[_]] = Seq(
     artifact := Artifact(moduleName.value)
-  ) ++ Defaults.globalDefaults(Seq(
+  ) ++ Defaults.globalDefaults(
+    Seq(
       packageOptions :== Nil,
       artifactName :== (Artifact.artifactName _)
-    ))
+    )
+  )
 
   lazy val packageConfig: Seq[Setting[_]] =
-    inTask(packageBin)(Seq(
-      packageOptions := {
-        val n = name.value
-        val ver = version.value
-        val org = organization.value
-        val orgName = organizationName.value
-        val main = mainClass.value
-        val old = packageOptions.value
-        Package.addSpecManifestAttributes(n, ver, orgName) +:
-          Package.addImplManifestAttributes(n, ver, homepage.value, org, orgName) +:
-          main.map(Package.MainClass.apply) ++: old
-      }
-    )) ++
-      inTask(packageSrc)(Seq(
-        packageOptions := Package.addSpecManifestAttributes(name.value, version.value, organizationName.value) +: packageOptions.value)) ++
+    inTask(packageBin)(
+      Seq(
+        packageOptions := {
+          val n = name.value
+          val ver = version.value
+          val org = organization.value
+          val orgName = organizationName.value
+          val main = mainClass.value
+          val ts = packageTimestamp.value
+          val old = packageOptions.value
+
+          Package.addSpecManifestAttributes(n, ver, orgName) +:
+            Package.addImplManifestAttributes(n, ver, homepage.value, org, orgName) +:
+            Package.setFixedTimestamp(ts) +:
+            main.map(Package.MainClass.apply) ++: old
+        }
+      )
+    ) ++
+      inTask(packageSrc)(
+        Seq(
+          packageOptions := {
+            val old = packageOptions.value
+            val ts = packageTimestamp.value
+            Package.addSpecManifestAttributes(
+              name.value,
+              version.value,
+              organizationName.value
+            ) +: Package.setFixedTimestamp(ts) +: old
+          }
+        )
+      ) ++
       packageTaskSettings(packageBin, packageBinMappings) ++
       packageTaskSettings(packageSrc, packageSrcMappings) ++
       packageTaskSettings(packageDoc, packageDocMappings) ++
-      Seq(`package` := packageBin.value)
+      Seq(Keys.`package` := packageBin.value)
 
   def packageBinMappings = products map { _ flatMap Path.allSubpaths }
   def packageDocMappings = doc map { Path.allSubpaths(_).toSeq }
   def packageSrcMappings = concatMappings(resourceMappings, sourceMappings)
 
-  @deprecated("Use `packageBinMappings` instead", "0.12.0")
-  def packageBinTask = packageBinMappings
-  @deprecated("Use `packageDocMappings` instead", "0.12.0")
-  def packageDocTask = packageDocMappings
-  @deprecated("Use `packageSrcMappings` instead", "0.12.0")
-  def packageSrcTask = packageSrcMappings
-
   private type Mappings = Initialize[Task[Seq[(File, String)]]]
-  def concatMappings(as: Mappings, bs: Mappings) = (as zipWith bs)((a, b) => (a, b) map { case (a, b) => a ++ b })
+  def concatMappings(as: Mappings, bs: Mappings) =
+    (as zipWith bs)((a, b) => (a, b) map { case (a, b) => a ++ b })
 
   // drop base directories, since there are no valid mappings for these
-  def sourceMappings = (unmanagedSources, unmanagedSourceDirectories, baseDirectory) map { (srcs, sdirs, base) =>
-    (srcs --- sdirs --- base) pair (relativeTo(sdirs) | relativeTo(base) | flat)
-  }
-  def resourceMappings = relativeMappings(unmanagedResources, unmanagedResourceDirectories)
-  def relativeMappings(files: ScopedTaskable[Seq[File]], dirs: ScopedTaskable[Seq[File]]): Initialize[Task[Seq[(File, String)]]] =
-    (files, dirs) map { (rs, rdirs) =>
-      (rs --- rdirs) pair (relativeTo(rdirs) | flat)
+  def sourceMappings: Initialize[Task[Seq[(File, String)]]] =
+    Def.task {
+      val sdirs = unmanagedSourceDirectories.value
+      val base = baseDirectory.value
+      val relative = (f: File) => relativeTo(sdirs)(f).orElse(relativeTo(base)(f)).orElse(flat(f))
+      val exclude = Set(sdirs, base)
+      unmanagedSources.value.flatMap {
+        case s if !exclude(s) => relative(s).map(s -> _)
+        case _                => None
+      }
     }
 
-  def collectFiles(dirs: ScopedTaskable[Seq[File]], filter: ScopedTaskable[FileFilter], excludes: ScopedTaskable[FileFilter]): Initialize[Task[Seq[File]]] =
-    (dirs, filter, excludes) map { (d, f, excl) => d.descendantsExcept(f, excl).get }
+  def resourceMappings = relativeMappings(unmanagedResources, unmanagedResourceDirectories)
 
-  def artifactPathSetting(art: SettingKey[Artifact]) = (crossTarget, projectID, art, scalaVersion in artifactName, scalaBinaryVersion in artifactName, artifactName) {
-    (t, module, a, sv, sbv, toString) =>
-      t / toString(ScalaVersion(sv, sbv), module, a) asFile
-  }
-  def artifactSetting = ((artifact, artifactClassifier).identity zipWith configuration.?) {
-    case ((a, classifier), cOpt) =>
+  def relativeMappings(
+      files: Taskable[Seq[File]],
+      dirs: Taskable[Seq[File]]
+  ): Initialize[Task[Seq[(File, String)]]] =
+    Def.task {
+      val rdirs = dirs.toTask.value.toSet
+      val relative = (f: File) => relativeTo(rdirs)(f).orElse(flat(f))
+      files.toTask.value.flatMap {
+        case r if !rdirs(r) => relative(r).map(r -> _)
+        case _              => None
+      }
+    }
+
+  def collectFiles(
+      dirs: Taskable[Seq[File]],
+      filter: Taskable[FileFilter],
+      excludes: Taskable[FileFilter]
+  ): Initialize[Task[Seq[File]]] =
+    Def.task {
+      dirs.toTask.value.descendantsExcept(filter.toTask.value, excludes.toTask.value).get
+    }
+
+  def relativeMappings( // forward to widened variant
+      files: ScopedTaskable[Seq[File]],
+      dirs: ScopedTaskable[Seq[File]]
+  ): Initialize[Task[Seq[(File, String)]]] = relativeMappings(files: Taskable[Seq[File]], dirs)
+
+  def collectFiles( // forward to widened variant
+      dirs: ScopedTaskable[Seq[File]],
+      filter: ScopedTaskable[FileFilter],
+      excludes: ScopedTaskable[FileFilter]
+  ): Initialize[Task[Seq[File]]] = collectFiles(dirs: Taskable[Seq[File]], filter, excludes)
+
+  private[sbt] def configArtifactPathSetting(
+      art: SettingKey[Artifact],
+      extraPrefix: String
+  ): Initialize[File] =
+    Def.setting {
+      val f = artifactName.value
+      crossTarget.value /
+        (prefix(configuration.value.name) + extraPrefix) / f(
+        ScalaVersion(
+          (artifactName / scalaVersion).value,
+          (artifactName / scalaBinaryVersion).value
+        ),
+        projectID.value,
+        art.value
+      )
+    }
+
+  private[sbt] def prefixArtifactPathSetting(
+      art: SettingKey[Artifact],
+      extraPrefix: String
+  ): Initialize[File] =
+    Def.setting {
+      val f = artifactName.value
+      crossTarget.value / extraPrefix / f(
+        ScalaVersion(
+          (artifactName / scalaVersion).value,
+          (artifactName / scalaBinaryVersion).value
+        ),
+        projectID.value,
+        art.value
+      )
+    }
+
+  def artifactPathSetting(art: SettingKey[Artifact]): Initialize[File] =
+    Def.setting {
+      val f = artifactName.value
+      crossTarget.value / f(
+        ScalaVersion(
+          (artifactName / scalaVersion).value,
+          (artifactName / scalaBinaryVersion).value
+        ),
+        projectID.value,
+        art.value
+      )
+    }
+
+  def artifactSetting: Initialize[Artifact] =
+    Def.setting {
+      val a = artifact.value
+      val classifier = artifactClassifier.value
+      val cOpt = configuration.?.value
       val cPart = cOpt flatMap {
         case Compile => None
         case Test    => Some(Artifact.TestsClassifier)
         case c       => Some(c.name)
       }
       val combined = cPart.toList ++ classifier.toList
-      if (combined.isEmpty) a.copy(classifier = None, configurations = cOpt.toList) else {
-        val classifierString = combined mkString "-"
-        val confs = cOpt.toList flatMap { c => artifactConfigurations(a, c, classifier) }
-        a.copy(classifier = Some(classifierString), `type` = Artifact.classifierType(classifierString), configurations = confs)
+      val configurations = cOpt.map(c => ConfigRef(c.name)).toVector
+      if (combined.isEmpty) a.withClassifier(None).withConfigurations(configurations)
+      else {
+        val a1 = a
+          .withClassifier(Some(combined.mkString("-")))
+          .withConfigurations(configurations)
+        // use "source" as opposed to "foo-source" to retrieve the type
+        classifier match {
+          case Some(c) => a1.withType(Artifact.classifierType(c))
+          case None    => a1
+        }
       }
-  }
-  @deprecated("The configuration(s) should not be decided based on the classifier.", "1.0")
-  def artifactConfigurations(base: Artifact, scope: Configuration, classifier: Option[String]): Iterable[Configuration] =
+    }
+
+  @deprecated("The configuration(s) should not be decided based on the classifier.", "1.0.0")
+  def artifactConfigurations(
+      base: Artifact,
+      scope: Configuration,
+      classifier: Option[String]
+  ): Iterable[Configuration] =
     classifier match {
       case Some(c) => Artifact.classifierConf(c) :: Nil
       case None    => scope :: Nil
     }
 
-  @deprecated("Use `Util.pairID` instead", "0.12.0")
-  def pairID = Util.pairID
-
-  @deprecated("Use `packageTaskSettings` instead", "0.12.0")
-  def packageTasks(key: TaskKey[File], mappingsTask: Initialize[Task[Seq[(File, String)]]]) = packageTaskSettings(key, mappingsTask)
   def packageTaskSettings(key: TaskKey[File], mappingsTask: Initialize[Task[Seq[(File, String)]]]) =
-    inTask(key)(Seq(
-      key in TaskGlobal := packageTask.value,
-      packageConfiguration := packageConfigurationTask.value,
-      mappings := mappingsTask.value,
-      packagedArtifact := (artifact.value -> key.value),
-      artifact := artifactSetting.value,
-      artifactPath := artifactPathSetting(artifact).value
-    ))
+    inTask(key)(
+      Seq(
+        (TaskZero / key) := packageTask.value,
+        packageConfiguration := packageConfigurationTask.value,
+        mappings := mappingsTask.value,
+        packagedArtifact := (artifact.value -> key.value),
+        artifact := artifactSetting.value,
+        artifactPath := artifactPathSetting(artifact).value
+      )
+    )
+
   def packageTask: Initialize[Task[File]] =
-    (packageConfiguration, streams) map { (config, s) =>
-      Package(config, s.cacheDirectory, s.log)
+    Def.task {
+      val config = packageConfiguration.value
+      val s = streams.value
+      Package(
+        config,
+        s.cacheStoreFactory,
+        s.log,
+        Package.timeFromConfiguration(config)
+      )
       config.jar
     }
+
   def packageConfigurationTask: Initialize[Task[Package.Configuration]] =
-    (mappings, artifactPath, packageOptions) map { (srcs, path, options) =>
-      new Package.Configuration(srcs, path, options)
+    Def.task {
+      new Package.Configuration(mappings.value, artifactPath.value, packageOptions.value)
     }
 
-  @deprecated("use Defaults.askForMainClass", "0.13.7")
-  def selectRunMain(classes: Seq[String]): Option[String] = askForMainClass(classes)
-  @deprecated("use Defaults.pickMainClass", "0.13.7")
-  def selectPackageMain(classes: Seq[String]): Option[String] = pickMainClass(classes)
   def askForMainClass(classes: Seq[String]): Option[String] =
-    sbt.SelectMainClass(Some(SimpleReader readLine _), classes)
+    sbt.SelectMainClass(
+      if (classes.length >= 10) Some(SimpleReader(ITerminal.get).readLine(_))
+      else
+        Some(s => {
+          def print(st: String) = { scala.Console.out.print(st); scala.Console.out.flush() }
+          print(s)
+          ITerminal.get.withRawInput {
+            try ITerminal.get.inputStream.read match {
+              case -1 | -2 => None
+              case b =>
+                val res = b.toChar.toString
+                println(res)
+                Some(res)
+            } catch { case e: InterruptedException => None }
+          }
+        }),
+      classes
+    )
+
   def pickMainClass(classes: Seq[String]): Option[String] =
     sbt.SelectMainClass(None, classes)
-  private def pickMainClassOrWarn(classes: Seq[String], logger: Logger): Option[String] = {
+
+  private def pickMainClassOrWarn(
+      classes: Seq[String],
+      logger: Logger,
+      logWarning: Boolean
+  ): Option[String] = {
     classes match {
-      case multiple if multiple.size > 1 => logger.warn("Multiple main classes detected.  Run 'show discoveredMainClasses' to see the list")
-      case _                             =>
+      case multiple if multiple.size > 1 && logWarning =>
+        val msg =
+          "multiple main classes detected: run 'show discoveredMainClasses' to see the list"
+        logger.warn(msg)
+      case _ =>
     }
     pickMainClass(classes)
   }
 
-  def doClean(clean: Seq[File], preserve: Seq[File]): Unit =
-    IO.withTemporaryDirectory { temp =>
-      val (dirs, files) = preserve.filter(_.exists).flatMap(_.allPaths.get).partition(_.isDirectory)
-      val mappings = files.zipWithIndex map { case (f, i) => (f, new File(temp, i.toHexString)) }
-      IO.move(mappings)
-      IO.delete(clean)
-      IO.createDirectories(dirs) // recreate empty directories
-      IO.move(mappings.map(_.swap))
-    }
-  def runMainTask(classpath: Initialize[Task[Classpath]], scalaRun: Initialize[Task[ScalaRun]]): Initialize[InputTask[Unit]] =
-    {
-      val parser = loadForParser(discoveredMainClasses)((s, names) => runMainParser(s, names getOrElse Nil))
-      Def.inputTask {
-        val (mainClass, args) = parser.parsed
-        toError(scalaRun.value.run(mainClass, data(classpath.value), args, streams.value.log))
+  /** Implements `cleanFiles` task. */
+  private[sbt] def cleanFilesTask: Initialize[Task[Vector[File]]] = Def.task { Vector.empty[File] }
+
+  private[this] def termWrapper(canonical: Boolean, echo: Boolean): (() => Unit) => (() => Unit) =
+    (f: () => Unit) =>
+      () => {
+        val term = ITerminal.get
+        if (!canonical) {
+          term.enterRawMode()
+          if (echo) term.setEchoEnabled(echo)
+        } else if (!echo) term.setEchoEnabled(false)
+        try f()
+        finally {
+          if (!canonical) term.exitRawMode()
+          if (!echo) term.setEchoEnabled(true)
+        }
+      }
+  def bgRunMainTask(
+      products: Initialize[Task[Classpath]],
+      classpath: Initialize[Task[Classpath]],
+      copyClasspath: Initialize[Boolean],
+      scalaRun: Initialize[Task[ScalaRun]]
+  ): Initialize[InputTask[JobHandle]] = {
+    val parser = Defaults.loadForParser(discoveredMainClasses)(
+      (s, names) => Defaults.runMainParser(s, names getOrElse Nil)
+    )
+    Def.inputTask {
+      val service = bgJobService.value
+      val (mainClass, args) = parser.parsed
+      val hashClasspath = (bgRunMain / bgHashClasspath).value
+      val wrapper = termWrapper(canonicalInput.value, echoInput.value)
+      service.runInBackgroundWithLoader(resolvedScoped.value, state.value) { (logger, workingDir) =>
+        val files =
+          if (copyClasspath.value)
+            service.copyClasspath(products.value, classpath.value, workingDir, hashClasspath)
+          else classpath.value
+        val cp = data(files)
+        scalaRun.value match {
+          case r: Run =>
+            val loader = r.newLoader(cp)
+            (Some(loader), wrapper(() => r.runWithLoader(loader, cp, mainClass, args, logger).get))
+          case sr =>
+            (None, wrapper(() => sr.run(mainClass, cp, args, logger).get))
+        }
       }
     }
+  }
 
-  def runTask(classpath: Initialize[Task[Classpath]], mainClassTask: Initialize[Task[Option[String]]], scalaRun: Initialize[Task[ScalaRun]]): Initialize[InputTask[Unit]] =
-    {
-      import Def.parserToInput
-      val parser = Def.spaceDelimited()
-      Def.inputTask {
-        val mainClass = mainClassTask.value getOrElse sys.error("No main class detected.")
-        toError(scalaRun.value.run(mainClass, data(classpath.value), parser.parsed, streams.value.log))
+  def bgRunTask(
+      products: Initialize[Task[Classpath]],
+      classpath: Initialize[Task[Classpath]],
+      mainClassTask: Initialize[Task[Option[String]]],
+      copyClasspath: Initialize[Boolean],
+      scalaRun: Initialize[Task[ScalaRun]]
+  ): Initialize[InputTask[JobHandle]] = {
+    import Def.parserToInput
+    val parser = Def.spaceDelimited()
+    Def.inputTask {
+      val service = bgJobService.value
+      val mainClass = mainClassTask.value getOrElse sys.error("No main class detected.")
+      val hashClasspath = (bgRun / bgHashClasspath).value
+      val wrapper = termWrapper(canonicalInput.value, echoInput.value)
+      service.runInBackgroundWithLoader(resolvedScoped.value, state.value) { (logger, workingDir) =>
+        val files =
+          if (copyClasspath.value)
+            service.copyClasspath(products.value, classpath.value, workingDir, hashClasspath)
+          else classpath.value
+        val cp = data(files)
+        val args = parser.parsed
+        scalaRun.value match {
+          case r: Run =>
+            val loader = r.newLoader(cp)
+            (Some(loader), wrapper(() => r.runWithLoader(loader, cp, mainClass, args, logger).get))
+          case sr =>
+            (None, wrapper(() => sr.run(mainClass, cp, args, logger).get))
+        }
       }
     }
+  }
+
+  // runMain calls bgRunMain in the background and waits for the result.
+  def foregroundRunMainTask: Initialize[InputTask[Unit]] =
+    Def.inputTask {
+      val handle = bgRunMain.evaluated
+      val service = bgJobService.value
+      service.waitForTry(handle).get
+    }
+
+  // run calls bgRun in the background and waits for the result.
+  def foregroundRunTask: Initialize[InputTask[Unit]] =
+    Def.inputTask {
+      val handle = bgRun.evaluated
+      val service = bgJobService.value
+      service.waitForTry(handle).get
+    }
+
+  def runMainTask(
+      classpath: Initialize[Task[Classpath]],
+      scalaRun: Initialize[Task[ScalaRun]]
+  ): Initialize[InputTask[Unit]] = {
+    val parser =
+      loadForParser(discoveredMainClasses)((s, names) => runMainParser(s, names getOrElse Nil))
+    Def.inputTask {
+      val (mainClass, args) = parser.parsed
+      scalaRun.value.run(mainClass, data(classpath.value), args, streams.value.log).get
+    }
+  }
+
+  def runTask(
+      classpath: Initialize[Task[Classpath]],
+      mainClassTask: Initialize[Task[Option[String]]],
+      scalaRun: Initialize[Task[ScalaRun]]
+  ): Initialize[InputTask[Unit]] = {
+    import Def.parserToInput
+    val parser = Def.spaceDelimited()
+    Def.inputTask {
+      val mainClass = mainClassTask.value getOrElse sys.error("No main class detected.")
+      scalaRun.value.run(mainClass, data(classpath.value), parser.parsed, streams.value.log).get
+    }
+  }
+
+  def runnerTask: Setting[Task[ScalaRun]] = runner := runnerInit.value
 
-  def runnerTask = runner := runnerInit.value
   def runnerInit: Initialize[Task[ScalaRun]] = Def.task {
     val tmp = taskTemporaryDirectory.value
     val resolvedScope = resolvedScoped.value.scope
     val si = scalaInstance.value
     val s = streams.value
+    val opts = forkOptions.value
     val options = javaOptions.value
+    val trap = trapExit.value
     if (fork.value) {
       s.log.debug(s"javaOptions: $options")
-      new ForkRun(forkOptions.value)
+      new ForkRun(opts)
     } else {
       if (options.nonEmpty) {
         val mask = ScopeMask(project = false)
-        val showJavaOptions = Scope.displayMasked((javaOptions in resolvedScope).scopedKey.scope, (javaOptions in resolvedScope).key.label, mask)
-        val showFork = Scope.displayMasked((fork in resolvedScope).scopedKey.scope, (fork in resolvedScope).key.label, mask)
+        val showJavaOptions = Scope.displayMasked(
+          (resolvedScope / javaOptions).scopedKey.scope,
+          (resolvedScope / javaOptions).key.label,
+          mask
+        )
+        val showFork = Scope.displayMasked(
+          (resolvedScope / fork).scopedKey.scope,
+          (resolvedScope / fork).key.label,
+          mask
+        )
         s.log.warn(s"$showJavaOptions will be ignored, $showFork is set to false")
       }
-      new Run(si, trapExit.value, tmp)
+      new Run(si, trap, tmp)
     }
   }
 
-  @deprecated("Use `docTaskSettings` instead", "0.12.0")
-  def docSetting(key: TaskKey[File]) = docTaskSettings(key)
-  def docTaskSettings(key: TaskKey[File] = doc): Seq[Setting[_]] = inTask(key)(Seq(
-    apiMappings ++= { if (autoAPIMappings.value) APIMappings.extract(dependencyClasspath.value, streams.value.log).toMap else Map.empty[File, URL] },
-    fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"),
-    key in TaskGlobal := {
-      val s = streams.value
-      val cs: Compilers = compilers.value
-      val srcs = sources.value
-      val out = target.value
-      val sOpts = scalacOptions.value
-      val xapis = apiMappings.value
-      val hasScala = srcs.exists(_.name.endsWith(".scala"))
-      val hasJava = srcs.exists(_.name.endsWith(".java"))
-      val cp = data(dependencyClasspath.value).toList
-      val label = nameForSrc(configuration.value.name)
-      val fiOpts = fileInputOptions.value
-      val reporter = (compilerReporter in compile).value
-      (hasScala, hasJava) match {
-        case (true, _) =>
-          val options = sOpts ++ Opts.doc.externalAPI(xapis)
-          val runDoc = Doc.scaladoc(label, s.cacheDirectory / "scala",
-            cs.scalac match {
-              case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scaladoc"))
-            },
-            fiOpts)
-          runDoc(srcs, cp, out, options, maxErrors.value, s.log)
-        case (_, true) =>
-          val javadoc = sbt.inc.Doc.cachedJavadoc(label, s.cacheDirectory / "java", cs.javaTools)
-          javadoc.run(srcs.toList, cp, out, javacOptions.value.toList, s.log, reporter)
-        case _ => () // do nothing
-      }
-      out
+  private def foreachJobTask(
+      f: (BackgroundJobService, JobHandle) => Unit
+  ): Initialize[InputTask[Unit]] = {
+    val parser: Initialize[State => Parser[Seq[JobHandle]]] = Def.setting { (s: State) =>
+      val extracted = Project.extract(s)
+      val service = extracted.get(bgJobService)
+      // you might be tempted to use the jobList task here, but the problem
+      // is that its result gets cached during execution and therefore stale
+      BackgroundJobService.jobIdParser(s, service.jobs)
     }
-  ))
+    Def.inputTask {
+      val handles = parser.parsed
+      for (handle <- handles) {
+        f(bgJobService.value, handle)
+      }
+    }
+  }
 
-  def mainRunTask = run := runTask(fullClasspath in Runtime, mainClass in run, runner in run).evaluated
-  def mainRunMainTask = runMain := runMainTask(fullClasspath in Runtime, runner in run).evaluated
+  def psTask: Initialize[Task[Seq[JobHandle]]] =
+    Def.task {
+      val xs = bgList.value
+      val s = streams.value
+      xs foreach { x =>
+        s.log.info(x.toString)
+      }
+      xs
+    }
 
-  def discoverMainClasses(analysis: CompileAnalysis): Seq[String] =
-    Discovery.applications(Tests.allDefs(analysis)).collect({ case (definition, discovered) if discovered.hasMain => definition.name }).sorted
+  def bgStopTask: Initialize[InputTask[Unit]] = foreachJobTask { (manager, handle) =>
+    manager.stop(handle)
+  }
+
+  def bgWaitForTask: Initialize[InputTask[Unit]] = foreachJobTask { (manager, handle) =>
+    manager.waitForTry(handle)
+    ()
+  }
+
+  def docTaskSettings(key: TaskKey[File] = doc): Seq[Setting[_]] =
+    inTask(key)(
+      Seq(
+        apiMappings ++= {
+          val dependencyCp = dependencyClasspath.value
+          val log = streams.value.log
+          if (autoAPIMappings.value) APIMappings.extract(dependencyCp, log).toMap
+          else Map.empty[File, URL]
+        },
+        fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"),
+        scalacOptions := {
+          val compileOptions = scalacOptions.value
+          val sv = scalaVersion.value
+          val config = configuration.value
+          val projectName = name.value
+          if (ScalaArtifacts.isScala3(sv)) {
+            val project = if (config == Compile) projectName else s"$projectName-$config"
+            Seq("-project", project)
+          } else compileOptions
+        },
+        (TaskZero / key) := {
+          val s = streams.value
+          val cs: Compilers = compilers.value
+          val srcs = sources.value
+          val out = target.value
+          val sOpts = scalacOptions.value
+          val xapis = apiMappings.value
+          val hasScala = srcs.exists(_.name.endsWith(".scala"))
+          val hasJava = srcs.exists(_.name.endsWith(".java"))
+          val cp = data(dependencyClasspath.value).toList
+          val label = nameForSrc(configuration.value.name)
+          val fiOpts = fileInputOptions.value
+          val reporter = (compile / bspReporter).value
+          val converter = fileConverter.value
+          val tFiles = tastyFiles.value
+          val sv = scalaVersion.value
+          val allDeps = allDependencies.value
+          (hasScala, hasJava) match {
+            case (true, _) =>
+              val options = sOpts ++ Opts.doc.externalAPI(xapis)
+              val runDoc = Doc.scaladoc(label, s.cacheStoreFactory sub "scala", cs.scalac match {
+                case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scaladoc"))
+              }, fiOpts)
+              def isScala3Doc(module: ModuleID): Boolean = {
+                module.configurations.exists(_.startsWith(Configurations.ScalaDocTool.name)) &&
+                module.name == ScalaArtifacts.Scala3DocID
+              }
+              if (ScalaArtifacts.isScala3M123(sv) && !allDeps.exists(isScala3Doc)) {
+                Array(
+                  "Unresolved scala3doc artifact",
+                  "add 'ThisBuild / resolvers += Resolver.JCenterRepository'"
+                ).foreach(m => s.log.error(m))
+              }
+              val docSrcs = if (ScalaArtifacts.isScala3(sv)) tFiles else srcs
+              runDoc(docSrcs, cp, out, options, maxErrors.value, s.log)
+            case (_, true) =>
+              val javadoc =
+                sbt.inc.Doc.cachedJavadoc(label, s.cacheStoreFactory sub "java", cs.javaTools)
+              javadoc.run(
+                srcs.toList map { x =>
+                  converter.toVirtualFile(x.toPath)
+                },
+                cp map { x =>
+                  converter.toVirtualFile(x.toPath)
+                },
+                converter,
+                out.toPath,
+                javacOptions.value.toList,
+                IncToolOptionsUtil.defaultIncToolOptions(),
+                s.log,
+                reporter
+              )
+            case _ => () // do nothing
+          }
+          out
+        }
+      )
+    )
+
+  def mainBgRunTask = mainBgRunTaskForConfig(Select(Runtime))
+  def mainBgRunMainTask = mainBgRunMainTaskForConfig(Select(Runtime))
+
+  private[this] def mainBgRunTaskForConfig(c: ScopeAxis[ConfigKey]) =
+    bgRun := bgRunTask(
+      exportedProductJars,
+      This / c / This / fullClasspathAsJars,
+      run / mainClass,
+      bgRun / bgCopyClasspath,
+      run / runner
+    ).evaluated
+
+  private[this] def mainBgRunMainTaskForConfig(c: ScopeAxis[ConfigKey]) =
+    bgRunMain := bgRunMainTask(
+      exportedProductJars,
+      This / c / This / fullClasspathAsJars,
+      bgRunMain / bgCopyClasspath,
+      run / runner
+    ).evaluated
+
+  def discoverMainClasses(analysis: CompileAnalysis): Seq[String] = analysis match {
+    case analysis: Analysis =>
+      analysis.infos.allInfos.values.map(_.getMainClasses).flatten.toSeq.sorted
+  }
+
+  def consoleProjectTask =
+    Def.task {
+      ConsoleProject(state.value, (consoleProject / initialCommands).value)(streams.value.log)
+      println()
+    }
 
-  def consoleProjectTask = (state, streams, initialCommands in consoleProject) map { (state, s, extra) => ConsoleProject(state, extra)(s.log); println() }
   def consoleTask: Initialize[Task[Unit]] = consoleTask(fullClasspath, console)
   def consoleQuickTask = consoleTask(externalDependencyClasspath, consoleQuick)
   def consoleTask(classpath: TaskKey[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] =
-    (compilers in task, classpath in task, scalacOptions in task, initialCommands in task, cleanupCommands in task, taskTemporaryDirectory in task, scalaInstance in task, streams) map {
-      case (cs: Compilers, cp, options, initCommands, cleanup, temp, si, s) =>
-        val cpFiles = data(cp)
-        val fullcp = (cpFiles ++ si.allJars).distinct
-        val loader = sbt.internal.inc.classpath.ClasspathUtilities.makeLoader(fullcp, si, IO.createUniqueDirectory(temp))
-        val compiler =
-          cs.scalac match {
-            case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scala"))
-          }
-        (new Console(compiler))(cpFiles, options, loader, initCommands, cleanup)()(s.log).foreach(msg => sys.error(msg))
-        println()
+    Def.task {
+      val si = (task / scalaInstance).value
+      val s = streams.value
+      val cpFiles = data((task / classpath).value)
+      val fullcp = (cpFiles ++ si.allJars).distinct
+      val tempDir = IO.createUniqueDirectory((task / taskTemporaryDirectory).value).toPath
+      val loader = ClasspathUtil.makeLoader(fullcp.map(_.toPath), si, tempDir)
+      val compiler =
+        (task / compilers).value.scalac match {
+          case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scala"))
+        }
+      val sc = (task / scalacOptions).value
+      val ic = (task / initialCommands).value
+      val cc = (task / cleanupCommands).value
+      (new Console(compiler))(cpFiles, sc, loader, ic, cc)()(s.log).get
+      println()
     }
 
-  private[this] def exported(w: PrintWriter, command: String): Seq[String] => Unit = args =>
-    w.println((command +: args).mkString(" "))
-  private[this] def exported(s: TaskStreams, command: String): Seq[String] => Unit = args => {
+  private[this] def exported(w: PrintWriter, command: String): Seq[String] => Unit =
+    args => w.println((command +: args).mkString(" "))
+
+  private[this] def exported(s: TaskStreams, command: String): Seq[String] => Unit = {
     val w = s.text(ExportStream)
     try exported(w, command)
     finally w.close() // workaround for #937
   }
 
-  @deprecated("Use inTask(compile)(compileInputsSettings)", "0.13.0")
-  def compileTaskSettings: Seq[Setting[_]] = inTask(compile)(compileInputsSettings)
+  /** Handles traditional Scalac compilation. For non-pipelined compilation,
+   *  this also handles Java compilation.
+   */
+  private[sbt] def compileScalaBackendTask: Initialize[Task[CompileResult]] = Def.task {
+    val setup: Setup = compileIncSetup.value
+    val useBinary: Boolean = enableBinaryCompileAnalysis.value
+    val analysisResult: CompileResult = compileIncremental.value
+    val exportP = exportPipelining.value
+    // Save analysis midway if pipelining is enabled
+    if (analysisResult.hasModified && exportP) {
+      val store =
+        MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile.toPath, !useBinary)
+      val contents = AnalysisContents.create(analysisResult.analysis(), analysisResult.setup())
+      store.set(contents)
+      // this stores the eary analysis (again) in case the subproject contains a macro
+      setup.earlyAnalysisStore.toOption map { earlyStore =>
+        earlyStore.set(contents)
+      }
+    }
+    analysisResult
+  }
 
+  /** Block on earlyOutputPing promise, which will be completed by `compile` midway
+   * via `compileProgress` implementation.
+   */
+  private[sbt] def compileEarlyTask: Initialize[Task[CompileAnalysis]] = Def.task {
+    if ({
+      streams.value.log
+        .debug(s"${name.value}: compileEarly: blocking on earlyOutputPing")
+      earlyOutputPing.await.value
+    }) {
+      val useBinary: Boolean = enableBinaryCompileAnalysis.value
+      val store =
+        MixedAnalyzingCompiler.staticCachedStore(earlyCompileAnalysisFile.value.toPath, !useBinary)
+      store.get.toOption match {
+        case Some(contents) => contents.getAnalysis
+        case _              => Analysis.empty
+      }
+    } else {
+      compile.value
+    }
+  }
   def compileTask: Initialize[Task[CompileAnalysis]] = Def.task {
     val setup: Setup = compileIncSetup.value
+    val useBinary: Boolean = enableBinaryCompileAnalysis.value
+    val c = fileConverter.value
     // TODO - expose bytecode manipulation phase.
     val analysisResult: CompileResult = manipulateBytecode.value
     if (analysisResult.hasModified) {
-      val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile)
-      store.set(analysisResult.analysis, analysisResult.setup)
+      val store =
+        MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile.toPath, !useBinary)
+      val contents = AnalysisContents.create(analysisResult.analysis(), analysisResult.setup())
+      store.set(contents)
     }
-    analysisResult.analysis
+    val map = managedFileStampCache.value
+    val analysis = analysisResult.analysis
+    import scala.collection.JavaConverters._
+    analysis.readStamps.getAllProductStamps.asScala.foreach {
+      case (f: VirtualFileRef, s) =>
+        map.put(c.toPath(f), sbt.nio.FileStamp.fromZincStamp(s))
+    }
+    analysis
   }
   def compileIncrementalTask = Def.task {
-    // TODO - Should readAnalysis + saveAnalysis be scoped by the compile task too?
-    compileIncrementalTaskImpl(streams.value, (compileInputs in compile).value)
-  }
-  private[this] def compileIncrementalTaskImpl(s: TaskStreams, ci: Inputs): CompileResult =
-    {
-      lazy val x = s.text(ExportStream)
-      def onArgs(cs: Compilers) =
-        cs.withScalac(
-          cs.scalac match {
-            case ac: AnalyzingCompiler => ac.onArgs(exported(x, "scalac"))
-            case x                     => x
-          }
-        )
-      // .withJavac(
-      //  cs.javac.onArgs(exported(x, "javac"))
-      //)
-      val compilers: Compilers = ci.compilers
-      val i = ci.withCompilers(onArgs(compilers))
-      try Compiler.compile(i, s.log)
-      finally x.close() // workaround for #937
+    BspCompileTask.compute(bspTargetIdentifier.value, thisProjectRef.value, configuration.value) {
+      // TODO - Should readAnalysis + saveAnalysis be scoped by the compile task too?
+      compileIncrementalTaskImpl(
+        streams.value,
+        (compile / compileInputs).value,
+        earlyOutputPing.value,
+        (compile / bspReporter).value
+      )
     }
-  def compileIncSetupTask = Def.task {
-    val lookup = new PerClasspathEntryLookup {
-      private val cachedAnalysisMap = analysisMap(dependencyClasspath.value)
-      private val cachedPerEntryDefinesClassLookup = Keys.classpathEntryDefinesClass.value
+  }
+  private val incCompiler = ZincUtil.defaultIncrementalCompiler
+  private[sbt] def compileJavaTask: Initialize[Task[CompileResult]] = Def.task {
+    val s = streams.value
+    val r = compileScalaBackend.value
+    val in0 = (compileJava / compileInputs).value
+    val in = in0.withPreviousResult(PreviousResult.of(r.analysis, r.setup))
+    val reporter = (compile / bspReporter).value
+    try {
+      if (r.hasModified) {
+        val result0 = incCompiler
+          .asInstanceOf[sbt.internal.inc.IncrementalCompilerImpl]
+          .compileAllJava(in, s.log)
+        reporter.sendSuccessReport(result0.analysis())
+        result0.withHasModified(result0.hasModified || r.hasModified)
+      } else r
+    } catch {
+      case NonFatal(e) =>
+        reporter.sendFailureReport(in.options.sources)
+        throw e
+    }
+  }
+  private[this] def compileIncrementalTaskImpl(
+      s: TaskStreams,
+      ci: Inputs,
+      promise: PromiseWrap[Boolean],
+      reporter: BuildServerReporter
+  ): CompileResult = {
+    lazy val x = s.text(ExportStream)
+    def onArgs(cs: Compilers) = {
+      cs.withScalac(
+        cs.scalac match {
+          case ac: AnalyzingCompiler => ac.onArgs(exported(x, "scalac"))
+          case x                     => x
+        }
+      )
+    }
+    val compilers: Compilers = ci.compilers
+    val i = ci.withCompilers(onArgs(compilers))
+    try {
+      val result = incCompiler.compile(i, s.log)
+      reporter.sendSuccessReport(result.getAnalysis)
+      result
+    } catch {
+      case e: Throwable =>
+        if (!promise.isCompleted) {
+          promise.failure(e)
+          ConcurrentRestrictions.cancelAllSentinels()
+        }
+        reporter.sendFailureReport(ci.options.sources)
 
-      override def analysis(classpathEntry: File): Maybe[CompileAnalysis] =
-        o2m(cachedAnalysisMap(classpathEntry))
-      override def definesClass(classpathEntry: File): DefinesClass =
+        throw e
+    } finally {
+      x.close() // workaround for #937
+    }
+  }
+  def compileIncSetupTask = Def.task {
+    val cp = dependencyPicklePath.value
+    val lookup = new PerClasspathEntryLookup {
+      private val cachedAnalysisMap: VirtualFile => Option[CompileAnalysis] =
+        analysisMap(cp)
+      private val cachedPerEntryDefinesClassLookup: VirtualFile => DefinesClass =
+        Keys.classpathEntryDefinesClassVF.value
+      override def analysis(classpathEntry: VirtualFile): Optional[CompileAnalysis] =
+        cachedAnalysisMap(classpathEntry).toOptional
+      override def definesClass(classpathEntry: VirtualFile): DefinesClass =
         cachedPerEntryDefinesClassLookup(classpathEntry)
     }
-    new Setup(
+    val extra = extraIncOptions.value.map(t2)
+    val useBinary: Boolean = enableBinaryCompileAnalysis.value
+    val eapath = earlyCompileAnalysisFile.value.toPath
+    val eaOpt =
+      if (exportPipelining.value) Some(MixedAnalyzingCompiler.staticCachedStore(eapath, !useBinary))
+      else None
+    Setup.of(
       lookup,
-      (skip in compile).value,
-      // TODO - this is kind of a bad way to grab the cache directory for streams...
-      streams.value.cacheDirectory / compileAnalysisFilename.value,
+      (compile / skip).value,
+      compileAnalysisFile.value.toPath,
       compilerCache.value,
       incOptions.value,
-      (compilerReporter in compile).value,
-      o2m(None),
-      // TODO - task / setting for extra,
-      Array.empty)
-  }
-  def compileInputsSettings: Seq[Setting[_]] = {
-    Seq(
-      compileOptions := new CompileOptions(
-        (classDirectory.value +: data(dependencyClasspath.value)).toArray,
-        sources.value.toArray,
-        classDirectory.value,
-        scalacOptions.value.toArray,
-        javacOptions.value.toArray,
-        maxErrors.value,
-        f1(Compiler.foldMappers(sourcePositionMappers.value)),
-        compileOrder.value),
-      compilerReporter := new LoggerReporter(maxErrors.value, streams.value.log, Compiler.foldMappers(sourcePositionMappers.value)),
-      compileInputs := new Inputs(
-        compilers.value,
-        compileOptions.value,
-        compileIncSetup.value,
-        previousCompile.value)
+      (compile / bspReporter).value,
+      Some((compile / compileProgress).value).toOptional,
+      eaOpt.toOptional,
+      extra.toArray,
     )
   }
+  def compileInputsSettings: Seq[Setting[_]] =
+    compileInputsSettings(dependencyPicklePath)
+  def compileInputsSettings(classpathTask: TaskKey[VirtualClasspath]): Seq[Setting[_]] = {
+    Seq(
+      compileOptions := {
+        val c = fileConverter.value
+        val cp0 = classpathTask.value
+        val cp = backendOutput.value +: data(cp0)
+        val vs = sources.value.toVector map { x =>
+          c.toVirtualFile(x.toPath)
+        }
+        val eo = CompileOutput(c.toPath(earlyOutput.value))
+        val eoOpt =
+          if (exportPipelining.value) Some(eo)
+          else None
+        CompileOptions.of(
+          cp.toArray,
+          vs.toArray,
+          c.toPath(backendOutput.value),
+          scalacOptions.value.toArray,
+          javacOptions.value.toArray,
+          maxErrors.value,
+          f1(
+            foldMappers(sourcePositionMappers.value, reportAbsolutePath.value, fileConverter.value)
+          ),
+          compileOrder.value,
+          None.toOptional: Optional[NioPath],
+          Some(fileConverter.value).toOptional,
+          Some(reusableStamper.value).toOptional,
+          eoOpt.toOptional,
+        )
+      },
+      compilerReporter := {
+        new ManagedLoggedReporter(
+          maxErrors.value,
+          streams.value.log,
+          foldMappers(sourcePositionMappers.value, reportAbsolutePath.value, fileConverter.value)
+        )
+      },
+      compileInputs := {
+        val options = compileOptions.value
+        val setup = compileIncSetup.value
+        val prev = previousCompile.value
+        Inputs.of(
+          compilers.value,
+          options,
+          setup,
+          prev
+        )
+      }
+    )
+  }
+
+  private[sbt] def foldMappers(
+      mappers: Seq[Position => Option[Position]],
+      reportAbsolutePath: Boolean,
+      fc: FileConverter
+  ) = {
+    def withAbsoluteSource(p: Position): Position =
+      if (reportAbsolutePath) toAbsoluteSource(fc)(p) else p
+
+    mappers.foldRight({ p: Position =>
+      withAbsoluteSource(p) // Fallback if sourcePositionMappers is empty
+    }) {
+      (mapper, previousPosition) =>
+        { p: Position =>
+          // To each mapper we pass the position with the absolute source (only if reportAbsolutePath = true of course)
+          mapper(withAbsoluteSource(p)).getOrElse(previousPosition(p))
+        }
+    }
+  }
+
+  private[sbt] def none[A]: Option[A] = (None: Option[A])
+  private[sbt] def jnone[A]: Optional[A] = none[A].toOptional
   def compileAnalysisSettings: Seq[Setting[_]] = Seq(
     previousCompile := {
       val setup = compileIncSetup.value
-      val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile)
-      store.get() match {
-        case Some((an, setup)) => new PreviousResult(Maybe.just(an), Maybe.just(setup))
-        case None              => new PreviousResult(Maybe.nothing[CompileAnalysis], Maybe.nothing[MiniSetup])
+      val useBinary: Boolean = enableBinaryCompileAnalysis.value
+      val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile.toPath, !useBinary)
+      val prev = store.get().toOption match {
+        case Some(contents) =>
+          val analysis = Option(contents.getAnalysis).toOptional
+          val setup = Option(contents.getMiniSetup).toOptional
+          PreviousResult.of(analysis, setup)
+        case None => PreviousResult.of(jnone[CompileAnalysis], jnone[MiniSetup])
       }
+      prev
     }
   )
 
   def printWarningsTask: Initialize[Task[Unit]] =
-    (streams, compile, maxErrors, sourcePositionMappers) map {
-      case (s, analysis: Analysis, max, spms) =>
-        val problems = analysis.infos.allInfos.values.flatMap(i => i.reportedProblems ++ i.unreportedProblems)
-        val reporter = new LoggerReporter(max, s.log, Compiler.foldMappers(spms))
-        problems foreach { p => reporter.display(p.position, p.message, p.severity) }
+    Def.task {
+      val analysis = compile.value match { case a: Analysis => a }
+      val max = maxErrors.value
+      val spms = sourcePositionMappers.value
+      val problems =
+        analysis.infos.allInfos.values
+          .flatMap(i => i.getReportedProblems ++ i.getUnreportedProblems)
+      val reporter = new ManagedLoggedReporter(
+        max,
+        streams.value.log,
+        foldMappers(spms, reportAbsolutePath.value, fileConverter.value)
+      )
+      problems.foreach(p => reporter.log(p))
     }
 
   def sbtPluginExtra(m: ModuleID, sbtV: String, scalaV: String): ModuleID =
-    m.extra(PomExtraDependencyAttributes.SbtVersionKey -> sbtV, PomExtraDependencyAttributes.ScalaVersionKey -> scalaV).copy(crossVersion = CrossVersion.Disabled)
+    m.extra(
+        PomExtraDependencyAttributes.SbtVersionKey -> sbtV,
+        PomExtraDependencyAttributes.ScalaVersionKey -> scalaV
+      )
+      .withCrossVersion(Disabled())
 
-  def discoverSbtPluginNames: Initialize[Task[PluginDiscovery.DiscoveredNames]] = Def.task {
-    if (sbtPlugin.value) PluginDiscovery.discoverSourceAll(compile.value) else PluginDiscovery.emptyDiscoveredNames
+  def discoverSbtPluginNames: Initialize[Task[PluginDiscovery.DiscoveredNames]] = Def.taskDyn {
+    if (sbtPlugin.value) Def.task(PluginDiscovery.discoverSourceAll(compile.value))
+    else Def.task(PluginDiscovery.emptyDiscoveredNames)
   }
 
   def copyResourcesTask =
-    (classDirectory, resources, resourceDirectories, streams) map { (target, resrcs, dirs, s) =>
-      val cacheFile = s.cacheDirectory / "copy-resources"
-      val mappings = (resrcs --- dirs) pair (rebase(dirs, target) | flat(target))
+    Def.task {
+      val t = classDirectory.value
+      val dirs = resourceDirectories.value.toSet
+      val s = streams.value
+      val cacheStore = s.cacheStoreFactory make "copy-resources"
+      val flt: File => Option[File] = flat(t)
+      val transform: File => Option[File] = (f: File) => rebase(dirs, t)(f).orElse(flt(f))
+      val mappings: Seq[(File, File)] = resources.value.flatMap {
+        case r if !dirs(r) => transform(r).map(r -> _)
+        case _             => None
+      }
       s.log.debug("Copy resource mappings: " + mappings.mkString("\n\t", "\n\t", ""))
-      Sync(cacheFile)(mappings)
+      Sync.sync(cacheStore)(mappings)
       mappings
     }
 
-  def runMainParser: (State, Seq[String]) => Parser[(String, Seq[String])] =
-    {
-      import DefaultParsers._
-      (state, mainClasses) => Space ~> token(NotSpace examples mainClasses.toSet) ~ spaceDelimited("<arg>")
-    }
+  def runMainParser: (State, Seq[String]) => Parser[(String, Seq[String])] = {
+    import DefaultParsers._
+    (state, mainClasses) =>
+      Space ~> token(NotSpace examples mainClasses.toSet) ~ spaceDelimited("<arg>")
+  }
 
-  def testOnlyParser: (State, Seq[String]) => Parser[(Seq[String], Seq[String])] =
-    { (state, tests) =>
+  def testOnlyParser: (State, Seq[String]) => Parser[(Seq[String], Seq[String])] = {
+    (state, tests) =>
       import DefaultParsers._
       val selectTests = distinctParser(tests.toSet, true)
       val options = (token(Space) ~> token("--") ~> spaceDelimited("<option>")) ?? Nil
       selectTests ~ options
-    }
+  }
 
-  private def distinctParser(exs: Set[String], raw: Boolean): Parser[Seq[String]] =
-    {
-      import DefaultParsers._, Parser.and
-      val base = token(Space) ~> token(and(NotSpace, not("--", "Unexpected: ---")) examples exs)
-      val recurse = base flatMap { ex =>
-        val (matching, notMatching) = exs.partition(GlobFilter(ex).accept _)
-        distinctParser(notMatching, raw) map { result => if (raw) ex +: result else matching.toSeq ++ result }
-      }
-      recurse ?? Nil
-    }
-
-  @deprecated("Use the new <key>.all(<ScopeFilter>) API", "0.13.0")
-  def inDependencies[T](key: SettingKey[T], default: ProjectRef => T, includeRoot: Boolean = true, classpath: Boolean = true, aggregate: Boolean = false): Initialize[Seq[T]] =
-    forDependencies[T, T](ref => (key in ref) ?? default(ref), includeRoot, classpath, aggregate)
-
-  @deprecated("Use the new <key>.all(<ScopeFilter>) API", "0.13.0")
-  def forDependencies[T, V](init: ProjectRef => Initialize[V], includeRoot: Boolean = true, classpath: Boolean = true, aggregate: Boolean = false): Initialize[Seq[V]] =
-    Def.bind((loadedBuild, thisProjectRef).identity) {
-      case (lb, base) =>
-        transitiveDependencies(base, lb, includeRoot, classpath, aggregate) map init join;
-    }
-
-  def transitiveDependencies(base: ProjectRef, structure: LoadedBuild, includeRoot: Boolean, classpath: Boolean = true, aggregate: Boolean = false): Seq[ProjectRef] =
-    {
-      def tdeps(enabled: Boolean, f: ProjectRef => Seq[ProjectRef]): Seq[ProjectRef] =
-        {
-          val full = if (enabled) Dag.topologicalSort(base)(f) else Nil
-          if (includeRoot) full else full dropRight 1
-        }
-      def fullCp = tdeps(classpath, getDependencies(structure, classpath = true, aggregate = false))
-      def fullAgg = tdeps(aggregate, getDependencies(structure, classpath = false, aggregate = true))
-      (classpath, aggregate) match {
-        case (true, true)  => (fullCp ++ fullAgg).distinct
-        case (true, false) => fullCp
-        case _             => fullAgg
+  private def distinctParser(exs: Set[String], raw: Boolean): Parser[Seq[String]] = {
+    import DefaultParsers._
+    import Parser.and
+    val base = token(Space) ~> token(and(NotSpace, not("--", "Unexpected: ---")) examples exs)
+    val recurse = base flatMap { ex =>
+      val (matching, notMatching) = exs.partition(GlobFilter(ex).accept _)
+      distinctParser(notMatching, raw) map { result =>
+        if (raw) ex +: result else matching.toSeq ++ result
       }
     }
-  def getDependencies(structure: LoadedBuild, classpath: Boolean = true, aggregate: Boolean = false): ProjectRef => Seq[ProjectRef] =
-    ref => Project.getProject(ref, structure).toList flatMap { p =>
-      (if (classpath) p.dependencies.map(_.project) else Nil) ++
-        (if (aggregate) p.aggregate else Nil)
-    }
+    recurse ?? Nil
+  }
 
   val CompletionsID = "completions"
 
-  def noAggregation: Seq[Scoped] = Seq(run, runMain, console, consoleQuick, consoleProject)
+  def noAggregation: Seq[Scoped] =
+    Seq(run, runMain, bgRun, bgRunMain, console, consoleQuick, consoleProject)
   lazy val disableAggregation = Defaults.globalDefaults(noAggregation map disableAggregate)
-  def disableAggregate(k: Scoped) = aggregate in k :== false
+  def disableAggregate(k: Scoped) = (k / aggregate) :== false
+
+  // 1. runnerSettings is added unscoped via JvmPlugin.
+  // 2. In addition it's added scoped to run task.
+  lazy val runnerSettings: Seq[Setting[_]] = Seq(runnerTask, forkOptions := forkOptionsTask.value)
+  private[this] lazy val newRunnerSettings: Seq[Setting[_]] = {
+    val unscoped: Seq[Def.Setting[_]] =
+      Seq(runner := ClassLoaders.runner.value, forkOptions := forkOptionsTask.value)
+    inConfig(Compile)(unscoped) ++ inConfig(Test)(unscoped)
+  }
 
-  lazy val runnerSettings: Seq[Setting[_]] = Seq(runnerTask)
   lazy val baseTasks: Seq[Setting[_]] = projectTasks ++ packageBase
 
-  lazy val configSettings: Seq[Setting[_]] = Classpaths.configSettings ++ configTasks ++ configPaths ++ packageConfig ++ Classpaths.compilerPluginConfig
+  lazy val configSettings: Seq[Setting[_]] =
+    Classpaths.configSettings ++ configTasks ++ configPaths ++ packageConfig ++
+      Classpaths.compilerPluginConfig ++ deprecationSettings ++
+      BuildServerProtocol.configSettings
+
+  lazy val compileSettings: Seq[Setting[_]] =
+    configSettings ++ (mainBgRunMainTask +: mainBgRunTask) ++ Classpaths.addUnmanagedLibrary
 
-  lazy val compileSettings: Seq[Setting[_]] = configSettings ++ (mainRunMainTask +: mainRunTask +: addBaseSources) ++ Classpaths.addUnmanagedLibrary
   lazy val testSettings: Seq[Setting[_]] = configSettings ++ testTasks
 
-  lazy val itSettings: Seq[Setting[_]] = inConfig(IntegrationTest)(testSettings)
-  lazy val defaultConfigs: Seq[Setting[_]] = inConfig(Compile)(compileSettings) ++ inConfig(Test)(testSettings) ++ inConfig(Runtime)(Classpaths.configSettings)
+  lazy val itSettings: Seq[Setting[_]] = inConfig(IntegrationTest) {
+    testSettings
+  }
+  lazy val defaultConfigs: Seq[Setting[_]] = inConfig(Compile)(compileSettings) ++
+    inConfig(Test)(testSettings) ++
+    inConfig(Runtime)(Classpaths.configSettings)
 
   // These are project level settings that MUST be on every project.
   lazy val coreDefaultSettings: Seq[Setting[_]] =
     projectCore ++ disableAggregation ++ Seq(
       // Missing but core settings
       baseDirectory := thisProject.value.base,
-      target := baseDirectory.value / "target"
+      target := baseDirectory.value / "target",
+      bgHashClasspath := !turbo.value,
+      classLoaderLayeringStrategy := {
+        if (turbo.value) ClassLoaderLayeringStrategy.AllLibraryJars
+        else ClassLoaderLayeringStrategy.ScalaLibrary
+      },
+    )
+  // build.sbt is treated a Scala source of metabuild, so to enable deprecation flag on build.sbt we set the option here.
+  lazy val deprecationSettings: Seq[Setting[_]] =
+    inConfig(Compile)(
+      Seq(
+        scalacOptions := {
+          val old = scalacOptions.value
+          val existing = old.toSet
+          val d = "-deprecation"
+          if (sbtPlugin.value && !existing(d)) d :: old.toList
+          else old
+        }
+      )
     )
 
+  def dependencyResolutionTask: Def.Initialize[Task[DependencyResolution]] =
+    Def.taskIf {
+      if (useCoursier.value) CoursierDependencyResolution(csrConfiguration.value)
+      else IvyDependencyResolution(ivyConfiguration.value, CustomHttp.okhttpClient.value)
+    }
 }
+
 object Classpaths {
-  import Keys._
   import Defaults._
+  import Keys._
 
-  def concatDistinct[T](a: ScopedTaskable[Seq[T]], b: ScopedTaskable[Seq[T]]): Initialize[Task[Seq[T]]] = (a, b) map { (x, y) => (x ++ y).distinct }
-  def concat[T](a: ScopedTaskable[Seq[T]], b: ScopedTaskable[Seq[T]]): Initialize[Task[Seq[T]]] = (a, b) map (_ ++ _)
-  def concatSettings[T](a: SettingKey[Seq[T]], b: SettingKey[Seq[T]]): Initialize[Seq[T]] = (a, b)(_ ++ _)
+  def concatDistinct[T](a: Taskable[Seq[T]], b: Taskable[Seq[T]]): Initialize[Task[Seq[T]]] =
+    Def.task((a.toTask.value ++ b.toTask.value).distinct)
 
+  def concat[T](a: Taskable[Seq[T]], b: Taskable[Seq[T]]): Initialize[Task[Seq[T]]] =
+    Def.task(a.toTask.value ++ b.toTask.value)
+
+  def concatSettings[T](a: Initialize[Seq[T]], b: Initialize[Seq[T]]): Initialize[Seq[T]] =
+    Def.setting { a.value ++ b.value }
+
+  def concatDistinct[T]( // forward to widened variant
+      a: ScopedTaskable[Seq[T]],
+      b: ScopedTaskable[Seq[T]]
+  ): Initialize[Task[Seq[T]]] = concatDistinct(a: Taskable[Seq[T]], b)
+
+  def concat[T](a: ScopedTaskable[Seq[T]], b: ScopedTaskable[Seq[T]]): Initialize[Task[Seq[T]]] =
+    concat(a: Taskable[Seq[T]], b) // forward to widened variant
+
+  def concatSettings[T](a: SettingKey[Seq[T]], b: SettingKey[Seq[T]]): Initialize[Seq[T]] =
+    concatSettings(a: Initialize[Seq[T]], b) // forward to widened variant
+
+  // Included as part of JvmPlugin#projectSettings.
   lazy val configSettings: Seq[Setting[_]] = classpaths ++ Seq(
     products := makeProducts.value,
+    pickleProducts := makePickleProducts.value,
     productDirectories := classDirectory.value :: Nil,
-    classpathConfiguration := findClasspathConfig(internalConfigurationMap.value, configuration.value, classpathConfiguration.?.value, update.value)
+    classpathConfiguration := findClasspathConfig(
+      internalConfigurationMap.value,
+      configuration.value,
+      classpathConfiguration.?.value,
+      update.value
+    )
   )
-  private[this] def classpaths: Seq[Setting[_]] = Seq(
-    externalDependencyClasspath := concat(unmanagedClasspath, managedClasspath).value,
-    dependencyClasspath := concat(internalDependencyClasspath, externalDependencyClasspath).value,
-    fullClasspath := concatDistinct(exportedProducts, dependencyClasspath).value,
-    internalDependencyClasspath := internalDependencies.value,
-    unmanagedClasspath := unmanagedDependencies.value,
-    managedClasspath := managedJars(classpathConfiguration.value, classpathTypes.value, update.value),
-    exportedProducts := trackedExportedProducts(TrackLevel.TrackAlways).value,
-    exportedProductsIfMissing := trackedExportedProducts(TrackLevel.TrackIfMissing).value,
-    exportedProductsNoTracking := trackedExportedProducts(TrackLevel.NoTracking).value,
-    unmanagedJars := findUnmanagedJars(configuration.value, unmanagedBase.value, includeFilter in unmanagedJars value, excludeFilter in unmanagedJars value)
-  ).map(exportClasspath)
+  private[this] def classpaths: Seq[Setting[_]] =
+    Seq(
+      externalDependencyClasspath := concat(unmanagedClasspath, managedClasspath).value,
+      dependencyClasspath := concat(internalDependencyClasspath, externalDependencyClasspath).value,
+      fullClasspath := concatDistinct(exportedProducts, dependencyClasspath).value,
+      internalDependencyClasspath := ClasspathImpl.internalDependencyClasspathTask.value,
+      unmanagedClasspath := unmanagedDependencies.value,
+      managedClasspath := {
+        val isMeta = isMetaBuild.value
+        val force = reresolveSbtArtifacts.value
+        val app = appConfiguration.value
+        def isJansiOrJLine(f: File) = f.getName.contains("jline") || f.getName.contains("jansi")
+        val scalaInstanceJars = app.provider.scalaProvider.jars.filterNot(isJansiOrJLine)
+        val sbtCp = (scalaInstanceJars ++ app.provider.mainClasspath).map(Attributed.blank)
+        val mjars = managedJars(
+          classpathConfiguration.value,
+          classpathTypes.value,
+          update.value
+        )
+        if (isMeta && !force) (mjars ++ sbtCp).distinct
+        else mjars
+      },
+      exportedProducts := ClasspathImpl.trackedExportedProducts(TrackLevel.TrackAlways).value,
+      exportedProductsIfMissing := ClasspathImpl
+        .trackedExportedProducts(TrackLevel.TrackIfMissing)
+        .value,
+      exportedProductsNoTracking := ClasspathImpl
+        .trackedExportedProducts(TrackLevel.NoTracking)
+        .value,
+      exportedProductJars := ClasspathImpl.trackedExportedJarProducts(TrackLevel.TrackAlways).value,
+      exportedProductJarsIfMissing := ClasspathImpl
+        .trackedExportedJarProducts(TrackLevel.TrackIfMissing)
+        .value,
+      exportedProductJarsNoTracking := ClasspathImpl
+        .trackedExportedJarProducts(TrackLevel.NoTracking)
+        .value,
+      internalDependencyAsJars := internalDependencyJarsTask.value,
+      dependencyClasspathAsJars := concat(internalDependencyAsJars, externalDependencyClasspath).value,
+      fullClasspathAsJars := concatDistinct(exportedProductJars, dependencyClasspathAsJars).value,
+      unmanagedJars := findUnmanagedJars(
+        configuration.value,
+        unmanagedBase.value,
+        (unmanagedJars / includeFilter) value,
+        (unmanagedJars / excludeFilter) value
+      )
+    ).map(exportClasspath) ++ Seq(
+      externalDependencyClasspath / outputFileStamps := {
+        val stamper = timeWrappedStamper.value
+        val converter = fileConverter.value
+        externalDependencyClasspath.value flatMap { file0 =>
+          val p = file0.data.toPath
+          FileStamp(stamper.library(converter.toVirtualFile(p))).map(p -> _)
+        }
+      },
+      dependencyClasspathFiles := data(dependencyClasspath.value).map(_.toPath),
+      dependencyClasspathFiles / outputFileStamps := {
+        val stamper = timeWrappedStamper.value
+        val converter = fileConverter.value
+        dependencyClasspathFiles.value.flatMap(
+          p => FileStamp(stamper.library(converter.toVirtualFile(p))).map(p -> _)
+        )
+      },
+      dependencyVirtualClasspath := {
+        val converter = fileConverter.value
+        val cp0 = dependencyClasspath.value
+        cp0 map { attr: Attributed[File] =>
+          attr map { file =>
+            converter.toVirtualFile(file.toPath)
+          }
+        }
+      },
+      // Note: invoking this task from shell would block indefinately because it will
+      // wait for the upstream compilation to start.
+      dependencyPicklePath := {
+        // This is a conditional task. Do not refactor.
+        if (incOptions.value.pipelining) {
+          concat(
+            internalDependencyPicklePath,
+            Def.task {
+              externalDependencyClasspath.value map { attr: Attributed[File] =>
+                attr map { file =>
+                  val converter = fileConverter.value
+                  converter.toVirtualFile(file.toPath)
+                }
+              }
+            }
+          ).value
+        } else {
+          dependencyVirtualClasspath.value
+        }
+      },
+      internalDependencyPicklePath := ClasspathImpl.internalDependencyPicklePathTask.value,
+      exportedPickles := ClasspathImpl.exportedPicklesTask.value,
+    )
 
   private[this] def exportClasspath(s: Setting[Task[Classpath]]): Setting[Task[Classpath]] =
     s.mapInitialize(init => Def.task { exportClasspath(streams.value, init.value) })
-  private[this] def exportClasspath(s: TaskStreams, cp: Classpath): Classpath =
-    {
-      val w = s.text(ExportStream)
-      try w.println(Path.makeString(data(cp)))
-      finally w.close() // workaround for #937
-      cp
-    }
+  private[this] def exportClasspath(s: TaskStreams, cp: Classpath): Classpath = {
+    val w = s.text(ExportStream)
+    try w.println(Path.makeString(data(cp)))
+    finally w.close() // workaround for #937
+    cp
+  }
 
   def defaultPackageKeys = Seq(packageBin, packageSrc, packageDoc)
   lazy val defaultPackages: Seq[TaskKey[File]] =
-    for (task <- defaultPackageKeys; conf <- Seq(Compile, Test)) yield (task in conf)
+    for (task <- defaultPackageKeys; conf <- Seq(Compile, Test)) yield (conf / task)
   lazy val defaultArtifactTasks: Seq[TaskKey[File]] = makePom +: defaultPackages
 
-  def findClasspathConfig(map: Configuration => Configuration, thisConfig: Configuration, delegated: Option[Configuration], report: UpdateReport): Configuration =
-    {
-      val defined = report.allConfigurations.toSet
-      val search = map(thisConfig) +: (delegated.toList ++ Seq(Compile, Configurations.Default))
-      def notFound = sys.error("Configuration to use for managed classpath must be explicitly defined when default configurations are not present.")
-      search find { defined contains _.name } getOrElse notFound
-    }
+  def findClasspathConfig(
+      map: Configuration => Configuration,
+      thisConfig: Configuration,
+      delegated: Option[Configuration],
+      report: UpdateReport
+  ): Configuration = {
+    val defined = report.allConfigurations.toSet
+    val search = map(thisConfig) +: (delegated.toList ++ Seq(Compile, Configurations.Default))
+    def notFound =
+      sys.error(
+        "Configuration to use for managed classpath must be explicitly defined when default configurations are not present."
+      )
+    search find { c =>
+      defined contains ConfigRef(c.name)
+    } getOrElse notFound
+  }
 
   def packaged(pkgTasks: Seq[TaskKey[File]]): Initialize[Task[Map[Artifact, File]]] =
-    enabledOnly(packagedArtifact.task, pkgTasks) apply (_.join.map(_.toMap))
+    enabledOnly(packagedArtifact.toSettingKey, pkgTasks) apply (_.join.map(_.toMap))
+
   def artifactDefs(pkgTasks: Seq[TaskKey[File]]): Initialize[Seq[Artifact]] =
     enabledOnly(artifact, pkgTasks)
 
   def enabledOnly[T](key: SettingKey[T], pkgTasks: Seq[TaskKey[File]]): Initialize[Seq[T]] =
-    (forallIn(key, pkgTasks) zipWith forallIn(publishArtifact, pkgTasks))(_ zip _ collect { case (a, true) => a })
-  def forallIn[T](key: SettingKey[T], pkgTasks: Seq[TaskKey[_]]): Initialize[Seq[T]] =
+    (forallIn(key, pkgTasks) zipWith forallIn(publishArtifact, pkgTasks))(_ zip _ collect {
+      case (a, true) => a
+    })
+
+  @nowarn
+  def forallIn[T](
+      key: Scoped.ScopingSetting[SettingKey[T]], // should be just SettingKey[T] (mea culpa)
+      pkgTasks: Seq[TaskKey[_]],
+  ): Initialize[Seq[T]] =
     pkgTasks.map(pkg => key in pkg.scope in pkg).join
 
-  private[this] def publishGlobalDefaults = Defaults.globalDefaults(Seq(
-    publishMavenStyle :== true,
-    publishArtifact :== true,
-    publishArtifact in Test :== false
-  ))
+  private[this] def publishGlobalDefaults =
+    Defaults.globalDefaults(
+      Seq(
+        publishMavenStyle :== true,
+        publishArtifact :== true,
+        (Test / publishArtifact) :== false
+      )
+    )
 
   val jvmPublishSettings: Seq[Setting[_]] = Seq(
     artifacts := artifactDefs(defaultArtifactTasks).value,
     packagedArtifacts := packaged(defaultArtifactTasks).value
-  )
+  ) ++ RemoteCache.projectSettings
 
   val ivyPublishSettings: Seq[Setting[_]] = publishGlobalDefaults ++ Seq(
     artifacts :== Nil,
     packagedArtifacts :== Map.empty,
     crossTarget := target.value,
-    makePom := { val config = makePomConfiguration.value; IvyActions.makePom(ivyModule.value, config, streams.value.log); config.file },
-    packagedArtifact in makePom := ((artifact in makePom).value -> makePom.value),
-    deliver := deliverTask(deliverConfiguration).value,
-    deliverLocal := deliverTask(deliverLocalConfiguration).value,
-    publish := publishTask(publishConfiguration, deliver).value,
-    publishLocal := publishTask(publishLocalConfiguration, deliverLocal).value,
-    publishM2 := publishTask(publishM2Configuration, deliverLocal).value
+    makePom := {
+      val config = makePomConfiguration.value
+      val publisher = Keys.publisher.value
+      publisher.makePomFile(ivyModule.value, config, streams.value.log)
+      config.file.get
+    },
+    (makePom / packagedArtifact) := ((makePom / artifact).value -> makePom.value),
+    deliver := deliverTask(makeIvyXmlConfiguration).value,
+    deliverLocal := deliverTask(makeIvyXmlLocalConfiguration).value,
+    makeIvyXml := deliverTask(makeIvyXmlConfiguration).value,
+    publish := publishTask(publishConfiguration).value,
+    publishLocal := publishTask(publishLocalConfiguration).value,
+    publishM2 := publishTask(publishM2Configuration).value
   )
 
-  private[this] def baseGlobalDefaults = Defaults.globalDefaults(Seq(
-    conflictWarning :== ConflictWarning.default("global"),
-    compatibilityWarningOptions :== CompatibilityWarningOptions.default,
-    homepage :== None,
-    startYear :== None,
-    licenses :== Nil,
-    developers :== Nil,
-    scmInfo :== None,
-    offline :== false,
-    defaultConfiguration :== Some(Configurations.Compile),
-    dependencyOverrides :== Set.empty,
-    libraryDependencies :== Nil,
-    excludeDependencies :== Nil,
-    ivyLoggingLevel :== {
-      // This will suppress "Resolving..." logs on Jenkins and Travis.
-      if (sys.env.get("BUILD_NUMBER").isDefined || sys.env.get("CI").isDefined) UpdateLogging.Quiet
-      else UpdateLogging.Default
-    },
-    ivyXML :== NodeSeq.Empty,
-    ivyValidate :== false,
-    moduleConfigurations :== Nil,
-    publishTo :== None,
-    resolvers :== Nil,
-    useJCenter :== false,
-    retrievePattern :== Resolver.defaultRetrievePattern,
-    transitiveClassifiers :== Seq(SourceClassifier, DocClassifier),
-    sourceArtifactTypes :== Artifact.DefaultSourceTypes,
-    docArtifactTypes :== Artifact.DefaultDocTypes,
-    sbtDependency := {
-      val app = appConfiguration.value
-      val id = app.provider.id
-      val scalaVersion = app.provider.scalaProvider.version
-      val binVersion = binaryScalaVersion(scalaVersion)
-      val cross = id.crossVersionedValue match {
-        case CrossValue.Disabled => CrossVersion.Disabled
-        case CrossValue.Full     => CrossVersion.binary
-        case CrossValue.Binary   => CrossVersion.full
-      }
-      val base = ModuleID(id.groupID, id.name, sbtVersion.value, crossVersion = cross)
-      CrossVersion(scalaVersion, binVersion)(base).copy(crossVersion = CrossVersion.Disabled)
-    }
-  ))
+  private[this] def baseGlobalDefaults =
+    Defaults.globalDefaults(
+      Seq(
+        conflictWarning :== ConflictWarning.default("global"),
+        evictionWarningOptions := EvictionWarningOptions.default,
+        compatibilityWarningOptions :== CompatibilityWarningOptions.default,
+        homepage :== None,
+        startYear :== None,
+        licenses :== Nil,
+        developers :== Nil,
+        scmInfo :== None,
+        offline :== SysProp.offline,
+        defaultConfiguration :== Some(Configurations.Compile),
+        dependencyOverrides :== Vector.empty,
+        libraryDependencies :== Nil,
+        libraryDependencySchemes :== Nil,
+        evictionErrorLevel :== Level.Error,
+        assumedEvictionErrorLevel :== Level.Info,
+        assumedVersionScheme :== VersionScheme.Always,
+        assumedVersionSchemeJava :== VersionScheme.Always,
+        excludeDependencies :== Nil,
+        ivyLoggingLevel := (// This will suppress "Resolving..." logs on Jenkins and Travis.
+        if (insideCI.value)
+          UpdateLogging.Quiet
+        else UpdateLogging.Default),
+        ivyXML :== NodeSeq.Empty,
+        ivyValidate :== false,
+        moduleConfigurations :== Nil,
+        publishTo :== None,
+        resolvers :== Vector.empty,
+        includePluginResolvers :== false,
+        useJCenter :== false,
+        retrievePattern :== Resolver.defaultRetrievePattern,
+        transitiveClassifiers :== Seq(SourceClassifier, DocClassifier),
+        sourceArtifactTypes :== Artifact.DefaultSourceTypes.toVector,
+        docArtifactTypes :== Artifact.DefaultDocTypes.toVector,
+        cleanKeepFiles :== Nil,
+        cleanKeepGlobs := {
+          val base = appConfiguration.value.baseDirectory.getCanonicalFile
+          val dirs = BuildPaths
+            .globalLoggingStandard(base) :: BuildPaths.globalTaskDirectoryStandard(base) :: Nil
+          dirs.flatMap(d => Glob(d) :: Glob(d, RecursiveGlob) :: Nil)
+        },
+        fileOutputs :== Nil,
+        sbtDependency := {
+          val app = appConfiguration.value
+          val id = app.provider.id
+          val scalaVersion = app.provider.scalaProvider.version
+          val binVersion = binaryScalaVersion(scalaVersion)
+          val cross = id.crossVersionedValue match {
+            case CrossValue.Disabled => Disabled()
+            case CrossValue.Full     => CrossVersion.binary
+            case CrossValue.Binary   => CrossVersion.full
+          }
+          val base = ModuleID(id.groupID, id.name, sbtVersion.value).withCrossVersion(cross)
+          CrossVersion(scalaVersion, binVersion)(base).withCrossVersion(Disabled())
+        },
+        shellPrompt := sbt.internal.ui.UITask.NoShellPrompt,
+        colorShellPrompt := { (c, s) =>
+          shellPrompt.value match {
+            case sbt.internal.ui.UITask.NoShellPrompt => shellPromptFromState(c)(s)
+            case p                                    => p(s)
+          }
+        },
+        dynamicDependency := { (): Unit },
+        transitiveClasspathDependency := { (): Unit },
+        transitiveDynamicInputs :== Nil,
+      )
+    )
 
   val ivyBaseSettings: Seq[Setting[_]] = baseGlobalDefaults ++ sbtClassifiersTasks ++ Seq(
     conflictWarning := conflictWarning.value.copy(label = Reference.display(thisProjectRef.value)),
@@ -1221,37 +2895,82 @@ object Classpaths {
     organization := (organization or normalizedName).value,
     organizationName := (organizationName or organization).value,
     organizationHomepage := (organizationHomepage or homepage).value,
-    projectInfo := ((name, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers) apply ModuleInfo).value,
+    projectInfo := ModuleInfo(
+      name.value,
+      description.value,
+      homepage.value,
+      startYear.value,
+      licenses.value.toVector,
+      organizationName.value,
+      organizationHomepage.value,
+      scmInfo.value,
+      developers.value.toVector
+    ),
     overrideBuildResolvers := appConfiguration(isOverrideRepositories).value,
-    externalResolvers := ((externalResolvers.?.value, resolvers.value, appResolvers.value, useJCenter.value) match {
+    externalResolvers := ((
+      externalResolvers.?.value,
+      resolvers.value,
+      appResolvers.value,
+      useJCenter.value
+    ) match {
       case (Some(delegated), Seq(), _, _) => delegated
-      case (_, rs, Some(ars), uj)         => ars ++ rs
-      case (_, rs, _, uj)                 => Resolver.withDefaultResolvers(rs, uj, mavenCentral = true)
+      case (_, rs, Some(ars), _)          => ars ++ rs
+      case (_, rs, _, uj)                 => Resolver.combineDefaultResolvers(rs.toVector, uj, mavenCentral = true)
     }),
     appResolvers := {
       val ac = appConfiguration.value
       val uj = useJCenter.value
       appRepositories(ac) map { ars =>
-        val useMavenCentral = ars contains DefaultMavenRepository
+        val useMavenCentral = ars contains Resolver.DefaultMavenRepository
         Resolver.reorganizeAppResolvers(ars, uj, useMavenCentral)
       }
     },
     bootResolvers := (appConfiguration map bootRepositories).value,
-    fullResolvers := ((projectResolver, externalResolvers, sbtPlugin, sbtResolver, bootResolvers, overrideBuildResolvers) map { (proj, rs, isPlugin, sbtr, boot, overrideFlag) =>
-      boot match {
-        case Some(repos) if overrideFlag => proj +: repos
-        case _ =>
-          val base = if (isPlugin) sbtr +: sbtPluginReleases +: rs else rs
-          proj +: base
-      }
-    }).value,
+    fullResolvers :=
+      (Def.task {
+        val proj = projectResolver.value
+        val rs = externalResolvers.value
+        def pluginResolvers: Vector[Resolver] =
+          buildStructure.value
+            .units(thisProjectRef.value.build)
+            .unit
+            .plugins
+            .pluginData
+            .resolvers
+            .getOrElse(Vector.empty)
+        val pr =
+          if (includePluginResolvers.value) pluginResolvers
+          else Vector.empty
+        bootResolvers.value match {
+          case Some(repos) if overrideBuildResolvers.value => proj +: repos
+          case _ =>
+            val base = if (sbtPlugin.value) sbtResolvers.value ++ rs ++ pr else rs ++ pr
+            (proj +: base).distinct
+        }
+      }).value,
     moduleName := normalizedName.value,
-    ivyPaths := new IvyPaths(baseDirectory.value, bootIvyHome(appConfiguration.value)),
+    ivyPaths := IvyPaths(baseDirectory.value, bootIvyHome(appConfiguration.value)),
+    csrCacheDirectory := {
+      val old = csrCacheDirectory.value
+      val ac = appConfiguration.value
+      val ip = ivyPaths.value
+      // if ivyPaths is customized, create coursier-cache directory in it
+      if (useCoursier.value) {
+        val defaultIvyCache = bootIvyHome(ac)
+        if (old != LMCoursier.defaultCacheLocation) old
+        else if (ip.ivyHome == defaultIvyCache) old
+        else
+          ip.ivyHome match {
+            case Some(home) => home / "coursier-cache"
+            case _          => old
+          }
+      } else Classpaths.dummyCoursierDirectory(ac)
+    },
     dependencyCacheDirectory := {
       val st = state.value
       BuildPaths.getDependencyDirectory(st, BuildPaths.getGlobalBase(st))
     },
-    otherResolvers := Resolver.publishMavenLocal :: publishTo.value.toList,
+    otherResolvers := Resolver.publishMavenLocal +: publishTo.value.toVector,
     projectResolver := projectResolverTask.value,
     projectDependencies := projectDependenciesTask.value,
     // TODO - Is this the appropriate split?  Ivy defines this simply as
@@ -1260,665 +2979,1103 @@ object Classpaths {
     allDependencies := {
       projectDependencies.value ++ libraryDependencies.value
     },
-    ivyScala :=
-      (ivyScala or ((scalaHome, scalaVersion in update, scalaBinaryVersion in update, scalaOrganization, sbtPlugin) { (sh, fv, bv, so, plugin) =>
-        Option(new IvyScala(fv, bv, Nil, filterImplicit = false, checkExplicit = true, overrideScalaVersion = true, scalaOrganization = so))
-      })).value,
-    artifactPath in makePom := artifactPathSetting(artifact in makePom).value,
-    publishArtifact in makePom := publishMavenStyle.value && publishArtifact.value,
-    artifact in makePom := Artifact.pom(moduleName.value),
+    allExcludeDependencies := excludeDependencies.value,
+    scalaModuleInfo := (scalaModuleInfo or (
+      Def.setting {
+        Option(
+          ScalaModuleInfo(
+            (update / scalaVersion).value,
+            (update / scalaBinaryVersion).value,
+            Vector.empty,
+            filterImplicit = false,
+            checkExplicit = true,
+            overrideScalaVersion = true
+          ).withScalaOrganization(scalaOrganization.value)
+            .withScalaArtifacts(scalaArtifacts.value.toVector)
+        )
+      }
+    )).value,
+    makePom / artifactPath := artifactPathSetting((makePom / artifact)).value,
+    makePom / publishArtifact := publishMavenStyle.value && publishArtifact.value,
+    makePom / artifact := Artifact.pom(moduleName.value),
     projectID := defaultProjectID.value,
     projectID := pluginProjectID.value,
     projectDescriptors := depMap.value,
     updateConfiguration := {
       // Tell the UpdateConfiguration which artifact types are special (for sources and javadocs)
-      val specialArtifactTypes = sourceArtifactTypes.value union docArtifactTypes.value
+      val specialArtifactTypes = sourceArtifactTypes.value.toSet union docArtifactTypes.value.toSet
       // By default, to retrieve all types *but* these (it's assumed that everything else is binary/resource)
-      new UpdateConfiguration(retrieveConfiguration.value, false, ivyLoggingLevel.value, ArtifactTypeFilter.forbid(specialArtifactTypes))
+      UpdateConfiguration()
+        .withRetrieveManaged(retrieveConfiguration.value)
+        .withLogging(ivyLoggingLevel.value)
+        .withArtifactFilter(ArtifactTypeFilter.forbid(specialArtifactTypes))
+        .withOffline(offline.value)
     },
-    retrieveConfiguration := { if (retrieveManaged.value) Some(new RetrieveConfiguration(managedDirectory.value, retrievePattern.value, retrieveManagedSync.value, configurationsToRetrieve.value)) else None },
+    retrieveConfiguration := {
+      if (retrieveManaged.value)
+        Some(
+          RetrieveConfiguration()
+            .withRetrieveDirectory(managedDirectory.value)
+            .withOutputPattern(retrievePattern.value)
+            .withSync(retrieveManagedSync.value)
+            .withConfigurationsToRetrieve(configurationsToRetrieve.value map { _.toVector })
+        )
+      else None
+    },
+    dependencyResolution := dependencyResolutionTask.value,
+    publisher := IvyPublisher(ivyConfiguration.value, CustomHttp.okhttpClient.value),
     ivyConfiguration := mkIvyConfiguration.value,
     ivyConfigurations := {
       val confs = thisProject.value.configurations
-      (confs ++ confs.map(internalConfigurationMap.value) ++ (if (autoCompilerPlugins.value) CompilerPlugin :: Nil else Nil)).distinct
+      (confs ++ confs.map(internalConfigurationMap.value) ++ (if (autoCompilerPlugins.value)
+                                                                CompilerPlugin :: Nil
+                                                              else Nil)).distinct
     },
     ivyConfigurations ++= Configurations.auxiliary,
-    ivyConfigurations ++= { if (managedScalaInstance.value && scalaHome.value.isEmpty) Configurations.ScalaTool :: Nil else Nil },
+    ivyConfigurations ++= {
+      if (managedScalaInstance.value && scalaHome.value.isEmpty)
+        Configurations.ScalaTool :: Configurations.ScalaDocTool :: Nil
+      else Nil
+    },
+    // Coursier needs these
+    ivyConfigurations := {
+      val confs = ivyConfigurations.value
+      val names = confs.map(_.name).toSet
+      val extraSources =
+        if (names("sources"))
+          None
+        else
+          Some(
+            Configuration.of(
+              id = "Sources",
+              name = "sources",
+              description = "",
+              isPublic = true,
+              extendsConfigs = Vector.empty,
+              transitive = false
+            )
+          )
+
+      val extraDocs =
+        if (names("docs"))
+          None
+        else
+          Some(
+            Configuration.of(
+              id = "Docs",
+              name = "docs",
+              description = "",
+              isPublic = true,
+              extendsConfigs = Vector.empty,
+              transitive = false
+            )
+          )
+
+      val use = useCoursier.value
+      if (use) confs ++ extraSources.toSeq ++ extraDocs.toSeq
+      else confs
+    },
     moduleSettings := moduleSettings0.value,
-    makePomConfiguration := new MakePomConfiguration(artifactPath in makePom value, projectInfo.value, None, pomExtra.value, pomPostProcess.value, pomIncludeRepository.value, pomAllRepositories.value),
-    deliverLocalConfiguration := deliverConfig(crossTarget.value, status = if (isSnapshot.value) "integration" else "release", logging = ivyLoggingLevel.value),
-    deliverConfiguration := deliverLocalConfiguration.value,
-    publishConfiguration := publishConfig(packagedArtifacts.in(publish).value, if (publishMavenStyle.value) None else Some(deliver.value), resolverName = getPublishTo(publishTo.value).name, checksums = checksums.in(publish).value, logging = ivyLoggingLevel.value, overwrite = isSnapshot.value),
-    publishLocalConfiguration := publishConfig(packagedArtifacts.in(publishLocal).value, Some(deliverLocal.value), checksums.in(publishLocal).value, logging = ivyLoggingLevel.value, overwrite = isSnapshot.value),
-    publishM2Configuration := publishConfig(packagedArtifacts.in(publishM2).value, None, resolverName = Resolver.publishMavenLocal.name, checksums = checksums.in(publishM2).value, logging = ivyLoggingLevel.value, overwrite = isSnapshot.value),
+    makePomConfiguration := MakePomConfiguration()
+      .withFile((makePom / artifactPath).value)
+      .withModuleInfo(projectInfo.value)
+      .withExtra(pomExtra.value)
+      .withProcess(pomPostProcess.value)
+      .withFilterRepositories(pomIncludeRepository.value)
+      .withAllRepositories(pomAllRepositories.value)
+      .withConfigurations(Configurations.defaultMavenConfigurations),
+    makeIvyXmlConfiguration := {
+      makeIvyXmlConfig(
+        publishMavenStyle.value,
+        sbt.Classpaths.deliverPattern(crossTarget.value),
+        if (isSnapshot.value) "integration" else "release",
+        ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
+        (publish / checksums).value.toVector,
+        ivyLoggingLevel.value,
+        isSnapshot.value
+      )
+    },
+    publishConfiguration := {
+      val s = streams.value
+      val vs = versionScheme.value
+      if (vs.isEmpty)
+        s.log.warn(
+          s"""versionScheme setting is empty; set `ThisBuild / versionScheme := Some("early-semver")`, `Some("semver-spec")` or `Some("pvp")`
+             |so tooling can use it for evction errors etc - https://www.scala-sbt.org/1.x/docs/Publishing.html""".stripMargin
+        )
+      else ()
+      publishConfig(
+        publishMavenStyle.value,
+        deliverPattern(crossTarget.value),
+        if (isSnapshot.value) "integration" else "release",
+        ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
+        (publish / packagedArtifacts).value.toVector,
+        (publish / checksums).value.toVector,
+        getPublishTo(publishTo.value).name,
+        ivyLoggingLevel.value,
+        isSnapshot.value
+      )
+    },
+    makeIvyXmlLocalConfiguration := {
+      makeIvyXmlConfig(
+        false, //publishMavenStyle.value,
+        sbt.Classpaths.deliverPattern(crossTarget.value),
+        if (isSnapshot.value) "integration" else "release",
+        ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
+        (publish / checksums).value.toVector,
+        ivyLoggingLevel.value,
+        isSnapshot.value,
+        optResolverName = Some("local")
+      )
+    },
+    publishLocalConfiguration := publishConfig(
+      false, //publishMavenStyle.value,
+      deliverPattern(crossTarget.value),
+      if (isSnapshot.value) "integration" else "release",
+      ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
+      (publishLocal / packagedArtifacts).value.toVector,
+      (publishLocal / checksums).value.toVector,
+      logging = ivyLoggingLevel.value,
+      overwrite = isSnapshot.value
+    ),
+    publishM2Configuration := publishConfig(
+      true,
+      deliverPattern(crossTarget.value),
+      if (isSnapshot.value) "integration" else "release",
+      ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
+      (publishM2 / packagedArtifacts).value.toVector,
+      checksums = (publishM2 / checksums).value.toVector,
+      resolverName = Resolver.publishMavenLocal.name,
+      logging = ivyLoggingLevel.value,
+      overwrite = isSnapshot.value
+    ),
     ivySbt := ivySbt0.value,
     ivyModule := { val is = ivySbt.value; new is.Module(moduleSettings.value) },
+    allCredentials := LMCoursier.allCredentialsTask.value,
     transitiveUpdate := transitiveUpdateTask.value,
-    updateCacheName := "update_cache" + (if (crossPaths.value) s"_${scalaBinaryVersion.value}" else ""),
-    evictionWarningOptions in update := EvictionWarningOptions.default,
+    updateCacheName := {
+      val binVersion = scalaBinaryVersion.value
+      val suffix = if (crossPaths.value) s"_$binVersion" else ""
+      s"update_cache$suffix"
+    },
     dependencyPositions := dependencyPositionsTask.value,
-    unresolvedWarningConfiguration in update := UnresolvedWarningConfiguration(dependencyPositions.value),
-    update := (updateTask tag (Tags.Update, Tags.Network)).value,
+    update / unresolvedWarningConfiguration := UnresolvedWarningConfiguration(
+      dependencyPositions.value
+    ),
+    updateFull := (updateTask tag (Tags.Update, Tags.Network)).value,
+    update := (updateWithoutDetails("update") tag (Tags.Update, Tags.Network)).value,
     update := {
       val report = update.value
       val log = streams.value.log
       ConflictWarning(conflictWarning.value, report, log)
       report
     },
-    evictionWarningOptions in evicted := EvictionWarningOptions.full,
+    update / evictionWarningOptions := evictionWarningOptions.value,
+    evicted / evictionWarningOptions := EvictionWarningOptions.full,
     evicted := {
       import ShowLines._
       val report = (updateTask tag (Tags.Update, Tags.Network)).value
       val log = streams.value.log
-      val ew = EvictionWarning(ivyModule.value, (evictionWarningOptions in evicted).value, report, log)
+      val ew =
+        EvictionWarning(ivyModule.value, (evicted / evictionWarningOptions).value, report)
       ew.lines foreach { log.warn(_) }
       ew.infoAllTheThings foreach { log.info(_) }
       ew
     },
-    classifiersModule in updateClassifiers := {
-      implicit val key = (m: ModuleID) => (m.organization, m.name, m.revision)
-      val projectDeps = projectDependencies.value.iterator.map(key).toSet
-      val externalModules = update.value.allModules.filterNot(m => projectDeps contains key(m))
-      GetClassifiersModule(projectID.value, externalModules, ivyConfigurations.in(updateClassifiers).value, transitiveClassifiers.in(updateClassifiers).value)
-    },
-    updateClassifiers := (Def.task {
-      val s = streams.value
-      val is = ivySbt.value
-      val mod = (classifiersModule in updateClassifiers).value
-      val c = updateConfiguration.value
-      val app = appConfiguration.value
-      val srcTypes = sourceArtifactTypes.value
-      val docTypes = docArtifactTypes.value
-      val out = is.withIvy(s.log)(_.getSettings.getDefaultIvyUserDir)
-      val uwConfig = (unresolvedWarningConfiguration in update).value
-      val depDir = dependencyCacheDirectory.value
-      withExcludes(out, mod.classifiers, lock(app)) { excludes =>
-        IvyActions.updateClassifiers(is, GetClassifiersConfiguration(mod, excludes, c.copy(artifactFilter = c.artifactFilter.invert), ivyScala.value, srcTypes, docTypes), uwConfig, LogicalClock(state.value.hashCode), Some(depDir), Vector.empty, s.log)
-      }
-    } tag (Tags.Update, Tags.Network)).value
-  )
+  ) ++
+    inTask(updateClassifiers)(
+      Seq(
+        classifiersModule := {
+          implicit val key = (m: ModuleID) => (m.organization, m.name, m.revision)
+          val projectDeps = projectDependencies.value.iterator.map(key).toSet
+          val externalModules = update.value.allModules.filterNot(m => projectDeps contains key(m))
+          GetClassifiersModule(
+            projectID.value,
+            None,
+            externalModules,
+            ivyConfigurations.value.toVector,
+            transitiveClassifiers.value.toVector
+          )
+        },
+        dependencyResolution := dependencyResolutionTask.value,
+        csrConfiguration := LMCoursier.updateClassifierConfigurationTask.value,
+        TaskGlobal / updateClassifiers := LibraryManagement.updateClassifiersTask.value,
+      )
+    ) ++ Seq(
+    csrProject := CoursierInputsTasks.coursierProjectTask.value,
+    csrConfiguration := LMCoursier.coursierConfigurationTask.value,
+    csrResolvers := CoursierRepositoriesTasks.coursierResolversTask.value,
+    csrRecursiveResolvers := CoursierRepositoriesTasks.coursierRecursiveResolversTask.value,
+    csrSbtResolvers := CoursierRepositoriesTasks.coursierSbtResolversTask.value,
+    csrInterProjectDependencies := CoursierInputsTasks.coursierInterProjectDependenciesTask.value,
+    csrExtraProjects := CoursierInputsTasks.coursierExtraProjectsTask.value,
+    csrFallbackDependencies := CoursierInputsTasks.coursierFallbackDependenciesTask.value,
+  ) ++
+    IvyXml.generateIvyXmlSettings() ++
+    LMCoursier.publicationsSetting(Seq(Compile, Test).map(c => c -> CConfiguration(c.name)))
 
   val jvmBaseSettings: Seq[Setting[_]] = Seq(
-    libraryDependencies ++= autoLibraryDependency(autoScalaLibrary.value && scalaHome.value.isEmpty && managedScalaInstance.value, sbtPlugin.value, scalaOrganization.value, scalaVersion.value),
+    libraryDependencies ++= autoLibraryDependency(
+      autoScalaLibrary.value && scalaHome.value.isEmpty && managedScalaInstance.value,
+      sbtPlugin.value,
+      scalaOrganization.value,
+      scalaVersion.value
+    ),
     // Override the default to handle mixing in the sbtPlugin + scala dependencies.
     allDependencies := {
       val base = projectDependencies.value ++ libraryDependencies.value
-      val pluginAdjust = if (sbtPlugin.value) sbtDependency.value.copy(configurations = Some(Provided.name)) +: base else base
-      if (scalaHome.value.isDefined || ivyScala.value.isEmpty || !managedScalaInstance.value)
-        pluginAdjust
-      else {
-        val version = scalaVersion.value
-        val isDotty = ScalaInstance.isDotty(version)
-        ScalaArtifacts.toolDependencies(scalaOrganization.value, version, isDotty) ++ pluginAdjust
-      }
+      val isPlugin = sbtPlugin.value
+      val sbtdeps =
+        (pluginCrossBuild / sbtDependency).value.withConfigurations(Some(Provided.name))
+      val pluginAdjust =
+        if (isPlugin) sbtdeps +: base
+        else base
+      val sbtOrg = scalaOrganization.value
+      val version = scalaVersion.value
+      val extResolvers = externalResolvers.value
+      val isScala3M123 = ScalaArtifacts.isScala3M123(version)
+      val allToolDeps =
+        if (scalaHome.value.isDefined || scalaModuleInfo.value.isEmpty || !managedScalaInstance.value)
+          Nil
+        else if (!isScala3M123 || extResolvers.contains(Resolver.JCenterRepository)) {
+          ScalaArtifacts.toolDependencies(sbtOrg, version) ++
+            ScalaArtifacts.docToolDependencies(sbtOrg, version)
+        } else ScalaArtifacts.toolDependencies(sbtOrg, version)
+      allToolDeps ++ pluginAdjust
+    },
+    // in case of meta build, exclude all sbt modules from the dependency graph, so we can use the sbt resolved by the launcher
+    allExcludeDependencies := {
+      val sbtdeps = sbtDependency.value
+      val isMeta = isMetaBuild.value
+      val force = reresolveSbtArtifacts.value
+      val excludes = excludeDependencies.value
+      val o = sbtdeps.organization
+      val sbtModulesExcludes = Vector[ExclusionRule](
+        o % "sbt",
+        o %% "scripted-plugin",
+        o %% "librarymanagement-core",
+        o %% "librarymanagement-ivy",
+        o %% "util-logging",
+        o %% "util-position",
+        o %% "io"
+      )
+      if (isMeta && !force) excludes.toVector ++ sbtModulesExcludes
+      else excludes
+    },
+    dependencyOverrides ++= {
+      val isPlugin = sbtPlugin.value
+      val app = appConfiguration.value
+      val id = app.provider.id
+      val sv = (pluginCrossBuild / sbtVersion).value
+      val base = ModuleID(id.groupID, "scripted-plugin", sv).withCrossVersion(CrossVersion.binary)
+      if (isPlugin) Seq(base)
+      else Seq()
     }
   )
 
   def warnResolversConflict(ress: Seq[Resolver], log: Logger): Unit = {
     val resset = ress.toSet
     for ((name, r) <- resset groupBy (_.name) if r.size > 1) {
-      log.warn("Multiple resolvers having different access mechanism configured with same name '" + name + "'. To avoid conflict, Remove duplicate project resolvers (`resolvers`) or rename publishing resolver (`publishTo`).")
+      log.warn(
+        "Multiple resolvers having different access mechanism configured with same name '" + name + "'. To avoid conflict, Remove duplicate project resolvers (`resolvers`) or rename publishing resolver (`publishTo`)."
+      )
+    }
+  }
+
+  private[sbt] def errorInsecureProtocol(ress: Seq[Resolver], log: Logger): Unit = {
+    val bad = !ress.forall(!_.validateProtocol(log))
+    if (bad) {
+      sys.error("insecure protocol is unsupported")
+    }
+  }
+  // this warns about .from("http:/...") in ModuleID
+  private[sbt] def errorInsecureProtocolInModules(mods: Seq[ModuleID], log: Logger): Unit = {
+    val artifacts = mods.flatMap(_.explicitArtifacts.toSeq)
+    val bad = !artifacts.forall(!_.validateProtocol(log))
+    if (bad) {
+      sys.error("insecure protocol is unsupported")
     }
   }
 
   private[sbt] def defaultProjectID: Initialize[ModuleID] = Def.setting {
-    val base = ModuleID(organization.value, moduleName.value, version.value).cross(crossVersion in projectID value).artifacts(artifacts.value: _*)
-    apiURL.value match {
-      case Some(u) => base.extra(SbtPomExtraProperties.POM_API_KEY -> u.toExternalForm)
-      case _       => base
+    val p0 = ModuleID(organization.value, moduleName.value, version.value)
+      .cross((projectID / crossVersion) value)
+      .artifacts(artifacts.value: _*)
+    val p1 = apiURL.value match {
+      case Some(u) => p0.extra(SbtPomExtraProperties.POM_API_KEY -> u.toExternalForm)
+      case _       => p0
     }
+    val p2 = versionScheme.value match {
+      case Some(x) =>
+        VersionSchemes.validateScheme(x)
+        p1.extra(SbtPomExtraProperties.VERSION_SCHEME_KEY -> x)
+      case _ => p1
+    }
+    p2
   }
-
-  def pluginProjectID: Initialize[ModuleID] = (sbtBinaryVersion in update, scalaBinaryVersion in update, projectID, sbtPlugin) {
-    (sbtBV, scalaBV, pid, isPlugin) =>
-      if (isPlugin) sbtPluginExtra(pid, sbtBV, scalaBV) else pid
-  }
-  def ivySbt0: Initialize[Task[IvySbt]] =
-    (ivyConfiguration, credentials, streams) map { (conf, creds, s) =>
-      Credentials.register(creds, s.log)
-      new IvySbt(conf)
+  def pluginProjectID: Initialize[ModuleID] =
+    Def.setting {
+      if (sbtPlugin.value)
+        sbtPluginExtra(
+          projectID.value,
+          (pluginCrossBuild / sbtBinaryVersion).value,
+          (pluginCrossBuild / scalaBinaryVersion).value
+        )
+      else projectID.value
+    }
+  private[sbt] def ivySbt0: Initialize[Task[IvySbt]] =
+    Def.task {
+      Credentials.register(credentials.value, streams.value.log)
+      new IvySbt(ivyConfiguration.value, CustomHttp.okhttpClient.value)
     }
   def moduleSettings0: Initialize[Task[ModuleSettings]] = Def.task {
-    new InlineConfiguration(projectID.value, projectInfo.value, allDependencies.value, dependencyOverrides.value, excludeDependencies.value,
-      ivyXML.value, ivyConfigurations.value, defaultConfiguration.value, ivyScala.value, ivyValidate.value, conflictManager.value)
+    val deps = allDependencies.value.toVector
+    errorInsecureProtocolInModules(deps, streams.value.log)
+    ModuleDescriptorConfiguration(projectID.value, projectInfo.value)
+      .withValidate(ivyValidate.value)
+      .withScalaModuleInfo(scalaModuleInfo.value)
+      .withDependencies(deps)
+      .withOverrides(dependencyOverrides.value.toVector)
+      .withExcludes(allExcludeDependencies.value.toVector)
+      .withIvyXML(ivyXML.value)
+      .withConfigurations(ivyConfigurations.value.toVector)
+      .withDefaultConfiguration(defaultConfiguration.value)
+      .withConflictManager(conflictManager.value)
   }
 
-  private[this] def sbtClassifiersGlobalDefaults = Defaults.globalDefaults(Seq(
-    transitiveClassifiers in updateSbtClassifiers ~= (_.filter(_ != DocClassifier))
-  ))
-  def sbtClassifiersTasks = sbtClassifiersGlobalDefaults ++ inTask(updateSbtClassifiers)(Seq(
-    externalResolvers := {
-      val explicit = buildStructure.value.units(thisProjectRef.value.build).unit.plugins.pluginData.resolvers
-      explicit orElse bootRepositories(appConfiguration.value) getOrElse externalResolvers.value
-    },
-    ivyConfiguration := new InlineIvyConfiguration(ivyPaths.value, externalResolvers.value, Nil, Nil, offline.value, Option(lock(appConfiguration.value)),
-      checksums.value, Some(target.value / "resolution-cache"), UpdateOptions(), streams.value.log),
-    ivySbt := ivySbt0.value,
-    classifiersModule := ((projectID, sbtDependency, transitiveClassifiers, loadedBuild, thisProjectRef) map { (pid, sbtDep, classifiers, lb, ref) =>
-      val pluginClasspath = lb.units(ref.build).unit.plugins.fullClasspath
-      val pluginJars = pluginClasspath.filter(_.data.isFile) // exclude directories: an approximation to whether they've been published
-      val pluginIDs: Seq[ModuleID] = pluginJars.flatMap(_ get moduleID.key)
-      GetClassifiersModule(pid, sbtDep +: pluginIDs, Configurations.Default :: Nil, classifiers)
-    }).value,
-    updateSbtClassifiers in TaskGlobal := (Def.task {
-      val s = streams.value
-      val is = ivySbt.value
-      val mod = classifiersModule.value
-      val c = updateConfiguration.value
-      val app = appConfiguration.value
-      val srcTypes = sourceArtifactTypes.value
-      val docTypes = docArtifactTypes.value
-      val out = is.withIvy(s.log)(_.getSettings.getDefaultIvyUserDir)
-      val uwConfig = (unresolvedWarningConfiguration in update).value
-      val depDir = dependencyCacheDirectory.value
-      withExcludes(out, mod.classifiers, lock(app)) { excludes =>
-        val noExplicitCheck = ivyScala.value.map(_.copy(checkExplicit = false))
-        IvyActions.transitiveScratch(is, "sbt", GetClassifiersConfiguration(mod, excludes, c.copy(artifactFilter = c.artifactFilter.invert), noExplicitCheck, srcTypes, docTypes), uwConfig, LogicalClock(state.value.hashCode), Some(depDir), s.log)
-      }
-    } tag (Tags.Update, Tags.Network)).value
-  )) ++ Seq(bootIvyConfiguration := (ivyConfiguration in updateSbtClassifiers).value)
+  private[this] def sbtClassifiersGlobalDefaults =
+    Defaults.globalDefaults(
+      Seq(
+        (updateSbtClassifiers / transitiveClassifiers) ~= (_.filter(_ != DocClassifier))
+      )
+    )
+  def sbtClassifiersTasks =
+    sbtClassifiersGlobalDefaults ++
+      inTask(updateSbtClassifiers)(
+        Seq(
+          externalResolvers := {
+            val boot = bootResolvers.value
+            val explicit = buildStructure.value
+              .units(thisProjectRef.value.build)
+              .unit
+              .plugins
+              .pluginData
+              .resolvers
+            explicit orElse boot getOrElse externalResolvers.value
+          },
+          ivyConfiguration := InlineIvyConfiguration(
+            lock = Option(lock(appConfiguration.value)),
+            log = Option(streams.value.log),
+            updateOptions = UpdateOptions(),
+            paths = Option(ivyPaths.value),
+            resolvers = externalResolvers.value.toVector,
+            otherResolvers = Vector.empty,
+            moduleConfigurations = Vector.empty,
+            checksums = checksums.value.toVector,
+            managedChecksums = false,
+            resolutionCacheDir = Some(crossTarget.value / "resolution-cache"),
+          ),
+          ivySbt := ivySbt0.value,
+          classifiersModule := classifiersModuleTask.value,
+          // Redefine scalaVersion and scalaBinaryVersion specifically for the dependency graph used for updateSbtClassifiers task.
+          // to fix https://github.com/sbt/sbt/issues/2686
+          scalaVersion := appConfiguration.value.provider.scalaProvider.version,
+          scalaBinaryVersion := binaryScalaVersion(scalaVersion.value),
+          scalaOrganization := ScalaArtifacts.Organization,
+          scalaModuleInfo := {
+            Some(
+              ScalaModuleInfo(
+                scalaVersion.value,
+                scalaBinaryVersion.value,
+                Vector(),
+                checkExplicit = false,
+                filterImplicit = false,
+                overrideScalaVersion = true
+              ).withScalaOrganization(scalaOrganization.value)
+            )
+          },
+          dependencyResolution := dependencyResolutionTask.value,
+          csrConfiguration := LMCoursier.updateSbtClassifierConfigurationTask.value,
+          (TaskGlobal / updateSbtClassifiers) := (Def.task {
+            val lm = dependencyResolution.value
+            val s = streams.value
+            val is = ivySbt.value
+            val mod = classifiersModule.value
+            val updateConfig0 = updateConfiguration.value
+            val updateConfig = updateConfig0
+              .withMetadataDirectory(dependencyCacheDirectory.value)
+              .withArtifactFilter(
+                updateConfig0.artifactFilter.map(af => af.withInverted(!af.inverted))
+              )
+            val app = appConfiguration.value
+            val srcTypes = sourceArtifactTypes.value
+            val docTypes = docArtifactTypes.value
+            val log = s.log
+            val out = is.withIvy(log)(_.getSettings.getDefaultIvyUserDir)
+            val uwConfig = (update / unresolvedWarningConfiguration).value
+            withExcludes(out, mod.classifiers, lock(app)) { excludes =>
+              // val noExplicitCheck = ivy.map(_.withCheckExplicit(false))
+              LibraryManagement.transitiveScratch(
+                lm,
+                "sbt",
+                GetClassifiersConfiguration(
+                  mod,
+                  excludes.toVector,
+                  updateConfig,
+                  srcTypes.toVector,
+                  docTypes.toVector
+                ),
+                uwConfig,
+                log
+              ) match {
+                case Left(_)   => ???
+                case Right(ur) => ur
+              }
+            }
+          } tag (Tags.Update, Tags.Network)).value
+        )
+      ) ++
+      inTask(scalaCompilerBridgeScope)(
+        Seq(
+          dependencyResolution := dependencyResolutionTask.value,
+          csrConfiguration := LMCoursier.scalaCompilerBridgeConfigurationTask.value,
+          csrResolvers := CoursierRepositoriesTasks.coursierResolversTask.value,
+          externalResolvers := scalaCompilerBridgeResolvers.value,
+          ivyConfiguration := InlineIvyConfiguration(
+            lock = Option(lock(appConfiguration.value)),
+            log = Option(streams.value.log),
+            updateOptions = UpdateOptions(),
+            paths = Option(ivyPaths.value),
+            resolvers = scalaCompilerBridgeResolvers.value.toVector,
+            otherResolvers = Vector.empty,
+            moduleConfigurations = Vector.empty,
+            checksums = checksums.value.toVector,
+            managedChecksums = false,
+            resolutionCacheDir = Some(crossTarget.value / "bridge-resolution-cache"),
+          )
+        )
+      ) ++ Seq(
+      bootIvyConfiguration := (updateSbtClassifiers / ivyConfiguration).value,
+      bootDependencyResolution := (updateSbtClassifiers / dependencyResolution).value,
+      scalaCompilerBridgeResolvers := {
+        val boot = bootResolvers.value
+        val explicit = buildStructure.value
+          .units(thisProjectRef.value.build)
+          .unit
+          .plugins
+          .pluginData
+          .resolvers
+        val ext = externalResolvers.value.toVector
+        // https://github.com/sbt/sbt/issues/4408
+        val xs = (explicit, boot) match {
+          case (Some(ex), Some(b)) => (ex.toVector ++ b.toVector).distinct
+          case (Some(ex), None)    => ex.toVector
+          case (None, Some(b))     => b.toVector
+          case _                   => Vector()
+        }
+        (xs ++ ext).distinct
+      },
+      scalaCompilerBridgeDependencyResolution := (scalaCompilerBridgeScope / dependencyResolution).value
+    )
 
-  def deliverTask(config: TaskKey[DeliverConfiguration]): Initialize[Task[File]] =
-    (ivyModule, config, update, streams) map { (module, config, _, s) => IvyActions.deliver(module, config, s.log) }
-  def publishTask(config: TaskKey[PublishConfiguration], deliverKey: TaskKey[_]): Initialize[Task[Unit]] =
-    (ivyModule, config, streams) map { (module, config, s) =>
-      IvyActions.publish(module, config, s.log)
+  def classifiersModuleTask: Initialize[Task[GetClassifiersModule]] =
+    Def.task {
+      val classifiers = transitiveClassifiers.value
+      val ref = thisProjectRef.value
+      val pluginClasspath = loadedBuild.value.units(ref.build).unit.plugins.fullClasspath.toVector
+      val pluginJars = pluginClasspath.filter(_.data.isFile) // exclude directories: an approximation to whether they've been published
+      val pluginIDs: Vector[ModuleID] = pluginJars.flatMap(_ get moduleID.key)
+      GetClassifiersModule(
+        projectID.value,
+        // TODO: Should it be sbt's scalaModuleInfo?
+        scalaModuleInfo.value,
+        sbtDependency.value +: pluginIDs,
+        // sbt is now on Maven Central, so this has changed from sbt 0.13.
+        Vector(Configurations.Default) ++ Configurations.default,
+        classifiers.toVector
+      )
+    }
+
+  def deliverTask(config: TaskKey[PublishConfiguration]): Initialize[Task[File]] =
+    Def.task {
+      Def.unit(update.value)
+      IvyActions.deliver(ivyModule.value, config.value, streams.value.log)
+    }
+
+  @deprecated("Use variant without delivery key", "1.1.1")
+  def publishTask(
+      config: TaskKey[PublishConfiguration],
+      deliverKey: TaskKey[_],
+  ): Initialize[Task[Unit]] =
+    publishTask(config)
+
+  def publishTask(config: TaskKey[PublishConfiguration]): Initialize[Task[Unit]] =
+    Def.taskIf {
+      if ((publish / skip).value) {
+        val s = streams.value
+        val ref = thisProjectRef.value
+        s.log.debug(s"Skipping publish* for ${ref.project}")
+      } else {
+        val s = streams.value
+        IvyActions.publish(ivyModule.value, config.value, s.log)
+      }
     } tag (Tags.Publish, Tags.Network)
 
-  import CacheIvy.{ updateIC, updateReportFormat, excludeMap, moduleIDSeqIC, modulePositionMapFormat }
-
-  def withExcludes(out: File, classifiers: Seq[String], lock: xsbti.GlobalLock)(f: Map[ModuleID, Set[String]] => UpdateReport): UpdateReport =
-    {
-      val exclName = "exclude_classifiers"
-      val file = out / exclName
-      lock(out / (exclName + ".lock"), new Callable[UpdateReport] {
-        def call = {
-          val excludes = CacheIO.fromFile[Map[ModuleID, Set[String]]](excludeMap, Map.empty[ModuleID, Set[String]])(file)
-          val report = f(excludes)
-          val allExcludes = excludes ++ IvyActions.extractExcludes(report)
-          CacheIO.toFile(excludeMap)(allExcludes)(file)
-          IvyActions.addExcluded(report, classifiers, allExcludes)
-        }
-      })
+  val moduleIdJsonKeyFormat: sjsonnew.JsonKeyFormat[ModuleID] =
+    new sjsonnew.JsonKeyFormat[ModuleID] {
+      import LibraryManagementCodec._
+      import sjsonnew.support.scalajson.unsafe._
+      val moduleIdFormat: JsonFormat[ModuleID] = implicitly[JsonFormat[ModuleID]]
+      def write(key: ModuleID): String =
+        CompactPrinter(Converter.toJsonUnsafe(key)(moduleIdFormat))
+      def read(key: String): ModuleID =
+        Converter.fromJsonUnsafe[ModuleID](Parser.parseUnsafe(key))(moduleIdFormat)
+    }
+
+  def withExcludes(out: File, classifiers: Seq[String], lock: xsbti.GlobalLock)(
+      f: Map[ModuleID, Vector[ConfigRef]] => UpdateReport
+  ): UpdateReport = LibraryManagement.withExcludes(out, classifiers, lock)(f)
+
+  /**
+   * Substitute unmanaged jars for managed jars when the major.minor parts of
+   * the version are the same for:
+   *   1. The Scala version and the `scalaHome` (unmanaged) version are equal.
+   *   2. The Scala version and the `declared` (managed) version are equal.
+   *
+   * Equality is weak, that is, no version qualifier is checked.
+   */
+  private def unmanagedJarsTask(scalaVersion: String, unmanagedVersion: String, jars: Seq[File]) = {
+    (subVersion0: String) =>
+      val scalaV = partialVersion(scalaVersion)
+      val managedV = partialVersion(subVersion0)
+      val unmanagedV = partialVersion(unmanagedVersion)
+      (managedV, unmanagedV, scalaV) match {
+        case (Some(mv), Some(uv), _) if mv == uv => jars
+        case (Some(mv), _, Some(sv)) if mv == sv => jars
+        case _                                   => Nil
+      }
+  }
+
+  def updateTask: Initialize[Task[UpdateReport]] = updateTask0("updateFull", true, true)
+  def updateWithoutDetails(label: String): Initialize[Task[UpdateReport]] =
+    updateTask0(label, false, false)
+
+  /**
+   * cacheLabel - label to identify an update cache
+   * includeCallers - include the caller information
+   * includeDetails - include module reports for the evicted modules
+   */
+  private def updateTask0(
+      cacheLabel: String,
+      includeCallers: Boolean,
+      includeDetails: Boolean
+  ): Initialize[Task[UpdateReport]] = Def.task {
+    val s = streams.value
+    val cacheDirectory = crossTarget.value / cacheLabel / updateCacheName.value
+
+    val cacheStoreFactory: CacheStoreFactory = {
+      val factory =
+        state.value.get(Keys.cacheStoreFactoryFactory).getOrElse(InMemoryCacheStore.factory(0))
+      factory(cacheDirectory.toPath)
     }
 
-  def updateTask: Initialize[Task[UpdateReport]] = Def.task {
-    val depsUpdated = transitiveUpdate.value.exists(!_.stats.cached)
     val isRoot = executionRoots.value contains resolvedScoped.value
-    val forceUpdate = forceUpdatePeriod.value
-    val s = streams.value
-    val fullUpdateOutput = s.cacheDirectory / "out"
-    val forceUpdateByTime = forceUpdate match {
-      case None => false
-      case Some(period) =>
-        val elapsedDuration = new FiniteDuration(System.currentTimeMillis() - fullUpdateOutput.lastModified(), TimeUnit.MILLISECONDS)
-        fullUpdateOutput.exists() && elapsedDuration > period
-    }
-    val scalaProvider = appConfiguration.value.provider.scalaProvider
-
-    // Only substitute unmanaged jars for managed jars when the major.minor parts of the versions the same for:
-    //   the resolved Scala version and the scalaHome version: compatible (weakly- no qualifier checked)
-    //   the resolved Scala version and the declared scalaVersion: assume the user intended scalaHome to override anything with scalaVersion
-    def subUnmanaged(subVersion: String, jars: Seq[File]) = (sv: String) =>
-      (partialVersion(sv), partialVersion(subVersion), partialVersion(scalaVersion.value)) match {
-        case (Some(res), Some(sh), _) if res == sh     => jars
-        case (Some(res), _, Some(decl)) if res == decl => jars
-        case _                                         => Nil
+    val shouldForce = isRoot || {
+      forceUpdatePeriod.value match {
+        case None => false
+        case Some(period) =>
+          val fullUpdateOutput = cacheDirectory / "out"
+          val now = System.currentTimeMillis
+          val diff = now - IO.getModifiedTimeOrZero(fullUpdateOutput)
+          val elapsedDuration = new FiniteDuration(diff, TimeUnit.MILLISECONDS)
+          fullUpdateOutput.exists() && elapsedDuration > period
       }
-    val subScalaJars: String => Seq[File] = Defaults.unmanagedScalaInstanceOnly.value match {
-      case Some(si) => subUnmanaged(si.version, si.allJars)
-      case None     => sv => if (scalaProvider.version == sv) scalaProvider.jars else Nil
     }
-    val transform: UpdateReport => UpdateReport = r => substituteScalaFiles(scalaOrganization.value, r)(subScalaJars)
-    val uwConfig = (unresolvedWarningConfiguration in update).value
-    val show = Reference.display(thisProjectRef.value)
-    val st = state.value
-    val logicalClock = LogicalClock(st.hashCode)
-    val depDir = dependencyCacheDirectory.value
-    val uc0 = updateConfiguration.value
-    val ms = publishMavenStyle.value
-    val cw = compatibilityWarningOptions.value
-    // Normally, log would capture log messages at all levels.
-    // Ivy logs are treated specially using sbt.UpdateConfiguration.logging.
-    // This code bumps up the sbt.UpdateConfiguration.logging to Full when logLevel is Debug.
-    import UpdateLogging.{ Full, DownloadOnly, Default }
-    val uc = (logLevel in update).?.value orElse st.get(logLevel.key) match {
-      case Some(Level.Debug) if uc0.logging == Default => uc0.copy(logging = Full)
-      case Some(x) if uc0.logging == Default => uc0.copy(logging = DownloadOnly)
-      case _ => uc0
+
+    val providedScalaJars: String => Seq[File] = {
+      val scalaProvider = appConfiguration.value.provider.scalaProvider
+      Defaults.unmanagedScalaInstanceOnly.value match {
+        case Some(instance) =>
+          unmanagedJarsTask(scalaVersion.value, instance.version, instance.allJars)
+        case None =>
+          (subVersion: String) =>
+            if (scalaProvider.version == subVersion) scalaProvider.jars else Nil
+      }
     }
-    val ewo =
-      if (executionRoots.value exists { _.key == evicted.key }) EvictionWarningOptions.empty
-      else (evictionWarningOptions in update).value
-    cachedUpdate(s.cacheDirectory / updateCacheName.value, show, ivyModule.value, uc, transform,
-      skip = (skip in update).value, force = isRoot || forceUpdateByTime, depsUpdated = depsUpdated,
-      uwConfig = uwConfig, logicalClock = logicalClock, depDir = Some(depDir),
-      ewo = ewo, mavenStyle = ms, compatWarning = cw, log = s.log)
+
+    val state0 = state.value
+    val updateConf = {
+      // Log captures log messages at all levels, except ivy logs.
+      // Use full level when debug is enabled so that ivy logs are shown.
+      import UpdateLogging.{ Default, DownloadOnly, Full }
+      val conf = updateConfiguration.value
+      val maybeUpdateLevel = (update / logLevel).?.value
+      val conf1 = maybeUpdateLevel.orElse(state0.get(logLevel.key)) match {
+        case Some(Level.Debug) if conf.logging == Default => conf.withLogging(logging = Full)
+        case Some(_) if conf.logging == Default           => conf.withLogging(logging = DownloadOnly)
+        case _                                            => conf
+      }
+
+      // logical clock is folded into UpdateConfiguration
+      conf1
+        .withLogicalClock(LogicalClock(state0.hashCode))
+        .withMetadataDirectory(dependencyCacheDirectory.value)
+    }
+
+    val extracted = Project.extract(state0)
+    val isPlugin = sbtPlugin.value
+    val thisRef = thisProjectRef.value
+    val label =
+      if (isPlugin) Reference.display(thisRef)
+      else Def.displayRelativeReference(extracted.currentRef, thisRef)
+
+    LibraryManagement.cachedUpdate(
+      // LM API
+      lm = dependencyResolution.value,
+      // Ivy-free ModuleDescriptor
+      module = ivyModule.value,
+      cacheStoreFactory = cacheStoreFactory,
+      label = label,
+      updateConf,
+      substituteScalaFiles(scalaOrganization.value, _)(providedScalaJars),
+      skip = (update / skip).value,
+      force = shouldForce,
+      depsUpdated = transitiveUpdate.value.exists(!_.stats.cached),
+      uwConfig = (update / unresolvedWarningConfiguration).value,
+      evictionLevel = evictionErrorLevel.value,
+      versionSchemeOverrides = libraryDependencySchemes.value,
+      assumedEvictionErrorLevel = assumedEvictionErrorLevel.value,
+      assumedVersionScheme = assumedVersionScheme.value,
+      assumedVersionSchemeJava = assumedVersionSchemeJava.value,
+      mavenStyle = publishMavenStyle.value,
+      compatWarning = compatibilityWarningOptions.value,
+      includeCallers = includeCallers,
+      includeDetails = includeDetails,
+      log = s.log
+    )
   }
-  @deprecated("Use cachedUpdate with the variant that takes unresolvedHandler instead.", "0.13.6")
-  def cachedUpdate(cacheFile: File, label: String, module: IvySbt#Module, config: UpdateConfiguration,
-    transform: UpdateReport => UpdateReport, skip: Boolean, force: Boolean, depsUpdated: Boolean, log: Logger): UpdateReport =
-    cachedUpdate(cacheFile, label, module, config, transform, skip, force, depsUpdated,
-      UnresolvedWarningConfiguration(), LogicalClock.unknown, None, EvictionWarningOptions.empty, true, CompatibilityWarningOptions.default, log)
-  private[sbt] def cachedUpdate(cacheFile: File, label: String, module: IvySbt#Module, config: UpdateConfiguration,
-    transform: UpdateReport => UpdateReport, skip: Boolean, force: Boolean, depsUpdated: Boolean,
-    uwConfig: UnresolvedWarningConfiguration, logicalClock: LogicalClock, depDir: Option[File],
-    ewo: EvictionWarningOptions, mavenStyle: Boolean, compatWarning: CompatibilityWarningOptions,
-    log: Logger): UpdateReport =
-    {
-      implicit val updateCache = updateIC
-      type In = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil
-      def work = (_: In) match {
-        case conf :+: settings :+: config :+: HNil =>
-          import ShowLines._
-          log.info("Updating " + label + "...")
-          val r = IvyActions.updateEither(module, config, uwConfig, logicalClock, depDir, log) match {
-            case Right(ur) => ur
-            case Left(uw) =>
-              uw.lines foreach { log.warn(_) }
-              throw uw.resolveException
-          }
-          log.info("Done updating.")
-          val result = transform(r)
-          val ew = EvictionWarning(module, ewo, result, log)
-          ew.lines foreach { log.warn(_) }
-          ew.infoAllTheThings foreach { log.info(_) }
-          CompatibilityWarning.run(compatWarning, module, mavenStyle, log)
-          result
-      }
-      def uptodate(inChanged: Boolean, out: UpdateReport): Boolean =
-        !force &&
-          !depsUpdated &&
-          !inChanged &&
-          out.allFiles.forall(f => fileUptodate(f, out.stamps)) &&
-          fileUptodate(out.cachedDescriptor, out.stamps)
 
-      val outCacheFile = cacheFile / "output"
-      def skipWork: In => UpdateReport =
-        Tracked.lastOutput[In, UpdateReport](outCacheFile) {
-          case (_, Some(out)) => out
-          case _              => sys.error("Skipping update requested, but update has not previously run successfully.")
-        }
-      def doWork: In => UpdateReport =
-        Tracked.inputChanged(cacheFile / "inputs") { (inChanged: Boolean, in: In) =>
-          val outCache = Tracked.lastOutput[In, UpdateReport](outCacheFile) {
-            case (_, Some(out)) if uptodate(inChanged, out) => out
-            case _ => work(in)
-          }
-          try {
-            outCache(in)
-          } catch {
-            case e: NullPointerException =>
-              val r = work(in)
-              log.warn("Update task has failed to cache the report due to null.")
-              log.warn("Report the following output to sbt:")
-              r.toString.lines foreach { log.warn(_) }
-              log.trace(e)
-              r
-            case e: OutOfMemoryError =>
-              val r = work(in)
-              log.warn("Update task has failed to cache the report due to OutOfMemoryError.")
-              log.trace(e)
-              r
-          }
-        }
-      val f = if (skip && !force) skipWork else doWork
-      f(module.owner.configuration :+: module.moduleSettings :+: config :+: HNil)
-    }
-  private[this] def fileUptodate(file: File, stamps: Map[File, Long]): Boolean =
-    stamps.get(file).forall(_ == file.lastModified)
-  private[sbt] def dependencyPositionsTask: Initialize[Task[Map[ModuleID, SourcePosition]]] = Def.task {
-    val projRef = thisProjectRef.value
-    val st = state.value
-    val s = streams.value
-    val cacheFile = s.cacheDirectory / updateCacheName.value
-    implicit val depSourcePosCache = moduleIDSeqIC
-    implicit val outFormat = modulePositionMapFormat
-    def modulePositions: Map[ModuleID, SourcePosition] =
-      try {
-        val extracted = (Project extract st)
-        val sk = (libraryDependencies in (GlobalScope in projRef)).scopedKey
-        val empty = extracted.structure.data set (sk.scope, sk.key, Nil)
-        val settings = extracted.structure.settings filter { s: Setting[_] =>
-          (s.key.key == libraryDependencies.key) &&
+  private[sbt] def dependencyPositionsTask: Initialize[Task[Map[ModuleID, SourcePosition]]] =
+    Def.task {
+      val projRef = thisProjectRef.value
+      val st = state.value
+      val s = streams.value
+      val cacheStoreFactory = s.cacheStoreFactory sub updateCacheName.value
+      import sbt.librarymanagement.LibraryManagementCodec._
+      def modulePositions: Map[ModuleID, SourcePosition] =
+        try {
+          val extracted = (Project extract st)
+          val sk = (projRef / Zero / Zero / libraryDependencies).scopedKey
+          val empty = extracted.structure.data set (sk.scope, sk.key, Nil)
+          val settings = extracted.structure.settings filter { s: Setting[_] =>
+            (s.key.key == libraryDependencies.key) &&
             (s.key.scope.project == Select(projRef))
+          }
+          Map(settings flatMap {
+            case s: Setting[Seq[ModuleID]] @unchecked =>
+              s.init.evaluate(empty) map { _ -> s.pos }
+          }: _*)
+        } catch {
+          case NonFatal(_) => Map()
         }
-        Map(settings flatMap {
-          case s: Setting[Seq[ModuleID]] @unchecked =>
-            s.init.evaluate(empty) map { _ -> s.pos }
-        }: _*)
-      } catch {
-        case NonFatal(e) => Map()
-      }
 
-    val outCacheFile = cacheFile / "output_dsp"
-    val f = Tracked.inputChanged(cacheFile / "input_dsp") { (inChanged: Boolean, in: Seq[ModuleID]) =>
-      val outCache = Tracked.lastOutput[Seq[ModuleID], Map[ModuleID, SourcePosition]](outCacheFile) {
-        case (_, Some(out)) if !inChanged => out
-        case _                            => modulePositions
+      val outCacheStore = cacheStoreFactory make "output_dsp"
+      val f = Tracked.inputChanged(cacheStoreFactory make "input_dsp") {
+        (inChanged: Boolean, in: Seq[ModuleID]) =>
+          implicit val NoPositionFormat: JsonFormat[NoPosition.type] = asSingleton(NoPosition)
+          implicit val LinePositionFormat: IsoLList.Aux[LinePosition, String :*: Int :*: LNil] =
+            LList.iso(
+              { l: LinePosition =>
+                ("path", l.path) :*: ("startLine", l.startLine) :*: LNil
+              }, { in: String :*: Int :*: LNil =>
+                LinePosition(in.head, in.tail.head)
+              }
+            )
+          implicit val LineRangeFormat: IsoLList.Aux[LineRange, Int :*: Int :*: LNil] = LList.iso(
+            { l: LineRange =>
+              ("start", l.start) :*: ("end", l.end) :*: LNil
+            }, { in: Int :*: Int :*: LNil =>
+              LineRange(in.head, in.tail.head)
+            }
+          )
+          implicit val RangePositionFormat
+              : IsoLList.Aux[RangePosition, String :*: LineRange :*: LNil] = LList.iso(
+            { r: RangePosition =>
+              ("path", r.path) :*: ("range", r.range) :*: LNil
+            }, { in: String :*: LineRange :*: LNil =>
+              RangePosition(in.head, in.tail.head)
+            }
+          )
+          implicit val SourcePositionFormat: JsonFormat[SourcePosition] =
+            unionFormat3[SourcePosition, NoPosition.type, LinePosition, RangePosition]
+
+          implicit val midJsonKeyFmt: sjsonnew.JsonKeyFormat[ModuleID] = moduleIdJsonKeyFormat
+          val outCache =
+            Tracked.lastOutput[Seq[ModuleID], Map[ModuleID, SourcePosition]](outCacheStore) {
+              case (_, Some(out)) if !inChanged => out
+              case _                            => modulePositions
+            }
+          outCache(in)
       }
-      outCache(in)
+      f(libraryDependencies.value)
     }
-    f(libraryDependencies.value)
-  }
 
   /*
-	// can't cache deliver/publish easily since files involved are hidden behind patterns.  publish will be difficult to verify target-side anyway
-	def cachedPublish(cacheFile: File)(g: (IvySbt#Module, PublishConfiguration) => Unit, module: IvySbt#Module, config: PublishConfiguration) => Unit =
-	{ case module :+: config :+: HNil =>
-	/*	implicit val publishCache = publishIC
-		val f = cached(cacheFile) { (conf: IvyConfiguration, settings: ModuleSettings, config: PublishConfiguration) =>*/
-		    g(module, config)
-		/*}
-		f(module.owner.configuration :+: module.moduleSettings :+: config :+: HNil)*/
-	}*/
+    // can't cache deliver/publish easily since files involved are hidden behind patterns.  publish will be difficult to verify target-side anyway
+    def cachedPublish(cacheFile: File)(g: (IvySbt#Module, PublishConfiguration) => Unit, module: IvySbt#Module, config: PublishConfiguration) => Unit =
+    { case module :+: config :+: HNil =>
+    /*	implicit val publishCache = publishIC
+      val f = cached(cacheFile) { (conf: IvyConfiguration, settings: ModuleSettings, config: PublishConfiguration) =>*/
+          g(module, config)
+      /*}
+      f(module.owner.configuration :+: module.moduleSettings :+: config :+: HNil)*/
+    }*/
 
-  def defaultRepositoryFilter = (repo: MavenRepository) => !repo.root.startsWith("file:")
-  def getPublishTo(repo: Option[Resolver]): Resolver = repo getOrElse sys.error("Repository for publishing is not specified.")
+  def defaultRepositoryFilter: MavenRepository => Boolean = repo => !repo.root.startsWith("file:")
 
-  def deliverConfig(outputDirectory: File, status: String = "release", logging: UpdateLogging.Value = UpdateLogging.DownloadOnly) =
-    new DeliverConfiguration(deliverPattern(outputDirectory), status, None, logging)
-  @deprecated("Previous semantics allowed overwriting cached files, which was unsafe. Please specify overwrite parameter.", "0.13.2")
-  def publishConfig(artifacts: Map[Artifact, File], ivyFile: Option[File], checksums: Seq[String], resolverName: String, logging: UpdateLogging.Value): PublishConfiguration =
-    publishConfig(artifacts, ivyFile, checksums, resolverName, logging, overwrite = true)
-  def publishConfig(artifacts: Map[Artifact, File], ivyFile: Option[File], checksums: Seq[String], resolverName: String = "local", logging: UpdateLogging.Value = UpdateLogging.DownloadOnly, overwrite: Boolean = false) =
-    new PublishConfiguration(ivyFile, resolverName, artifacts, checksums, logging, overwrite)
+  def getPublishTo(repo: Option[Resolver]): Resolver =
+    repo getOrElse sys.error("Repository for publishing is not specified.")
 
-  def deliverPattern(outputPath: File): String = (outputPath / "[artifact]-[revision](-[classifier]).[ext]").absolutePath
+  def publishConfig(
+      publishMavenStyle: Boolean,
+      deliverIvyPattern: String,
+      status: String,
+      configurations: Vector[ConfigRef],
+      artifacts: Vector[(Artifact, File)],
+      checksums: Vector[String],
+      resolverName: String = "local",
+      logging: UpdateLogging = UpdateLogging.DownloadOnly,
+      overwrite: Boolean = false
+  ) =
+    PublishConfiguration(
+      publishMavenStyle,
+      deliverIvyPattern,
+      status,
+      configurations,
+      resolverName,
+      artifacts,
+      checksums,
+      logging,
+      overwrite
+    )
+
+  def makeIvyXmlConfig(
+      publishMavenStyle: Boolean,
+      deliverIvyPattern: String,
+      status: String,
+      configurations: Vector[ConfigRef],
+      checksums: Vector[String],
+      logging: sbt.librarymanagement.UpdateLogging = UpdateLogging.DownloadOnly,
+      overwrite: Boolean = false,
+      optResolverName: Option[String] = None
+  ) =
+    PublishConfiguration(
+      publishMavenStyle,
+      Some(deliverIvyPattern),
+      Some(status),
+      Some(configurations),
+      optResolverName,
+      Vector.empty,
+      checksums,
+      Some(logging),
+      overwrite
+    )
+
+  def deliverPattern(outputPath: File): String =
+    (outputPath / "[artifact]-[revision](-[classifier]).[ext]").absolutePath
+
+  private[sbt] def isScala2Scala3Sandwich(sbv1: String, sbv2: String): Boolean = {
+    def compare(a: String, b: String): Boolean =
+      a == "2.13" && (b.startsWith("0.") || b.startsWith("3"))
+    compare(sbv1, sbv2) || compare(sbv2, sbv1)
+  }
 
   def projectDependenciesTask: Initialize[Task[Seq[ModuleID]]] =
-    (thisProjectRef, settingsData, buildDependencies) map { (ref, data, deps) =>
+    Def.task {
+      val sbv = scalaBinaryVersion.value
+      val ref = thisProjectRef.value
+      val data = settingsData.value
+      val deps = buildDependencies.value
       deps.classpath(ref) flatMap { dep =>
-        (projectID in dep.project) get data map {
-          _.copy(configurations = dep.configuration, explicitArtifacts = Nil)
+        for {
+          depProjId <- (dep.project / projectID).get(data)
+          depSBV <- (dep.project / scalaBinaryVersion).get(data)
+          depCross <- (dep.project / crossVersion).get(data)
+        } yield {
+          depCross match {
+            case b: CrossVersion.Binary if isScala2Scala3Sandwich(sbv, depSBV) =>
+              depProjId
+                .withCrossVersion(CrossVersion.constant(b.prefix + depSBV))
+                .withConfigurations(dep.configuration)
+                .withExplicitArtifacts(Vector.empty)
+            case _ =>
+              depProjId.withConfigurations(dep.configuration).withExplicitArtifacts(Vector.empty)
+          }
         }
       }
     }
 
-  def depMap: Initialize[Task[Map[ModuleRevisionId, ModuleDescriptor]]] =
-    (thisProjectRef, settingsData, buildDependencies, streams) flatMap { (root, data, deps, s) =>
-      depMap(deps classpathTransitiveRefs root, data, s.log)
+  private[sbt] def depMap: Initialize[Task[Map[ModuleRevisionId, ModuleDescriptor]]] =
+    Def.taskDyn {
+      depMap(
+        buildDependencies.value classpathTransitiveRefs thisProjectRef.value,
+        settingsData.value,
+        streams.value.log
+      )
     }
 
-  def depMap(projects: Seq[ProjectRef], data: Settings[Scope], log: Logger): Task[Map[ModuleRevisionId, ModuleDescriptor]] =
-    projects.flatMap(ivyModule in _ get data).join.map { mod =>
-      mod map { _.dependencyMapping(log) } toMap;
+  @nowarn
+  private[sbt] def depMap(
+      projects: Seq[ProjectRef],
+      data: Settings[Scope],
+      log: Logger
+  ): Initialize[Task[Map[ModuleRevisionId, ModuleDescriptor]]] =
+    Def.value {
+      projects.flatMap(ivyModule in _ get data).join.map { mod =>
+        mod map { _.dependencyMapping(log) } toMap;
+      }
     }
 
   def projectResolverTask: Initialize[Task[Resolver]] =
     projectDescriptors map { m =>
-      new RawRepository(new ProjectResolver(ProjectResolver.InterProject, m))
+      val resolver = new ProjectResolver(ProjectResolver.InterProject, m)
+      new RawRepository(resolver, resolver.getName)
     }
 
-  def analyzed[T](data: T, analysis: CompileAnalysis) = Attributed.blank(data).put(Keys.analysis, analysis)
+  def analyzed[T](data: T, analysis: CompileAnalysis) = ClasspathImpl.analyzed[T](data, analysis)
   def makeProducts: Initialize[Task[Seq[File]]] = Def.task {
-    compile.value
-    copyResources.value
-    classDirectory.value :: Nil
+    val c = fileConverter.value
+    Def.unit(copyResources.value)
+    Def.unit(compile.value)
+
+    c.toPath(backendOutput.value).toFile :: Nil
   }
-  // This is a variant of exportProductsTask with tracking
-  private[sbt] def trackedExportedProducts(track: TrackLevel): Initialize[Task[Classpath]] = Def.task {
-    val art = (artifact in packageBin).value
-    val module = projectID.value
-    val config = configuration.value
-    for { (f, analysis) <- trackedProductsImplTask(track).value } yield APIMappings.store(analyzed(f, analysis), apiURL.value).put(artifact.key, art).put(moduleID.key, module).put(configuration.key, config)
-  }
-  private[this] def trackedProductsImplTask(track: TrackLevel): Initialize[Task[Seq[(File, CompileAnalysis)]]] =
-    Def.taskDyn {
-      val useJars = exportJars.value
-      val jar = (artifactPath in packageBin).value
-      val dirs = productDirectories.value
-      def containsClassFile(fs: List[File]): Boolean =
-        (fs exists { dir =>
-          (dir ** DirectoryFilter).get exists { d =>
-            (d * "*.class").get.nonEmpty
-          }
-        })
-      TrackLevel.intersection(track, exportToInternal.value) match {
-        case TrackLevel.TrackAlways if (useJars) =>
-          Def.task {
-            Seq((packageBin.value, compile.value))
-          }
-        case TrackLevel.TrackAlways =>
-          Def.task {
-            products.value map { (_, compile.value) }
-          }
-        case TrackLevel.TrackIfMissing if (useJars && !jar.exists) =>
-          Def.task {
-            Seq((packageBin.value, compile.value))
-          }
-        case TrackLevel.TrackIfMissing if (!useJars && !containsClassFile(dirs.toList)) =>
-          Def.task {
-            products.value map { (_, compile.value) }
-          }
-        case _ =>
-          Def.task {
-            val analysisOpt = previousCompile.value.analysis
-            (if (useJars) Seq(jar)
-            else dirs) map { x =>
-              (x, if (analysisOpt.isDefined) analysisOpt.get
-              else Analysis.empty(true))
-            }
-          }
+
+  private[sbt] def makePickleProducts: Initialize[Task[Seq[VirtualFile]]] = Def.task {
+    // This is a conditional task.
+    if (earlyOutputPing.await.value) {
+      // TODO: copyResources.value
+      earlyOutput.value :: Nil
+    } else {
+      val c = fileConverter.value
+      products.value map { x: File =>
+        c.toVirtualFile(x.toPath)
       }
     }
-
-  @deprecated("This is no longer used.", "0.13.10")
-  def exportProductsTask: Initialize[Task[Classpath]] = Def.task {
-    val art = (artifact in packageBin).value
-    val module = projectID.value
-    val config = configuration.value
-    for (f <- productsImplTask.value) yield APIMappings.store(analyzed(f, compile.value), apiURL.value).put(artifact.key, art).put(moduleID.key, module).put(configuration.key, config)
   }
 
-  private[this] def productsImplTask: Initialize[Task[Seq[File]]] = Def.task {
-    if (exportJars.value) Seq(packageBin.value) else products.value
-  }
-
-  def constructBuildDependencies: Initialize[BuildDependencies] = loadedBuild(lb => BuildUtil.dependencies(lb.units))
+  def constructBuildDependencies: Initialize[BuildDependencies] =
+    loadedBuild(lb => BuildUtil.dependencies(lb.units))
 
+  @deprecated("not used", "1.4.0")
   def internalDependencies: Initialize[Task[Classpath]] =
-    (thisProjectRef, classpathConfiguration, configuration, settingsData, buildDependencies, trackInternalDependencies) flatMap internalDependencies0
-  def unmanagedDependencies: Initialize[Task[Classpath]] =
-    (thisProjectRef, configuration, settingsData, buildDependencies) flatMap unmanagedDependencies0
-  def mkIvyConfiguration: Initialize[Task[IvyConfiguration]] =
-    (fullResolvers, ivyPaths, otherResolvers, moduleConfigurations, offline, checksums in update, appConfiguration,
-      target, updateOptions, streams) map { (rs, paths, other, moduleConfs, off, check, app, t, uo, s) =>
-        warnResolversConflict(rs ++: other, s.log)
-        val resCacheDir = t / "resolution-cache"
+    ClasspathImpl.internalDependencyClasspathTask
 
-        new InlineIvyConfiguration(paths, rs, other, moduleConfs, off, Option(lock(app)), check, Some(resCacheDir), uo, s.log)
-      }
-
-  import java.util.LinkedHashSet
-  import collection.JavaConverters._
-  def interSort(projectRef: ProjectRef, conf: Configuration, data: Settings[Scope], deps: BuildDependencies): Seq[(ProjectRef, String)] =
-    {
-      val visited = (new LinkedHashSet[(ProjectRef, String)]).asScala
-      def visit(p: ProjectRef, c: Configuration): Unit = {
-        val applicableConfigs = allConfigs(c)
-        for (ac <- applicableConfigs) // add all configurations in this project
-          visited add (p -> ac.name)
-        val masterConfs = names(getConfigurations(projectRef, data))
-
-        for (ResolvedClasspathDependency(dep, confMapping) <- deps.classpath(p)) {
-          val configurations = getConfigurations(dep, data)
-          val mapping = mapped(confMapping, masterConfs, names(configurations), "compile", "*->compile")
-          // map master configuration 'c' and all extended configurations to the appropriate dependency configuration
-          for (ac <- applicableConfigs; depConfName <- mapping(ac.name)) {
-            for (depConf <- confOpt(configurations, depConfName))
-              if (!visited((dep, depConfName)))
-                visit(dep, depConf)
-          }
-        }
-      }
-      visit(projectRef, conf)
-      visited.toSeq
-    }
-  def unmanagedDependencies0(projectRef: ProjectRef, conf: Configuration, data: Settings[Scope], deps: BuildDependencies): Task[Classpath] =
-    interDependencies(projectRef, deps, conf, conf, data, TrackLevel.TrackAlways, true, unmanagedLibs0)
-  @deprecated("This is no longer public.", "0.13.10")
-  def internalDependencies0(projectRef: ProjectRef, conf: Configuration, self: Configuration, data: Settings[Scope], deps: BuildDependencies): Task[Classpath] =
-    interDependencies(projectRef, deps, conf, self, data, false, productsTask)
-  private[sbt] def internalDependencies0(projectRef: ProjectRef, conf: Configuration, self: Configuration, data: Settings[Scope], deps: BuildDependencies, track: TrackLevel): Task[Classpath] =
-    interDependencies(projectRef, deps, conf, self, data, track, false, productsTask0)
-  @deprecated("This is no longer public.", "0.13.10")
-  def interDependencies(projectRef: ProjectRef, deps: BuildDependencies, conf: Configuration, self: Configuration, data: Settings[Scope], includeSelf: Boolean,
-    f: (ProjectRef, String, Settings[Scope]) => Task[Classpath]): Task[Classpath] =
-    interDependencies(projectRef, deps, conf, self, data, TrackLevel.TrackAlways, includeSelf,
-      { (pr: ProjectRef, s: String, sc: Settings[Scope], tl: TrackLevel) => f(pr, s, sc) })
-  private[sbt] def interDependencies(projectRef: ProjectRef, deps: BuildDependencies, conf: Configuration, self: Configuration, data: Settings[Scope],
-    track: TrackLevel, includeSelf: Boolean, f: (ProjectRef, String, Settings[Scope], TrackLevel) => Task[Classpath]): Task[Classpath] =
-    {
-      val visited = interSort(projectRef, conf, data, deps)
-      val tasks = (new LinkedHashSet[Task[Classpath]]).asScala
-      for ((dep, c) <- visited)
-        if (includeSelf || (dep != projectRef) || (conf.name != c && self.name != c))
-          tasks += f(dep, c, data, track)
-
-      (tasks.toSeq.join).map(_.flatten.distinct)
+  def internalDependencyJarsTask: Initialize[Task[Classpath]] =
+    ClasspathImpl.internalDependencyJarsTask
+  def unmanagedDependencies: Initialize[Task[Classpath]] = ClasspathImpl.unmanagedDependenciesTask
+  def mkIvyConfiguration: Initialize[Task[InlineIvyConfiguration]] =
+    Def.task {
+      val (rs, other) = (fullResolvers.value.toVector, otherResolvers.value.toVector)
+      val s = streams.value
+      warnResolversConflict(rs ++: other, s.log)
+      errorInsecureProtocol(rs ++: other, s.log)
+      InlineIvyConfiguration()
+        .withPaths(ivyPaths.value)
+        .withResolvers(rs)
+        .withOtherResolvers(other)
+        .withModuleConfigurations(moduleConfigurations.value.toVector)
+        .withLock(lock(appConfiguration.value))
+        .withChecksums((update / checksums).value.toVector)
+        .withResolutionCacheDir(crossTarget.value / "resolution-cache")
+        .withUpdateOptions(updateOptions.value)
+        .withLog(s.log)
     }
 
-  def mapped(confString: Option[String], masterConfs: Seq[String], depConfs: Seq[String], default: String, defaultMapping: String): String => Seq[String] =
-    {
-      lazy val defaultMap = parseMapping(defaultMapping, masterConfs, depConfs, _ :: Nil)
-      parseMapping(confString getOrElse default, masterConfs, depConfs, defaultMap)
-    }
-  def parseMapping(confString: String, masterConfs: Seq[String], depConfs: Seq[String], default: String => Seq[String]): String => Seq[String] =
-    union(confString.split(";") map parseSingleMapping(masterConfs, depConfs, default))
-  def parseSingleMapping(masterConfs: Seq[String], depConfs: Seq[String], default: String => Seq[String])(confString: String): String => Seq[String] =
-    {
-      val ms: Seq[(String, Seq[String])] =
-        trim(confString.split("->", 2)) match {
-          case x :: Nil => for (a <- parseList(x, masterConfs)) yield (a, default(a))
-          case x :: y :: Nil =>
-            val target = parseList(y, depConfs); for (a <- parseList(x, masterConfs)) yield (a, target)
-          case _ => sys.error("Invalid configuration '" + confString + "'") // shouldn't get here
-        }
-      val m = ms.toMap
-      s => m.getOrElse(s, Nil)
+  def interSort(
+      projectRef: ProjectRef,
+      conf: Configuration,
+      data: Settings[Scope],
+      deps: BuildDependencies
+  ): Seq[(ProjectRef, String)] = ClasspathImpl.interSort(projectRef, conf, data, deps)
+
+  def interSortConfigurations(
+      projectRef: ProjectRef,
+      conf: Configuration,
+      data: Settings[Scope],
+      deps: BuildDependencies
+  ): Seq[(ProjectRef, ConfigRef)] =
+    interSort(projectRef, conf, data, deps).map {
+      case (projectRef, configName) => (projectRef, ConfigRef(configName))
     }
 
+  def mapped(
+      confString: Option[String],
+      masterConfs: Seq[String],
+      depConfs: Seq[String],
+      default: String,
+      defaultMapping: String
+  ): String => Seq[String] =
+    ClasspathImpl.mapped(confString, masterConfs, depConfs, default, defaultMapping)
+
+  def parseMapping(
+      confString: String,
+      masterConfs: Seq[String],
+      depConfs: Seq[String],
+      default: String => Seq[String]
+  ): String => Seq[String] =
+    ClasspathImpl.parseMapping(confString, masterConfs, depConfs, default)
+
+  def parseSingleMapping(
+      masterConfs: Seq[String],
+      depConfs: Seq[String],
+      default: String => Seq[String]
+  )(confString: String): String => Seq[String] =
+    ClasspathImpl.parseSingleMapping(masterConfs, depConfs, default)(confString)
+
   def union[A, B](maps: Seq[A => Seq[B]]): A => Seq[B] =
-    a => (Seq[B]() /: maps) { _ ++ _(a) } distinct;
+    ClasspathImpl.union[A, B](maps)
 
-  def parseList(s: String, allConfs: Seq[String]): Seq[String] = (trim(s split ",") flatMap replaceWildcard(allConfs)).distinct
-  def replaceWildcard(allConfs: Seq[String])(conf: String): Seq[String] = conf match {
-    case ""  => Nil
-    case "*" => allConfs
-    case _   => conf :: Nil
-  }
+  def parseList(s: String, allConfs: Seq[String]): Seq[String] =
+    ClasspathImpl.parseList(s, allConfs)
+
+  def replaceWildcard(allConfs: Seq[String])(conf: String): Seq[String] =
+    ClasspathImpl.replaceWildcard(allConfs)(conf)
 
-  private def trim(a: Array[String]): List[String] = a.toList.map(_.trim)
   def missingConfiguration(in: String, conf: String) =
     sys.error("Configuration '" + conf + "' not defined in '" + in + "'")
-  def allConfigs(conf: Configuration): Seq[Configuration] =
-    Dag.topologicalSort(conf)(_.extendsConfigs)
+  def allConfigs(conf: Configuration): Seq[Configuration] = ClasspathImpl.allConfigs(conf)
 
   def getConfigurations(p: ResolvedReference, data: Settings[Scope]): Seq[Configuration] =
-    ivyConfigurations in p get data getOrElse Nil
+    ClasspathImpl.getConfigurations(p, data)
   def confOpt(configurations: Seq[Configuration], conf: String): Option[Configuration] =
-    configurations.find(_.name == conf)
-  def productsTask(dep: ResolvedReference, conf: String, data: Settings[Scope]): Task[Classpath] =
-    getClasspath(exportedProducts, dep, conf, data)
-  def productsTask0(dep: ResolvedReference, conf: String, data: Settings[Scope], track: TrackLevel): Task[Classpath] =
-    track match {
-      case TrackLevel.NoTracking     => getClasspath(exportedProductsNoTracking, dep, conf, data)
-      case TrackLevel.TrackIfMissing => getClasspath(exportedProductsIfMissing, dep, conf, data)
-      case TrackLevel.TrackAlways    => getClasspath(exportedProducts, dep, conf, data)
-    }
-  private[sbt] def unmanagedLibs0(dep: ResolvedReference, conf: String, data: Settings[Scope], track: TrackLevel): Task[Classpath] =
-    unmanagedLibs(dep, conf, data)
+    ClasspathImpl.confOpt(configurations, conf)
+
   def unmanagedLibs(dep: ResolvedReference, conf: String, data: Settings[Scope]): Task[Classpath] =
-    getClasspath(unmanagedJars, dep, conf, data)
-  def getClasspath(key: TaskKey[Classpath], dep: ResolvedReference, conf: String, data: Settings[Scope]): Task[Classpath] =
-    (key in (dep, ConfigKey(conf))) get data getOrElse constant(Nil)
+    ClasspathImpl.unmanagedLibs(dep, conf, data)
+
+  def getClasspath(
+      key: TaskKey[Classpath],
+      dep: ResolvedReference,
+      conf: String,
+      data: Settings[Scope]
+  ): Task[Classpath] =
+    ClasspathImpl.getClasspath(key, dep, conf, data)
+
   def defaultConfigurationTask(p: ResolvedReference, data: Settings[Scope]): Configuration =
-    flatten(defaultConfiguration in p get data) getOrElse Configurations.Default
+    flatten((p / defaultConfiguration) get data) getOrElse Configurations.Default
+
   def flatten[T](o: Option[Option[T]]): Option[T] = o flatMap idFun
 
-  val sbtIvySnapshots = Resolver.sbtIvyRepo("snapshots")
-
-  lazy val typesafeReleases = Resolver.typesafeIvyRepo("releases")
-
-  @deprecated("Use `typesafeReleases` instead", "0.12.0")
-  lazy val typesafeResolver = typesafeReleases
-  @deprecated("Use `Resolver.typesafeIvyRepo` instead", "0.12.0")
-  def typesafeRepo(status: String) = Resolver.typesafeIvyRepo(status)
-
-  lazy val sbtPluginReleases = Resolver.sbtPluginRepo("releases")
+  val sbtIvySnapshots: URLRepository = Resolver.sbtIvyRepo("snapshots")
+  val typesafeReleases: URLRepository =
+    Resolver.typesafeIvyRepo("releases").withName("typesafe-alt-ivy-releases")
+  val sbtPluginReleases: URLRepository = Resolver.sbtPluginRepo("releases")
+  val sbtMavenSnapshots: MavenRepository =
+    MavenRepository("sbt-maven-snapshot", Resolver.SbtRepositoryRoot + "/" + "maven-snapshots/")
 
   def modifyForPlugin(plugin: Boolean, dep: ModuleID): ModuleID =
-    if (plugin) dep.copy(configurations = Some(Provided.name)) else dep
+    if (plugin) dep.withConfigurations(Some(Provided.name)) else dep
 
-  @deprecated("Explicitly specify the organization using the other variant.", "0.13.0")
-  def autoLibraryDependency(auto: Boolean, plugin: Boolean, version: String): Seq[ModuleID] =
+  def autoLibraryDependency(
+      auto: Boolean,
+      plugin: Boolean,
+      org: String,
+      version: String
+  ): Seq[ModuleID] =
     if (auto)
-      modifyForPlugin(plugin, ScalaArtifacts.libraryDependency(version)) :: Nil
+      modifyForPlugin(plugin, ScalaArtifacts.libraryDependency(org, version)) :: Nil
     else
       Nil
-  def autoLibraryDependency(auto: Boolean, plugin: Boolean, org: String, version: String): Seq[ModuleID] =
-    if (auto)
-      modifyForPlugin(plugin, ModuleID(org, ScalaArtifacts.LibraryID, version)) :: Nil
-    else
-      Nil
-  def addUnmanagedLibrary: Seq[Setting[_]] = Seq(
-    unmanagedJars in Compile ++= unmanagedScalaLibrary.value
-  )
-  def unmanagedScalaLibrary: Initialize[Task[Seq[File]]] =
-    Def.taskDyn {
-      if (autoScalaLibrary.value && scalaHome.value.isDefined)
-        Def.task { scalaInstance.value.libraryJar :: Nil }
-      else
-        Def.task { Nil }
-    }
+
+  def addUnmanagedLibrary: Seq[Setting[_]] =
+    Seq((Compile / unmanagedJars) ++= unmanagedScalaLibrary.value)
+
+  def unmanagedScalaLibrary: Initialize[Task[Seq[File]]] = Def.taskDyn {
+    if (autoScalaLibrary.value && scalaHome.value.isDefined)
+      Def.task { scalaInstance.value.libraryJars } else
+      Def.task { Nil }
+  }
 
   import DependencyFilter._
   def managedJars(config: Configuration, jarTypes: Set[String], up: UpdateReport): Classpath =
-    up.filter(configurationFilter(config.name) && artifactFilter(`type` = jarTypes)).toSeq.map {
-      case (conf, module, art, file) =>
-        Attributed(file)(AttributeMap.empty.put(artifact.key, art).put(moduleID.key, module).put(configuration.key, config))
-    } distinct;
+    up.filter(configurationFilter(config.name) && artifactFilter(`type` = jarTypes))
+      .toSeq
+      .map {
+        case (_, module, art, file) =>
+          Attributed(file)(
+            AttributeMap.empty
+              .put(artifact.key, art)
+              .put(moduleID.key, module)
+              .put(configuration.key, config)
+          )
+      }
+      .distinct
 
-  def findUnmanagedJars(config: Configuration, base: File, filter: FileFilter, excl: FileFilter): Classpath =
+  def findUnmanagedJars(
+      config: Configuration,
+      base: File,
+      filter: FileFilter,
+      excl: FileFilter
+  ): Classpath = {
     (base * (filter -- excl) +++ (base / config.name).descendantsExcept(filter, excl)).classpath
-
-  @deprecated("Specify the classpath that includes internal dependencies", "0.13.0")
-  def autoPlugins(report: UpdateReport): Seq[String] = autoPlugins(report, Nil)
+  }
+  @deprecated(
+    "The method only works for Scala 2, use the overloaded version to support both Scala 2 and Scala 3",
+    "1.1.5"
+  )
   def autoPlugins(report: UpdateReport, internalPluginClasspath: Seq[File]): Seq[String] =
-    {
-      val pluginClasspath = report.matching(configurationFilter(CompilerPlugin.name)) ++ internalPluginClasspath
-      val plugins = sbt.internal.inc.classpath.ClasspathUtilities.compilerPlugins(pluginClasspath)
-      plugins.map("-Xplugin:" + _.getAbsolutePath).toSeq
-    }
+    autoPlugins(report, internalPluginClasspath, isDotty = false)
+
+  def autoPlugins(
+      report: UpdateReport,
+      internalPluginClasspath: Seq[File],
+      isDotty: Boolean
+  ): Seq[String] = {
+    import sbt.internal.inc.classpath.ClasspathUtil.compilerPlugins
+    val pluginClasspath = report.matching(configurationFilter(CompilerPlugin.name)) ++ internalPluginClasspath
+    val plugins = compilerPlugins(pluginClasspath.map(_.toPath), isDotty)
+    plugins.map("-Xplugin:" + _.toAbsolutePath.toString).toSeq
+  }
 
   private[this] lazy val internalCompilerPluginClasspath: Initialize[Task[Classpath]] =
-    (thisProjectRef, settingsData, buildDependencies) flatMap { (ref, data, deps) =>
-      internalDependencies0(ref, CompilerPlugin, CompilerPlugin, data, deps, TrackLevel.TrackAlways)
+    Def.taskDyn {
+      val ref = thisProjectRef.value
+      val data = settingsData.value
+      val deps = buildDependencies.value
+      ClasspathImpl.internalDependenciesImplTask(
+        ref,
+        CompilerPlugin,
+        CompilerPlugin,
+        data,
+        deps,
+        TrackLevel.TrackAlways,
+        streams.value.log
+      )
     }
 
   lazy val compilerPluginConfig = Seq(
     scalacOptions := {
       val options = scalacOptions.value
-      val newPlugins = autoPlugins(update.value, internalCompilerPluginClasspath.value.files)
+      val newPlugins = autoPlugins(
+        update.value,
+        internalCompilerPluginClasspath.value.files,
+        ScalaInstance.isDotty(scalaVersion.value)
+      )
       val existing = options.toSet
       if (autoCompilerPlugins.value) options ++ newPlugins.filterNot(existing) else options
     }
   )
 
-  @deprecated("Doesn't properly handle non-standard Scala organizations.", "0.13.0")
-  def substituteScalaFiles(scalaInstance: ScalaInstance, report: UpdateReport): UpdateReport =
-    substituteScalaFiles(scalaInstance, ScalaArtifacts.Organization, report)
-
-  @deprecated("Directly provide the jar files per Scala version.", "0.13.0")
-  def substituteScalaFiles(scalaInstance: ScalaInstance, scalaOrg: String, report: UpdateReport): UpdateReport =
-    substituteScalaFiles(scalaOrg, report)(const(scalaInstance.allJars))
-
-  def substituteScalaFiles(scalaOrg: String, report: UpdateReport)(scalaJars: String => Seq[File]): UpdateReport =
+  def substituteScalaFiles(scalaOrg: String, report: UpdateReport)(
+      scalaJars: String => Seq[File]
+  ): UpdateReport =
     report.substitute { (configuration, module, arts) =>
       if (module.organization == scalaOrg) {
         val jarName = module.name + ".jar"
-        val replaceWith = scalaJars(module.revision).filter(_.getName == jarName).map(f => (Artifact(f.getName.stripSuffix(".jar")), f))
+        val replaceWith = scalaJars(module.revision).toVector
+          .filter(_.getName == jarName)
+          .map(f => (Artifact(f.getName.stripSuffix(".jar")), f))
         if (replaceWith.isEmpty) arts else replaceWith
       } else
         arts
@@ -1926,66 +4083,126 @@ object Classpaths {
 
   // try/catch for supporting earlier launchers
   def bootIvyHome(app: xsbti.AppConfiguration): Option[File] =
-    try { Option(app.provider.scalaProvider.launcher.ivyHome) }
-    catch { case _: NoSuchMethodError => None }
+    try {
+      Option(app.provider.scalaProvider.launcher.ivyHome)
+    } catch {
+      case _: NoSuchMethodError => None
+    }
 
-  def bootChecksums(app: xsbti.AppConfiguration): Seq[String] =
-    try { app.provider.scalaProvider.launcher.checksums.toSeq }
-    catch { case _: NoSuchMethodError => IvySbt.DefaultChecksums }
+  def bootChecksums(app: xsbti.AppConfiguration): Vector[String] =
+    try {
+      app.provider.scalaProvider.launcher.checksums.toVector
+    } catch {
+      case _: NoSuchMethodError => IvySbt.DefaultChecksums
+    }
 
   def isOverrideRepositories(app: xsbti.AppConfiguration): Boolean =
     try app.provider.scalaProvider.launcher.isOverrideRepositories
     catch { case _: NoSuchMethodError => false }
 
   /** Loads the `appRepositories` configured for this launcher, if supported. */
-  def appRepositories(app: xsbti.AppConfiguration): Option[Seq[Resolver]] =
-    try { Some(app.provider.scalaProvider.launcher.appRepositories.toSeq map bootRepository) }
-    catch { case _: NoSuchMethodError => None }
+  def appRepositories(app: xsbti.AppConfiguration): Option[Vector[Resolver]] =
+    try {
+      Some(app.provider.scalaProvider.launcher.appRepositories.toVector map bootRepository)
+    } catch {
+      case _: NoSuchMethodError => None
+    }
 
-  def bootRepositories(app: xsbti.AppConfiguration): Option[Seq[Resolver]] =
-    try { Some(app.provider.scalaProvider.launcher.ivyRepositories.toSeq map bootRepository) }
-    catch { case _: NoSuchMethodError => None }
+  def bootRepositories(app: xsbti.AppConfiguration): Option[Vector[Resolver]] =
+    try {
+      Some(app.provider.scalaProvider.launcher.ivyRepositories.toVector map bootRepository)
+    } catch {
+      case _: NoSuchMethodError => None
+    }
+
+  // This is a place holder in case someone doesn't want to use Coursier
+  private[sbt] def dummyCoursierDirectory(app: xsbti.AppConfiguration): File = {
+    val base = app.baseDirectory.getCanonicalFile
+    base / "target" / "coursier-temp"
+  }
 
   private[this] def mavenCompatible(ivyRepo: xsbti.IvyRepository): Boolean =
-    try { ivyRepo.mavenCompatible }
-    catch { case _: NoSuchMethodError => false }
+    try {
+      ivyRepo.mavenCompatible
+    } catch { case _: NoSuchMethodError => false }
 
   private[this] def skipConsistencyCheck(ivyRepo: xsbti.IvyRepository): Boolean =
-    try { ivyRepo.skipConsistencyCheck }
-    catch { case _: NoSuchMethodError => false }
+    try {
+      ivyRepo.skipConsistencyCheck
+    } catch { case _: NoSuchMethodError => false }
 
   private[this] def descriptorOptional(ivyRepo: xsbti.IvyRepository): Boolean =
-    try { ivyRepo.descriptorOptional }
-    catch { case _: NoSuchMethodError => false }
+    try {
+      ivyRepo.descriptorOptional
+    } catch { case _: NoSuchMethodError => false }
 
-  private[this] def bootRepository(repo: xsbti.Repository): Resolver =
-    {
-      import xsbti.Predefined
-      repo match {
-        case m: xsbti.MavenRepository => MavenRepository(m.id, m.url.toString)
-        case i: xsbti.IvyRepository =>
-          val patterns = Patterns(i.ivyPattern :: Nil, i.artifactPattern :: Nil, mavenCompatible(i), descriptorOptional(i), skipConsistencyCheck(i))
-          i.url.getProtocol match {
-            case "file" =>
-              // This hackery is to deal suitably with UNC paths on Windows. Once we can assume Java7, Paths should save us from this.
-              val file = try { new File(i.url.toURI) } catch { case e: java.net.URISyntaxException => new File(i.url.getPath) }
-              Resolver.file(i.id, file)(patterns)
-            case _ => Resolver.url(i.id, i.url)(patterns)
-          }
-        case p: xsbti.PredefinedRepository => p.id match {
+  // for forward-compatibility with launcher.jar prior to 1.3.11
+  private[this] def mavenRepoAllowInsecureProtocol(mavenRepo: xsbti.MavenRepository): Boolean =
+    try {
+      mavenRepo.allowInsecureProtocol
+    } catch { case _: NoSuchMethodError => false }
+
+  // for forward-compatibility with launcher.jar prior to 1.3.11
+  private[this] def allowInsecureProtocol(ivyRepo: xsbti.IvyRepository): Boolean =
+    try {
+      ivyRepo.allowInsecureProtocol
+    } catch { case _: NoSuchMethodError => false }
+
+  @nowarn
+  private[this] def bootRepository(repo: xsbti.Repository): Resolver = {
+    import xsbti.Predefined
+    repo match {
+      case m: xsbti.MavenRepository =>
+        MavenRepository(m.id, m.url.toString)
+          .withAllowInsecureProtocol(mavenRepoAllowInsecureProtocol(m))
+      case i: xsbti.IvyRepository =>
+        val patterns = Patterns(
+          Vector(i.ivyPattern),
+          Vector(i.artifactPattern),
+          mavenCompatible(i),
+          descriptorOptional(i),
+          skipConsistencyCheck(i)
+        )
+        i.url.getProtocol match {
+          case "file" =>
+            // This hackery is to deal suitably with UNC paths on Windows. Once we can assume Java7, Paths should save us from this.
+            val file = IO.toFile(i.url)
+            Resolver.file(i.id, file)(patterns)
+          case _ =>
+            Resolver
+              .url(i.id, i.url)(patterns)
+              .withAllowInsecureProtocol(allowInsecureProtocol(i))
+        }
+      case p: xsbti.PredefinedRepository =>
+        p.id match {
           case Predefined.Local                => Resolver.defaultLocal
           case Predefined.MavenLocal           => Resolver.mavenLocal
-          case Predefined.MavenCentral         => DefaultMavenRepository
+          case Predefined.MavenCentral         => Resolver.DefaultMavenRepository
           case Predefined.ScalaToolsReleases   => Resolver.ScalaToolsReleases
           case Predefined.ScalaToolsSnapshots  => Resolver.ScalaToolsSnapshots
           case Predefined.SonatypeOSSReleases  => Resolver.sonatypeRepo("releases")
           case Predefined.SonatypeOSSSnapshots => Resolver.sonatypeRepo("snapshots")
-          case unknown                         => sys.error("Unknown predefined resolver '" + unknown + "'.  This resolver may only be supported in newer sbt versions.")
+          case unknown =>
+            sys.error(
+              "Unknown predefined resolver '" + unknown + "'.  This resolver may only be supported in newer sbt versions."
+            )
         }
-      }
     }
+  }
+
+  def shellPromptFromState: State => String = shellPromptFromState(ITerminal.console.isColorEnabled)
+  def shellPromptFromState(isColorEnabled: Boolean): State => String = { s: State =>
+    val extracted = Project.extract(s)
+    (extracted.currentRef / name).get(extracted.structure.data) match {
+      case Some(name) =>
+        s"sbt:$name" + Def.withColor(s"> ", Option(scala.Console.CYAN), isColorEnabled)
+      case _ => "> "
+    }
+  }
 }
 
+private[sbt] object Build0 extends BuildExtra
+
 trait BuildExtra extends BuildCommon with DefExtra {
   import Defaults._
 
@@ -1996,25 +4213,43 @@ trait BuildExtra extends BuildCommon with DefExtra {
    * Names are restricted to be either alphanumeric or completely symbolic.
    * As an exception, '-' and '_' are allowed within an alphanumeric name.
    */
-  def addCommandAlias(name: String, value: String): Seq[Setting[State => State]] =
-    {
-      val add = (s: State) => BasicCommands.addAlias(s, name, value)
-      val remove = (s: State) => BasicCommands.removeAlias(s, name)
-      def compose(setting: SettingKey[State => State], f: State => State) = setting in Global ~= (_ compose f)
-      Seq(compose(onLoad, add), compose(onUnload, remove))
-    }
+  def addCommandAlias(name: String, value: String): Seq[Setting[State => State]] = {
+    val add = (s: State) => BasicCommands.addAlias(s, name, value)
+    val remove = (s: State) => BasicCommands.removeAlias(s, name)
+    def compose(setting: SettingKey[State => State], f: State => State) =
+      (GlobalScope / setting) ~= (_ compose f)
+    Seq(compose(onLoad, add), compose(onUnload, remove))
+  }
+
+  /**
+   * Adds Maven resolver plugin.
+   */
+  def addDependencyTreePlugin: Setting[Seq[ModuleID]] =
+    libraryDependencies += sbtPluginExtra(
+      ModuleID("org.scala-sbt", "sbt-dependency-tree", sbtVersion.value),
+      sbtBinaryVersion.value,
+      scalaBinaryVersion.value
+    )
 
   /**
    * Adds Maven resolver plugin.
    */
   def addMavenResolverPlugin: Setting[Seq[ModuleID]] =
-    libraryDependencies += sbtPluginExtra(ModuleID("org.scala-sbt", "sbt-maven-resolver", sbtVersion.value), sbtBinaryVersion.value, scalaBinaryVersion.value)
+    libraryDependencies += sbtPluginExtra(
+      ModuleID("org.scala-sbt", "sbt-maven-resolver", sbtVersion.value),
+      sbtBinaryVersion.value,
+      scalaBinaryVersion.value
+    )
 
   /**
    * Adds `dependency` as an sbt plugin for the specific sbt version `sbtVersion` and Scala version `scalaVersion`.
    * Typically, use the default values for these versions instead of specifying them explicitly.
    */
-  def addSbtPlugin(dependency: ModuleID, sbtVersion: String, scalaVersion: String): Setting[Seq[ModuleID]] =
+  def addSbtPlugin(
+      dependency: ModuleID,
+      sbtVersion: String,
+      scalaVersion: String
+  ): Setting[Seq[ModuleID]] =
     libraryDependencies += sbtPluginExtra(dependency, sbtVersion, scalaVersion)
 
   /**
@@ -2023,7 +4258,7 @@ trait BuildExtra extends BuildCommon with DefExtra {
    */
   def addSbtPlugin(dependency: ModuleID, sbtVersion: String): Setting[Seq[ModuleID]] =
     libraryDependencies += {
-      val scalaV = (scalaBinaryVersion in update).value
+      val scalaV = (update / scalaBinaryVersion).value
       sbtPluginExtra(dependency, sbtVersion, scalaV)
     }
 
@@ -2033,94 +4268,197 @@ trait BuildExtra extends BuildCommon with DefExtra {
    */
   def addSbtPlugin(dependency: ModuleID): Setting[Seq[ModuleID]] =
     libraryDependencies += {
-      val sbtV = (sbtBinaryVersion in update).value
-      val scalaV = (scalaBinaryVersion in update).value
+      val sbtV = (pluginCrossBuild / sbtBinaryVersion).value
+      val scalaV = (update / scalaBinaryVersion).value
       sbtPluginExtra(dependency, sbtV, scalaV)
     }
 
   /** Transforms `dependency` to be in the auto-compiler plugin configuration. */
   def compilerPlugin(dependency: ModuleID): ModuleID =
-    dependency.copy(configurations = Some("plugin->default(compile)"))
+    dependency.withConfigurations(Some("plugin->default(compile)"))
 
   /** Adds `dependency` to `libraryDependencies` in the auto-compiler plugin configuration. */
   def addCompilerPlugin(dependency: ModuleID): Setting[Seq[ModuleID]] =
     libraryDependencies += compilerPlugin(dependency)
 
   /** Constructs a setting that declares a new artifact `a` that is generated by `taskDef`. */
-  def addArtifact(a: Artifact, taskDef: TaskKey[File]): SettingsDefinition =
-    {
-      val pkgd = packagedArtifacts := packagedArtifacts.value updated (a, taskDef.value)
-      Seq(artifacts += a, pkgd)
-    }
+  def addArtifact(a: Artifact, taskDef: TaskKey[File]): SettingsDefinition = {
+    val pkgd = packagedArtifacts := packagedArtifacts.value updated (a, taskDef.value)
+    Seq(artifacts += a, pkgd)
+  }
+
   /** Constructs a setting that declares a new artifact `artifact` that is generated by `taskDef`. */
-  def addArtifact(artifact: Initialize[Artifact], taskDef: Initialize[Task[File]]): SettingsDefinition =
-    {
-      val artLocal = SettingKey.local[Artifact]
-      val taskLocal = TaskKey.local[File]
-      val art = artifacts := artLocal.value +: artifacts.value
-      val pkgd = packagedArtifacts := packagedArtifacts.value updated (artLocal.value, taskLocal.value)
-      Seq(artLocal := artifact.value, taskLocal := taskDef.value, art, pkgd)
-    }
+  def addArtifact(
+      artifact: Initialize[Artifact],
+      taskDef: Initialize[Task[File]]
+  ): SettingsDefinition = {
+    val artLocal = SettingKey.local[Artifact]
+    val taskLocal = TaskKey.local[File]
+    val art = artifacts := artLocal.value +: artifacts.value
+    val pkgd = packagedArtifacts := packagedArtifacts.value updated (artLocal.value, taskLocal.value)
+    Seq(artLocal := artifact.value, taskLocal := taskDef.value, art, pkgd)
+  }
 
-  // because this was commonly used, this might need to be kept longer than usual
-  @deprecated("In build.sbt files, this call can be removed.  In other cases, this can usually be replaced by Seq.", "0.13.0")
-  def seq(settings: Setting[_]*): SettingsDefinition = new Def.SettingList(settings)
-
-  def externalIvySettings(file: Initialize[File] = inBase("ivysettings.xml"), addMultiResolver: Boolean = true): Setting[Task[IvyConfiguration]] =
+  def externalIvySettings(
+      file: Initialize[File] = inBase("ivysettings.xml"),
+      addMultiResolver: Boolean = true
+  ): Setting[Task[IvyConfiguration]] =
     externalIvySettingsURI(file(_.toURI), addMultiResolver)
-  def externalIvySettingsURL(url: URL, addMultiResolver: Boolean = true): Setting[Task[IvyConfiguration]] =
+
+  def externalIvySettingsURL(
+      url: URL,
+      addMultiResolver: Boolean = true
+  ): Setting[Task[IvyConfiguration]] =
     externalIvySettingsURI(Def.value(url.toURI), addMultiResolver)
-  def externalIvySettingsURI(uri: Initialize[URI], addMultiResolver: Boolean = true): Setting[Task[IvyConfiguration]] =
-    {
-      val other = (baseDirectory, appConfiguration, projectResolver, updateOptions, streams).identityMap
-      ivyConfiguration := ((uri zipWith other) {
-        case (u, otherTask) =>
-          otherTask map {
-            case (base, app, pr, uo, s) =>
-              val extraResolvers = if (addMultiResolver) pr :: Nil else Nil
-              new ExternalIvyConfiguration(base, u, Option(lock(app)), extraResolvers, uo, s.log)
-          }
-      }).value
-    }
-  private[this] def inBase(name: String): Initialize[File] = Def.setting { baseDirectory.value / name }
 
-  def externalIvyFile(file: Initialize[File] = inBase("ivy.xml"), iScala: Initialize[Option[IvyScala]] = ivyScala): Setting[Task[ModuleSettings]] =
-    moduleSettings := new IvyFileConfiguration(file.value, iScala.value, ivyValidate.value, managedScalaInstance.value)
-  def externalPom(file: Initialize[File] = inBase("pom.xml"), iScala: Initialize[Option[IvyScala]] = ivyScala): Setting[Task[ModuleSettings]] =
-    moduleSettings := new PomConfiguration(file.value, ivyScala.value, ivyValidate.value, managedScalaInstance.value)
-
-  def runInputTask(config: Configuration, mainClass: String, baseArguments: String*): Initialize[InputTask[Unit]] =
-    Def.inputTask {
-      import Def._
-      val r = (runner in (config, run)).value
-      val cp = (fullClasspath in config).value
-      val args = spaceDelimited().parsed
-      toError(r.run(mainClass, data(cp), baseArguments ++ args, streams.value.log))
+  def externalIvySettingsURI(
+      uri: Initialize[URI],
+      addMultiResolver: Boolean = true
+  ): Setting[Task[IvyConfiguration]] = {
+    val other = Def.task {
+      (
+        baseDirectory.value,
+        appConfiguration.value,
+        projectResolver.value,
+        updateOptions.value,
+        streams.value
+      )
     }
-  def runTask(config: Configuration, mainClass: String, arguments: String*): Initialize[Task[Unit]] =
-    (fullClasspath in config, runner in (config, run), streams) map { (cp, r, s) =>
-      toError(r.run(mainClass, data(cp), arguments, s.log))
-    }
-
-  def fullRunInputTask(scoped: InputKey[Unit], config: Configuration, mainClass: String, baseArguments: String*): Setting[InputTask[Unit]] =
-    scoped := (inputTask { result =>
-      (initScoped(scoped.scopedKey, runnerInit) zipWith (fullClasspath in config, streams, result).identityMap) { (rTask, t) =>
-        (t, rTask) map {
-          case ((cp, s, args), r) =>
-            toError(r.run(mainClass, data(cp), baseArguments ++ args, s.log))
-        }
-      }
-    }).evaluated
-  def fullRunTask(scoped: TaskKey[Unit], config: Configuration, mainClass: String, arguments: String*): Setting[Task[Unit]] =
-    scoped := ((initScoped(scoped.scopedKey, runnerInit) zipWith (fullClasspath in config, streams).identityMap) {
-      case (rTask, t) =>
-        (t, rTask) map {
-          case ((cp, s), r) =>
-            toError(r.run(mainClass, data(cp), arguments, s.log))
+    ivyConfiguration := ((uri zipWith other) {
+      case (u, otherTask) =>
+        otherTask map {
+          case (base, app, pr, uo, s) =>
+            val extraResolvers = if (addMultiResolver) Vector(pr) else Vector.empty
+            ExternalIvyConfiguration()
+              .withLock(lock(app))
+              .withBaseDirectory(base)
+              .withLog(s.log)
+              .withUpdateOptions(uo)
+              .withUri(u)
+              .withExtraResolvers(extraResolvers)
         }
     }).value
-  def initScoped[T](sk: ScopedKey[_], i: Initialize[T]): Initialize[T] = initScope(fillTaskAxis(sk.scope, sk.key), i)
-  def initScope[T](s: Scope, i: Initialize[T]): Initialize[T] = i mapReferenced Project.mapScope(Scope.replaceThis(s))
+  }
+
+  private[this] def inBase(name: String): Initialize[File] = Def.setting {
+    baseDirectory.value / name
+  }
+
+  @deprecated(
+    "externalIvyFile is not supported by Couriser, and will be removed in the future",
+    since = "1.5.0"
+  )
+  def externalIvyFile(
+      file: Initialize[File] = inBase("ivy.xml"),
+      iScala: Initialize[Option[ScalaModuleInfo]] = scalaModuleInfo
+  ): Setting[Task[ModuleSettings]] =
+    moduleSettings := IvyFileConfiguration(
+      ivyValidate.value,
+      iScala.value,
+      file.value,
+      managedScalaInstance.value
+    )
+
+  @deprecated(
+    "externalPom is not supported by Coursier, and will be removed in the future",
+    since = "1.5.0"
+  )
+  def externalPom(
+      file: Initialize[File] = inBase("pom.xml"),
+      iScala: Initialize[Option[ScalaModuleInfo]] = scalaModuleInfo,
+  ): Setting[Task[ModuleSettings]] =
+    moduleSettings := PomConfiguration(
+      ivyValidate.value,
+      iScala.value,
+      file.value,
+      managedScalaInstance.value,
+    )
+
+  def runInputTask(
+      config: Configuration,
+      mainClass: String,
+      baseArguments: String*
+  ): Initialize[InputTask[Unit]] =
+    Def.inputTask {
+      import Def._
+      val r = (config / run / runner).value
+      val cp = (config / fullClasspath).value
+      val args = spaceDelimited().parsed
+      r.run(mainClass, data(cp), baseArguments ++ args, streams.value.log).get
+    }
+
+  def runTask(
+      config: Configuration,
+      mainClass: String,
+      arguments: String*
+  ): Initialize[Task[Unit]] =
+    Def.task {
+      val cp = (config / fullClasspath).value
+      val r = (config / run / runner).value
+      val s = streams.value
+      r.run(mainClass, data(cp), arguments, s.log).get
+    }
+
+  // public API
+  /** Returns a vector of settings that create custom run input task. */
+  @nowarn
+  def fullRunInputTask(
+      scoped: InputKey[Unit],
+      config: Configuration,
+      mainClass: String,
+      baseArguments: String*
+  ): Vector[Setting[_]] = {
+    // TODO: Re-write to avoid InputTask.apply which is deprecated
+    // I tried "Def.spaceDelimited().parsed" (after importing Def.parserToInput)
+    // but it broke actions/run-task
+    // Maybe it needs to be defined inside a Def.inputTask?
+    @nowarn
+    def inputTask[T](f: TaskKey[Seq[String]] => Initialize[Task[T]]): Initialize[InputTask[T]] =
+      InputTask.apply(Def.value((s: State) => Def.spaceDelimited()))(f)
+
+    Vector(
+      scoped := inputTask { result =>
+        initScoped(
+          scoped.scopedKey,
+          ClassLoaders.runner mapReferenced Project.mapScope(s => s.in(config))
+        ).zipWith(Def.task { ((config / fullClasspath).value, streams.value, result.value) }) {
+          (rTask, t) =>
+            (t, rTask) map {
+              case ((cp, s, args), r) =>
+                r.run(mainClass, data(cp), baseArguments ++ args, s.log).get
+            }
+        }
+      }.evaluated
+    ) ++ inTask(scoped)((config / forkOptions) := forkOptionsTask.value)
+  }
+
+  // public API
+  /** Returns a vector of settings that create custom run task. */
+  @nowarn
+  def fullRunTask(
+      scoped: TaskKey[Unit],
+      config: Configuration,
+      mainClass: String,
+      arguments: String*
+  ): Vector[Setting[_]] =
+    Vector(
+      scoped := initScoped(
+        scoped.scopedKey,
+        ClassLoaders.runner mapReferenced Project.mapScope(s => s.in(config))
+      ).zipWith(Def.task { ((config / fullClasspath).value, streams.value) }) {
+          case (rTask, t) =>
+            (t, rTask) map {
+              case ((cp, s), r) =>
+                r.run(mainClass, data(cp), arguments, s.log).get
+            }
+        }
+        .value
+    ) ++ inTask(scoped)((config / forkOptions) := forkOptionsTask.value)
+
+  def initScoped[T](sk: ScopedKey[_], i: Initialize[T]): Initialize[T] =
+    initScope(fillTaskAxis(sk.scope, sk.key), i)
+  def initScope[T](s: Scope, i: Initialize[T]): Initialize[T] =
+    i mapReferenced Project.mapScope(Scope.replaceThis(s))
 
   /**
    * Disables post-compilation hook for determining tests for tab-completion (such as for 'test-only').
@@ -2129,22 +4467,23 @@ trait BuildExtra extends BuildCommon with DefExtra {
   def noTestCompletion(config: Configuration = Test): Setting[_] =
     inConfig(config)(Seq(definedTests := detectTests.value)).head
 
-  def filterKeys(ss: Seq[Setting[_]], transitive: Boolean = false)(f: ScopedKey[_] => Boolean): Seq[Setting[_]] =
+  def filterKeys(ss: Seq[Setting[_]], transitive: Boolean = false)(
+      f: ScopedKey[_] => Boolean
+  ): Seq[Setting[_]] =
     ss filter (s => f(s.key) && (!transitive || s.dependencies.forall(f)))
 }
+
 trait DefExtra {
   private[this] val ts: TaskSequential = new TaskSequential {}
-  implicit def toTaskSequential(d: Def.type): TaskSequential = ts
+  implicit def toTaskSequential(@deprecated("unused", "") d: Def.type): TaskSequential = ts
 }
+
 trait BuildCommon {
-  @deprecated("Use Def.inputTask with the `Def.spaceDelimited()` parser.", "0.13.0")
-  def inputTask[T](f: TaskKey[Seq[String]] => Initialize[Task[T]]): Initialize[InputTask[T]] =
-    InputTask.apply(Def.value((s: State) => Def.spaceDelimited()))(f)
 
   /**
    * Allows a String to be used where a `NameFilter` is expected.
    * Asterisks (`*`) in the string are interpreted as wildcards.
-   * All other characters must match exactly.  See [[sbt.GlobFilter]].
+   * All other characters must match exactly.  See GlobFilter.
    */
   implicit def globFilter(expression: String): NameFilter = GlobFilter(expression)
 
@@ -2152,52 +4491,73 @@ trait BuildCommon {
   implicit def richFiles(s: Seq[File]): RichFiles = new RichFiles(s)
   implicit def richPathFinder(s: PathFinder): RichPathFinder = new RichPathFinder(s)
   final class RichPathFinder private[sbt] (s: PathFinder) {
+
     /** Converts the `PathFinder` to a `Classpath`, which is an alias for `Seq[Attributed[File]]`. */
     def classpath: Classpath = Attributed blankSeq s.get
   }
   final class RichAttributed private[sbt] (s: Seq[Attributed[File]]) {
+
     /** Extracts the plain `Seq[File]` from a Classpath (which is a `Seq[Attributed[File]]`).*/
     def files: Seq[File] = Attributed.data(s)
   }
   final class RichFiles private[sbt] (s: Seq[File]) {
+
     /** Converts the `Seq[File]` to a Classpath, which is an alias for `Seq[Attributed[File]]`. */
     def classpath: Classpath = Attributed blankSeq s
   }
-  def toError(o: Option[String]): Unit = o foreach error
 
-  def overrideConfigs(cs: Configuration*)(configurations: Seq[Configuration]): Seq[Configuration] =
-    {
-      val existingName = configurations.map(_.name).toSet
-      val newByName = cs.map(c => (c.name, c)).toMap
-      val overridden = configurations map { conf => newByName.getOrElse(conf.name, conf) }
-      val newConfigs = cs filter { c => !existingName(c.name) }
-      overridden ++ newConfigs
+  def overrideConfigs(cs: Configuration*)(
+      configurations: Seq[Configuration]
+  ): Seq[Configuration] = {
+    val existingName = configurations.map(_.name).toSet
+    val newByName = cs.map(c => (c.name, c)).toMap
+    val overridden = configurations map { conf =>
+      newByName.getOrElse(conf.name, conf)
     }
+    val newConfigs = cs filter { c =>
+      !existingName(c.name)
+    }
+    overridden ++ newConfigs
+  }
 
-  // these are intended for use in input tasks for creating parsers
+  // these are intended for use in in put tasks for creating parsers
   def getFromContext[T](task: TaskKey[T], context: ScopedKey[_], s: State): Option[T] =
     SessionVar.get(SessionVar.resolveContext(task.scopedKey, context.scope, s), s)
 
-  def loadFromContext[T](task: TaskKey[T], context: ScopedKey[_], s: State)(implicit f: sbinary.Format[T]): Option[T] =
+  def loadFromContext[T](task: TaskKey[T], context: ScopedKey[_], s: State)(
+      implicit f: JsonFormat[T]
+  ): Option[T] =
     SessionVar.load(SessionVar.resolveContext(task.scopedKey, context.scope, s), s)
 
   // intended for use in constructing InputTasks
-  def loadForParser[P, T](task: TaskKey[T])(f: (State, Option[T]) => Parser[P])(implicit format: sbinary.Format[T]): Initialize[State => Parser[P]] =
+  def loadForParser[P, T](task: TaskKey[T])(
+      f: (State, Option[T]) => Parser[P]
+  )(implicit format: JsonFormat[T]): Initialize[State => Parser[P]] =
     loadForParserI(task)(Def value f)(format)
-  def loadForParserI[P, T](task: TaskKey[T])(init: Initialize[(State, Option[T]) => Parser[P]])(implicit format: sbinary.Format[T]): Initialize[State => Parser[P]] =
-    (resolvedScoped, init)((ctx, f) => (s: State) => f(s, loadFromContext(task, ctx, s)(format)))
+  def loadForParserI[P, T](task: TaskKey[T])(
+      init: Initialize[(State, Option[T]) => Parser[P]]
+  )(implicit format: JsonFormat[T]): Initialize[State => Parser[P]] =
+    Def.setting { (s: State) =>
+      init.value(s, loadFromContext(task, resolvedScoped.value, s)(format))
+    }
 
-  def getForParser[P, T](task: TaskKey[T])(init: (State, Option[T]) => Parser[P]): Initialize[State => Parser[P]] =
+  def getForParser[P, T](
+      task: TaskKey[T]
+  )(init: (State, Option[T]) => Parser[P]): Initialize[State => Parser[P]] =
     getForParserI(task)(Def value init)
-  def getForParserI[P, T](task: TaskKey[T])(init: Initialize[(State, Option[T]) => Parser[P]]): Initialize[State => Parser[P]] =
-    (resolvedScoped, init)((ctx, f) => (s: State) => f(s, getFromContext(task, ctx, s)))
+  def getForParserI[P, T](
+      task: TaskKey[T]
+  )(init: Initialize[(State, Option[T]) => Parser[P]]): Initialize[State => Parser[P]] =
+    Def.setting { (s: State) =>
+      init.value(s, getFromContext(task, resolvedScoped.value, s))
+    }
 
   // these are for use for constructing Tasks
-  def loadPrevious[T](task: TaskKey[T])(implicit f: sbinary.Format[T]): Initialize[Task[Option[T]]] =
-    (state, resolvedScoped) map { (s, ctx) => loadFromContext(task, ctx, s)(f) }
-
+  def loadPrevious[T](task: TaskKey[T])(implicit f: JsonFormat[T]): Initialize[Task[Option[T]]] =
+    Def.task { loadFromContext(task, resolvedScoped.value, state.value)(f) }
   def getPrevious[T](task: TaskKey[T]): Initialize[Task[Option[T]]] =
-    (state, resolvedScoped) map { (s, ctx) => getFromContext(task, ctx, s) }
+    Def.task { getFromContext(task, resolvedScoped.value, state.value) }
 
-  private[sbt] def derive[T](s: Setting[T]): Setting[T] = Def.derive(s, allowDynamic = true, trigger = _ != streams.key, default = true)
+  private[sbt] def derive[T](s: Setting[T]): Setting[T] =
+    Def.derive(s, allowDynamic = true, trigger = _ != streams.key, default = true)
 }
diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala
index c82df9e14..6a793ba10 100644
--- a/main/src/main/scala/sbt/EvaluateTask.scala
+++ b/main/src/main/scala/sbt/EvaluateTask.scala
@@ -1,26 +1,31 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import sbt.internal.{ Load, BuildStructure, TaskTimings, TaskName, GCUtil }
-import sbt.internal.util.{ Attributed, ErrorHandling, HList, RMap, Show, Signals, Types }
-import sbt.util.Logger
-import sbt.librarymanagement.{ Resolver, UpdateReport }
-
-import scala.concurrent.duration.Duration
 import java.io.File
-import Def.{ dummyState, ScopedKey, Setting }
-import Keys.{ Streams, TaskStreams, dummyRoots, executionRoots, pluginData, streams,
-  streamsManager, transformState }
-import Project.richInitializeTask
-import Scope.GlobalScope
-import scala.Console.RED
-import std.Transform.DummyTaskMap
-import TaskName._
+import java.util.concurrent.atomic.AtomicReference
 
-@deprecated("Use EvaluateTaskConfig instead.", "0.13.5")
-final case class EvaluateConfig(cancelable: Boolean, restrictions: Seq[Tags.Rule], checkCycles: Boolean = false, progress: ExecuteProgress[Task] = EvaluateTask.defaultProgress)
+import sbt.Def.{ ScopedKey, Setting, dummyState }
+import sbt.Keys.{ TaskProgress => _, name => _, _ }
+import sbt.Project.richInitializeTask
+import sbt.Scope.Global
+import sbt.SlashSyntax0._
+import sbt.internal.Aggregation.KeyValue
+import sbt.internal.TaskName._
+import sbt.internal._
+import sbt.internal.util.{ Terminal => ITerminal, _ }
+import sbt.librarymanagement.{ Resolver, UpdateReport }
+import sbt.std.Transform.DummyTaskMap
+import sbt.util.{ Logger, Show }
+
+import scala.annotation.nowarn
+import scala.Console.RED
+import scala.concurrent.duration.Duration
 
 /**
  * An API that allows you to cancel executing tasks upon some signal.
@@ -29,11 +34,13 @@ final case class EvaluateConfig(cancelable: Boolean, restrictions: Seq[Tags.Rule
  *  invoking `cancelAndShutdown()` allows you to cancel the current task execution.
  */
 trait RunningTaskEngine {
+
   /** Attempts to kill and shutdown the running task engine.*/
   def cancelAndShutdown(): Unit
 }
+
 /**
- * A startegy for being able to cancle tasks.
+ * A strategy for being able to cancel tasks.
  *
  * Implementations of this trait determine what will trigger `cancel()` for
  * the task engine, providing in the `start` method.
@@ -41,8 +48,10 @@ trait RunningTaskEngine {
  * All methods on this API are expected to be called from the same thread.
  */
 trait TaskCancellationStrategy {
+
   /** The state used by this task. */
   type State
+
   /**
    * Called when task evaluation starts.
    *
@@ -50,10 +59,13 @@ trait TaskCancellationStrategy {
    * @return Whatever state you need to cleanup in your finish method.
    */
   def onTaskEngineStart(canceller: RunningTaskEngine): State
+
   /** Called when task evaluation completes, either in success or failure. */
   def onTaskEngineFinish(state: State): Unit
 }
+
 object TaskCancellationStrategy {
+
   /** An empty handler that does not cancel tasks. */
   object Null extends TaskCancellationStrategy {
     type State = Unit
@@ -61,14 +73,16 @@ object TaskCancellationStrategy {
     def onTaskEngineFinish(state: Unit): Unit = ()
     override def toString: String = "Null"
   }
+
   /** Cancel handler which registers for SIGINT and cancels tasks when it is received. */
   object Signal extends TaskCancellationStrategy {
     type State = Signals.Registration
-    def onTaskEngineStart(canceller: RunningTaskEngine): Signals.Registration = {
+
+    def onTaskEngineStart(canceller: RunningTaskEngine): Signals.Registration =
       Signals.register(() => canceller.cancelAndShutdown())
-    }
-    def onTaskEngineFinish(registration: Signals.Registration): Unit =
-      registration.remove()
+
+    def onTaskEngineFinish(registration: Signals.Registration): Unit = registration.remove()
+
     override def toString: String = "Signal"
   }
 }
@@ -85,175 +99,263 @@ sealed trait EvaluateTaskConfig {
   def checkCycles: Boolean
   def progressReporter: ExecuteProgress[Task]
   def cancelStrategy: TaskCancellationStrategy
-  /**
-   * If true, we force a finalizer/gc run (or two) after task execution completes when needed.
-   */
+
+  /** If true, we force a finalizer/gc run (or two) after task execution completes when needed. */
   def forceGarbageCollection: Boolean
 
-  /**
-   * Interval to force GC.
-   */
+  /** Interval to force GC. */
   def minForcegcInterval: Duration
 }
+
 object EvaluateTaskConfig {
-  @deprecated("Use the alternative that specifies minForcegcInterval", "0.13.9")
-  def apply(restrictions: Seq[Tags.Rule],
-    checkCycles: Boolean,
-    progressReporter: ExecuteProgress[Task],
-    cancelStrategy: TaskCancellationStrategy,
-    forceGarbageCollection: Boolean): EvaluateTaskConfig =
-    apply(restrictions, checkCycles, progressReporter, cancelStrategy, forceGarbageCollection,
-      GCUtil.defaultMinForcegcInterval)
 
   /** Raw constructor for EvaluateTaskConfig. */
-  def apply(restrictions: Seq[Tags.Rule],
-    checkCycles: Boolean,
-    progressReporter: ExecuteProgress[Task],
-    cancelStrategy: TaskCancellationStrategy,
-    forceGarbageCollection: Boolean,
-    minForcegcInterval: Duration): EvaluateTaskConfig = {
-    val r = restrictions
-    val check = checkCycles
-    val cs = cancelStrategy
-    val pr = progressReporter
-    val fgc = forceGarbageCollection
-    val mfi = minForcegcInterval
-    object SimpleEvaluateTaskConfig extends EvaluateTaskConfig {
-      def restrictions = r
-      def checkCycles = check
-      def progressReporter = pr
-      def cancelStrategy = cs
-      def forceGarbageCollection = fgc
-      def minForcegcInterval = mfi
-    }
-    SimpleEvaluateTaskConfig
-  }
+  def apply(
+      restrictions: Seq[Tags.Rule],
+      checkCycles: Boolean,
+      progressReporter: ExecuteProgress[Task],
+      cancelStrategy: TaskCancellationStrategy,
+      forceGarbageCollection: Boolean,
+      minForcegcInterval: Duration
+  ): EvaluateTaskConfig =
+    DefaultEvaluateTaskConfig(
+      restrictions,
+      checkCycles,
+      progressReporter,
+      cancelStrategy,
+      forceGarbageCollection,
+      minForcegcInterval
+    )
+
+  private[this] case class DefaultEvaluateTaskConfig(
+      restrictions: Seq[Tags.Rule],
+      checkCycles: Boolean,
+      progressReporter: ExecuteProgress[Task],
+      cancelStrategy: TaskCancellationStrategy,
+      forceGarbageCollection: Boolean,
+      minForcegcInterval: Duration
+  ) extends EvaluateTaskConfig
 }
 
-final case class PluginData(dependencyClasspath: Seq[Attributed[File]], definitionClasspath: Seq[Attributed[File]], resolvers: Option[Seq[Resolver]], report: Option[UpdateReport], scalacOptions: Seq[String]) {
+final case class PluginData(
+    dependencyClasspath: Seq[Attributed[File]],
+    definitionClasspath: Seq[Attributed[File]],
+    resolvers: Option[Vector[Resolver]],
+    report: Option[UpdateReport],
+    scalacOptions: Seq[String]
+) {
   val classpath: Seq[Attributed[File]] = definitionClasspath ++ dependencyClasspath
 }
 
-object EvaluateTask {
-  import std.Transform
-  import Keys.state
+object PluginData {
+  private[sbt] def apply(dependencyClasspath: Def.Classpath): PluginData =
+    PluginData(dependencyClasspath, Nil, None, None, Nil)
+}
 
-  private[sbt] def defaultProgress: ExecuteProgress[Task] =
-    if (java.lang.Boolean.getBoolean("sbt.task.timings")) new TaskTimings else ExecuteProgress.empty[Task]
+object EvaluateTask {
+  import Keys.state
+  import std.Transform
+
+  @nowarn
+  lazy private val sharedProgress = new TaskTimings(reportOnShutdown = true)
+  def taskTimingProgress: Option[ExecuteProgress[Task]] =
+    if (SysProp.taskTimingsOnShutdown) Some(sharedProgress)
+    else None
+
+  lazy private val sharedTraceEvent = new TaskTraceEvent()
+  def taskTraceEvent: Option[ExecuteProgress[Task]] =
+    if (SysProp.traces) {
+      Some(sharedTraceEvent)
+    } else None
+
+  // sbt-pgp calls this
+  @deprecated("No longer used", "1.3.0")
+  private[sbt] def defaultProgress(): ExecuteProgress[Task] = ExecuteProgress.empty[Task]
 
   val SystemProcessors = Runtime.getRuntime.availableProcessors
 
-  @deprecated("Use extractedTaskConfig.", "0.13.0")
-  def defaultConfig(state: State): EvaluateConfig =
-    {
-      val extracted = Project.extract(state)
-      extractedConfig(extracted, extracted.structure, state)
-    }
-
-  @deprecated("Use extractedTaskConfig.", "0.13.0")
-  def defaultConfig(extracted: Extracted, structure: BuildStructure) =
-    EvaluateConfig(false, restrictions(extracted, structure), progress = defaultProgress)
-
-  @deprecated("Use other extractedTaskConfig", "0.13.2")
-  def extractedConfig(extracted: Extracted, structure: BuildStructure): EvaluateConfig =
-    {
-      val workers = restrictions(extracted, structure)
-      val canCancel = cancelable(extracted, structure)
-      EvaluateConfig(cancelable = canCancel, restrictions = workers, progress = defaultProgress)
-    }
-  @deprecated("Use other extractedTaskConfig", "0.13.5")
-  def extractedConfig(extracted: Extracted, structure: BuildStructure, state: State): EvaluateConfig =
-    {
-      val workers = restrictions(extracted, structure)
-      val canCancel = cancelable(extracted, structure)
-      val progress = executeProgress(extracted, structure, state)
-      EvaluateConfig(cancelable = canCancel, restrictions = workers, progress = progress)
-    }
-  def extractedTaskConfig(extracted: Extracted, structure: BuildStructure, state: State): EvaluateTaskConfig =
-    {
-      val rs = restrictions(extracted, structure)
-      val canceller = cancelStrategy(extracted, structure, state)
-      val progress = executeProgress(extracted, structure, state)
-      val fgc = forcegc(extracted, structure)
-      val mfi = minForcegcInterval(extracted, structure)
-      EvaluateTaskConfig(rs, false, progress, canceller, fgc, mfi)
-    }
+  def extractedTaskConfig(
+      extracted: Extracted,
+      structure: BuildStructure,
+      state: State
+  ): EvaluateTaskConfig = {
+    val rs = restrictions(extracted, structure)
+    val canceller = cancelStrategy(extracted, structure, state)
+    val progress = executeProgress(extracted, structure, state)
+    val fgc = forcegc(extracted, structure)
+    val mfi = minForcegcInterval(extracted, structure)
+    EvaluateTaskConfig(rs, false, progress, canceller, fgc, mfi)
+  }
 
   def defaultRestrictions(maxWorkers: Int) = Tags.limitAll(maxWorkers) :: Nil
   def defaultRestrictions(extracted: Extracted, structure: BuildStructure): Seq[Tags.Rule] =
     Tags.limitAll(maxWorkers(extracted, structure)) :: Nil
 
-  def restrictions(state: State): Seq[Tags.Rule] =
-    {
-      val extracted = Project.extract(state)
-      restrictions(extracted, extracted.structure)
-    }
+  def restrictions(state: State): Seq[Tags.Rule] = {
+    val extracted = Project.extract(state)
+    restrictions(extracted, extracted.structure)
+  }
+
   def restrictions(extracted: Extracted, structure: BuildStructure): Seq[Tags.Rule] =
-    getSetting(Keys.concurrentRestrictions, defaultRestrictions(extracted, structure), extracted, structure)
+    getSetting(
+      Keys.concurrentRestrictions,
+      defaultRestrictions(extracted, structure),
+      extracted,
+      structure
+    )
+
   def maxWorkers(extracted: Extracted, structure: BuildStructure): Int =
     if (getSetting(Keys.parallelExecution, true, extracted, structure))
       SystemProcessors
     else
       1
+
   def cancelable(extracted: Extracted, structure: BuildStructure): Boolean =
     getSetting(Keys.cancelable, false, extracted, structure)
-  def cancelStrategy(extracted: Extracted, structure: BuildStructure, state: State): TaskCancellationStrategy =
-    getSetting(Keys.taskCancelStrategy, { (_: State) => TaskCancellationStrategy.Null }, extracted, structure)(state)
 
-  private[sbt] def executeProgress(extracted: Extracted, structure: BuildStructure, state: State): ExecuteProgress[Task] = {
-    import Types.const
-    val maker: State => Keys.TaskProgress = getSetting(Keys.executeProgress, const(new Keys.TaskProgress(defaultProgress)), extracted, structure)
-    maker(state).progress
+  def cancelStrategy(
+      extracted: Extracted,
+      structure: BuildStructure,
+      state: State
+  ): TaskCancellationStrategy =
+    getSetting(Keys.taskCancelStrategy, { (_: State) =>
+      TaskCancellationStrategy.Null
+    }, extracted, structure)(state)
+
+  private[sbt] def executeProgress(
+      extracted: Extracted,
+      structure: BuildStructure,
+      state: State
+  ): ExecuteProgress[Task] = {
+    state
+      .get(currentTaskProgress)
+      .map { tp =>
+        new ExecuteProgress[Task] {
+          val progress = tp.progress
+          override def initial(): Unit = progress.initial()
+          override def afterRegistered(
+              task: Task[_],
+              allDeps: Iterable[Task[_]],
+              pendingDeps: Iterable[Task[_]]
+          ): Unit =
+            progress.afterRegistered(task, allDeps, pendingDeps)
+          override def afterReady(task: Task[_]): Unit = progress.afterReady(task)
+          override def beforeWork(task: Task[_]): Unit = progress.beforeWork(task)
+          override def afterWork[A](task: Task[A], result: Either[Task[A], Result[A]]): Unit =
+            progress.afterWork(task, result)
+          override def afterCompleted[A](task: Task[A], result: Result[A]): Unit =
+            progress.afterCompleted(task, result)
+          override def afterAllCompleted(results: RMap[Task, Result]): Unit =
+            progress.afterAllCompleted(results)
+          override def stop(): Unit = {}
+        }
+      }
+      .getOrElse {
+        val maker: Seq[Keys.TaskProgress] = getSetting(
+          Keys.progressReports,
+          Seq(),
+          extracted,
+          structure
+        )
+        val reporters = maker.map(_.progress) ++ state.get(Keys.taskProgress) ++
+          (if (SysProp.taskTimings)
+             new TaskTimings(reportOnShutdown = false, state.globalLogging.full) :: Nil
+           else Nil)
+        reporters match {
+          case xs if xs.isEmpty   => ExecuteProgress.empty[Task]
+          case xs if xs.size == 1 => xs.head
+          case xs                 => ExecuteProgress.aggregate[Task](xs)
+        }
+      }
   }
   // TODO - Should this pull from Global or from the project itself?
   private[sbt] def forcegc(extracted: Extracted, structure: BuildStructure): Boolean =
-    getSetting(Keys.forcegc in Global, GCUtil.defaultForceGarbageCollection, extracted, structure)
+    getSetting((Global / Keys.forcegc), GCUtil.defaultForceGarbageCollection, extracted, structure)
   // TODO - Should this pull from Global or from the project itself?
   private[sbt] def minForcegcInterval(extracted: Extracted, structure: BuildStructure): Duration =
-    getSetting(Keys.minForcegcInterval in Global, GCUtil.defaultMinForcegcInterval, extracted, structure)
+    getSetting(
+      (Global / Keys.minForcegcInterval),
+      GCUtil.defaultMinForcegcInterval,
+      extracted,
+      structure
+    )
 
-  def getSetting[T](key: SettingKey[T], default: T, extracted: Extracted, structure: BuildStructure): T =
-    key in extracted.currentRef get structure.data getOrElse default
+  def getSetting[T](
+      key: SettingKey[T],
+      default: T,
+      extracted: Extracted,
+      structure: BuildStructure
+  ): T =
+    (extracted.currentRef / key).get(structure.data).getOrElse(default)
 
   def injectSettings: Seq[Setting[_]] = Seq(
-    (state in GlobalScope) ::= dummyState,
-    (streamsManager in GlobalScope) ::= Def.dummyStreamsManager,
-    (executionRoots in GlobalScope) ::= dummyRoots
+    Global / state ::= dummyState,
+    Global / streamsManager ::= Def.dummyStreamsManager,
+    Global / executionRoots ::= dummyRoots,
   )
 
+  @deprecated("Use variant which doesn't take a logger", "1.1.1")
   def evalPluginDef(log: Logger)(pluginDef: BuildStructure, state: State): PluginData =
-    {
-      val root = ProjectRef(pluginDef.root, Load.getRootProject(pluginDef.units)(pluginDef.root))
-      val pluginKey = pluginData
-      val config = extractedTaskConfig(Project.extract(state), pluginDef, state)
-      val evaluated = apply(pluginDef, ScopedKey(pluginKey.scope, pluginKey.key), state, root, config)
-      val (newS, result) = evaluated getOrElse sys.error("Plugin data does not exist for plugin definition at " + pluginDef.root)
-      Project.runUnloadHooks(newS) // discard states
-      processResult(result, log)
-    }
+    evalPluginDef(pluginDef, state)
+
+  def evalPluginDef(pluginDef: BuildStructure, state: State): PluginData = {
+    val root = ProjectRef(pluginDef.root, Load.getRootProject(pluginDef.units)(pluginDef.root))
+    val pluginKey = pluginData
+    val config = extractedTaskConfig(Project.extract(state), pluginDef, state)
+    val evaluated =
+      apply(pluginDef, ScopedKey(pluginKey.scope, pluginKey.key), state, root, config)
+    val (newS, result) = evaluated getOrElse sys.error(
+      "Plugin data does not exist for plugin definition at " + pluginDef.root
+    )
+    Project.runUnloadHooks(newS) // discard states
+    processResult2(result)
+  }
 
   /**
    * Evaluates `taskKey` and returns the new State and the result of the task wrapped in Some.
    * If the task is not defined, None is returned.  The provided task key is resolved against the current project `ref`.
    * Task execution is configured according to settings defined in the loaded project.
    */
-  def apply[T](structure: BuildStructure, taskKey: ScopedKey[Task[T]], state: State, ref: ProjectRef): Option[(State, Result[T])] =
-    apply[T](structure, taskKey, state, ref, extractedTaskConfig(Project.extract(state), structure, state))
+  def apply[T](
+      structure: BuildStructure,
+      taskKey: ScopedKey[Task[T]],
+      state: State,
+      ref: ProjectRef
+  ): Option[(State, Result[T])] =
+    apply[T](
+      structure,
+      taskKey,
+      state,
+      ref,
+      extractedTaskConfig(Project.extract(state), structure, state)
+    )
 
   /**
    * Evaluates `taskKey` and returns the new State and the result of the task wrapped in Some.
    * If the task is not defined, None is returned.  The provided task key is resolved against the current project `ref`.
    * `config` configures concurrency and canceling of task execution.
    */
-  def apply[T](structure: BuildStructure, taskKey: ScopedKey[Task[T]], state: State, ref: ProjectRef, config: EvaluateTaskConfig): Option[(State, Result[T])] = {
+  def apply[T](
+      structure: BuildStructure,
+      taskKey: ScopedKey[Task[T]],
+      state: State,
+      ref: ProjectRef,
+      config: EvaluateTaskConfig
+  ): Option[(State, Result[T])] = {
     withStreams(structure, state) { str =>
-      for ((task, toNode) <- getTask(structure, taskKey, state, str, ref)) yield runTask(task, state, str, structure.index.triggers, config)(toNode)
+      for ((task, toNode) <- getTask(structure, taskKey, state, str, ref))
+        yield runTask(task, state, str, structure.index.triggers, config)(toNode)
     }
   }
-  def logIncResult(result: Result[_], state: State, streams: Streams) = result match { case Inc(i) => logIncomplete(i, state, streams); case _ => () }
+
+  def logIncResult(result: Result[_], state: State, streams: Streams) = result match {
+    case Inc(i) => logIncomplete(i, state, streams); case _ => ()
+  }
+
   def logIncomplete(result: Incomplete, state: State, streams: Streams): Unit = {
     val all = Incomplete linearize result
-    val keyed = for (Incomplete(Some(key: ScopedKey[_]), _, msg, _, ex) <- all) yield (key, msg, ex)
+    val keyed =
+      all collect { case Incomplete(Some(key: ScopedKey[_]), _, msg, _, ex) => (key, msg, ex) }
 
     import ExceptionCategory._
     for ((key, msg, Some(ex)) <- keyed) {
@@ -268,117 +370,198 @@ object EvaluateTask {
     for ((key, msg, ex) <- keyed if (msg.isDefined || ex.isDefined)) {
       val msgString = (msg.toList ++ ex.toList.map(ErrorHandling.reducedToString)).mkString("\n\t")
       val log = getStreams(key, streams).log
-      val display = contextDisplay(state, log.ansiCodesSupported)
-      log.error("(" + display(key) + ") " + msgString)
+      val display = contextDisplay(state, ITerminal.isColorEnabled)
+      log.error("(" + display.show(key) + ") " + msgString)
     }
   }
-  private[this] def contextDisplay(state: State, highlight: Boolean) = Project.showContextKey(state, if (highlight) Some(RED) else None)
+
+  private[this] def contextDisplay(state: State, highlight: Boolean) =
+    Project.showContextKey(state, if (highlight) Some(RED) else None)
+
   def suppressedMessage(key: ScopedKey[_])(implicit display: Show[ScopedKey[_]]): String =
-    "Stack trace suppressed.  Run 'last %s' for the full log.".format(display(key))
+    "Stack trace suppressed.  Run 'last %s' for the full log.".format(display.show(key))
 
   def getStreams(key: ScopedKey[_], streams: Streams): TaskStreams =
     streams(ScopedKey(Project.fillTaskAxis(key).scope, Keys.streams.key))
-  def withStreams[T](structure: BuildStructure, state: State)(f: Streams => T): T =
-    {
-      val str = std.Streams.closeable(structure.streams(state))
-      try { f(str) } finally { str.close() }
+
+  def withStreams[T](structure: BuildStructure, state: State)(f: Streams => T): T = {
+    val str = std.Streams.closeable(structure.streams(state))
+    try {
+      f(str)
+    } finally {
+      str.close()
     }
+  }
 
-  def getTask[T](structure: BuildStructure, taskKey: ScopedKey[Task[T]], state: State, streams: Streams, ref: ProjectRef): Option[(Task[T], NodeView[Task])] =
-    {
-      val thisScope = Load.projectScope(ref)
-      val resolvedScope = Scope.replaceThis(thisScope)(taskKey.scope)
-      for (t <- structure.data.get(resolvedScope, taskKey.key)) yield (t, nodeView(state, streams, taskKey :: Nil))
+  def getTask[T](
+      structure: BuildStructure,
+      taskKey: ScopedKey[Task[T]],
+      state: State,
+      streams: Streams,
+      ref: ProjectRef
+  ): Option[(Task[T], NodeView[Task])] = {
+    val thisScope = Load.projectScope(ref)
+    val resolvedScope = Scope.replaceThis(thisScope)(taskKey.scope)
+    for (t <- structure.data.get(resolvedScope, taskKey.key))
+      yield (t, nodeView(state, streams, taskKey :: Nil))
+  }
+  def nodeView[HL <: HList](
+      state: State,
+      streams: Streams,
+      roots: Seq[ScopedKey[_]],
+      dummies: DummyTaskMap = DummyTaskMap(Nil)
+  ): NodeView[Task] =
+    Transform(
+      (dummyRoots, roots) :: (Def.dummyStreamsManager, streams) :: (dummyState, state) :: dummies
+    )
+
+  @deprecated("use StandardMain.exchange.withState to obtain an instance of State", "1.4.2")
+  val lastEvaluatedState: AtomicReference[SafeState] = new AtomicReference()
+  @deprecated("use currentlyRunningTaskEngine", "1.4.2")
+  val currentlyRunningEngine: AtomicReference[(SafeState, RunningTaskEngine)] =
+    new AtomicReference()
+  private[sbt] val currentlyRunningTaskEngine: AtomicReference[RunningTaskEngine] =
+    new AtomicReference()
+
+  /**
+   * The main method for the task engine.
+   * See also Aggregation.runTasks.
+   */
+  def runTask[T](
+      root: Task[T],
+      state: State,
+      streams: Streams,
+      triggers: Triggers[Task],
+      config: EvaluateTaskConfig
+  )(implicit taskToNode: NodeView[Task]): (State, Result[T]) = {
+    import ConcurrentRestrictions.{ cancellableCompletionService, tagged, tagsKey }
+
+    val log = state.log
+    log.debug(
+      s"Running task... Cancel: ${config.cancelStrategy}, check cycles: ${config.checkCycles}, forcegc: ${config.forceGarbageCollection}"
+    )
+    def tagMap(t: Task[_]): Tags.TagMap =
+      t.info.get(tagsKey).getOrElse(Map.empty)
+    val tags =
+      tagged[Task[_]](tagMap, Tags.predicate(config.restrictions))
+    val (service, shutdownThreads) =
+      cancellableCompletionService[Task[_], Completed](
+        tags,
+        (s: String) => log.warn(s),
+        (t: Task[_]) => tagMap(t).contains(Tags.Sentinel)
+      )
+
+    def shutdownImpl(force: Boolean): Unit = {
+      // First ensure that all threads are stopped for task execution.
+      shutdownThreads(force)
+      config.progressReporter.stop()
+
+      // Now we run the gc cleanup to force finalizers to clear out file handles (yay GC!)
+      if (config.forceGarbageCollection) {
+        GCUtil.forceGcWithInterval(config.minForcegcInterval, log)
+      }
     }
-  def nodeView[HL <: HList](state: State, streams: Streams, roots: Seq[ScopedKey[_]], dummies: DummyTaskMap = DummyTaskMap(Nil)): NodeView[Task] =
-    Transform((dummyRoots, roots) :: (Def.dummyStreamsManager, streams) :: (dummyState, state) :: dummies)
-
-  def runTask[T](root: Task[T], state: State, streams: Streams, triggers: Triggers[Task], config: EvaluateTaskConfig)(implicit taskToNode: NodeView[Task]): (State, Result[T]) =
-    {
-      import ConcurrentRestrictions.{ completionService, tagged, tagsKey }
-
-      val log = state.log
-      log.debug(s"Running task... Cancel: ${config.cancelStrategy}, check cycles: ${config.checkCycles}, forcegc: ${config.forceGarbageCollection}")
-      val tags = tagged[Task[_]](_.info get tagsKey getOrElse Map.empty, Tags.predicate(config.restrictions))
-      val (service, shutdownThreads) = completionService[Task[_], Completed](tags, (s: String) => log.warn(s))
-
-      def shutdown(): Unit = {
-        // First ensure that all threads are stopped for task execution.
-        shutdownThreads()
-
-        // Now we run the gc cleanup to force finalizers to clear out file handles (yay GC!)
-        if (config.forceGarbageCollection) {
-          GCUtil.forceGcWithInterval(config.minForcegcInterval, log)
-        }
-      }
-      // propagate the defining key for reporting the origin
-      def overwriteNode(i: Incomplete): Boolean = i.node match {
-        case Some(t: Task[_]) => transformNode(t).isEmpty
-        case _                => true
-      }
-      def run() = {
-        val x = new Execute[Task](Execute.config(config.checkCycles, overwriteNode), triggers, config.progressReporter)(taskToNode)
-        val (newState, result) =
-          try {
-            val results = x.runKeep(root)(service)
-            storeValuesForPrevious(results, state, streams)
-            applyResults(results, state, root)
-          } catch { case inc: Incomplete => (state, Inc(inc)) }
-          finally shutdown()
-        val replaced = transformInc(result)
-        logIncResult(replaced, state, streams)
-        (newState, replaced)
-      }
-      object runningEngine extends RunningTaskEngine {
-        def cancelAndShutdown(): Unit = {
-          println("")
-          log.warn("Canceling execution...")
-          shutdown()
-        }
-      }
-      // Register with our cancel handler we're about to start.
-      val strat = config.cancelStrategy
-      val cancelState = strat.onTaskEngineStart(runningEngine)
-      try run()
-      finally strat.onTaskEngineFinish(cancelState)
+    def shutdown(): Unit = shutdownImpl(false)
+    // propagate the defining key for reporting the origin
+    def overwriteNode(i: Incomplete): Boolean = i.node match {
+      case Some(t: Task[_]) => transformNode(t).isEmpty
+      case _                => true
     }
+    def run() = {
+      val x = new Execute[Task](
+        Execute.config(config.checkCycles, overwriteNode),
+        triggers,
+        config.progressReporter
+      )(taskToNode)
+      val (newState, result) =
+        try {
+          val results = x.runKeep(root)(service)
+          storeValuesForPrevious(results, state, streams)
+          applyResults(results, state, root)
+        } catch { case inc: Incomplete => (state, Inc(inc)) } finally shutdown()
+      val replaced = transformInc(result)
+      logIncResult(replaced, state, streams)
+      (newState, replaced)
+    }
+    object runningEngine extends RunningTaskEngine {
+      def cancelAndShutdown(): Unit = {
+        println("")
+        log.warn("Canceling execution...")
+        RunningProcesses.killAll()
+        ConcurrentRestrictions.cancelAll()
+        shutdownImpl(true)
+      }
+    }
+    currentlyRunningTaskEngine.set(runningEngine)
+    // Register with our cancel handler we're about to start.
+    val strat = config.cancelStrategy
+    val cancelState = strat.onTaskEngineStart(runningEngine)
+    config.progressReporter.initial()
+    try run()
+    finally {
+      strat.onTaskEngineFinish(cancelState)
+      currentlyRunningTaskEngine.set(null)
+    }
+  }
 
-  private[this] def storeValuesForPrevious(results: RMap[Task, Result], state: State, streams: Streams): Unit =
-    for (referenced <- Previous.references in Global get Project.structure(state).data)
+  private[this] def storeValuesForPrevious(
+      results: RMap[Task, Result],
+      state: State,
+      streams: Streams
+  ): Unit =
+    for (referenced <- (Global / Previous.references) get Project.structure(state).data)
       Previous.complete(referenced, results, streams)
 
-  def applyResults[T](results: RMap[Task, Result], state: State, root: Task[T]): (State, Result[T]) =
+  def applyResults[T](
+      results: RMap[Task, Result],
+      state: State,
+      root: Task[T]
+  ): (State, Result[T]) = {
     (stateTransform(results)(state), results(root))
+  }
   def stateTransform(results: RMap[Task, Result]): State => State =
     Function.chain(
       results.toTypedSeq flatMap {
-        case results.TPair(Task(info, _), Value(v)) => info.post(v) get transformState
-        case _                                      => Nil
+        case results.TPair(_, Value(KeyValue(_, st: StateTransform))) => Some(st.transform)
+        case results.TPair(Task(info, _), Value(v))                   => info.post(v) get transformState
+        case _                                                        => Nil
       }
     )
 
   def transformInc[T](result: Result[T]): Result[T] =
     // taskToKey needs to be before liftAnonymous.  liftA only lifts non-keyed (anonymous) Incompletes.
-    result.toEither.left.map { i => Incomplete.transformBU(i)(convertCyclicInc andThen taskToKey andThen liftAnonymous) }
+    result.toEither.left.map { i =>
+      Incomplete.transformBU(i)(convertCyclicInc andThen taskToKey andThen liftAnonymous)
+    }
   def taskToKey: Incomplete => Incomplete = {
     case in @ Incomplete(Some(node: Task[_]), _, _, _, _) => in.copy(node = transformNode(node))
-    case i => i
+    case i                                                => i
   }
+
   type AnyCyclic = Execute[({ type A[_] <: AnyRef })#A]#CyclicException[_]
+
   def convertCyclicInc: Incomplete => Incomplete = {
-    case in @ Incomplete(_, _, _, _, Some(c: AnyCyclic)) =>
+    case in @ Incomplete(
+          _,
+          _,
+          _,
+          _,
+          Some(c: Execute[({ type A[_] <: AnyRef })#A @unchecked]#CyclicException[_])
+        ) =>
       in.copy(directCause = Some(new RuntimeException(convertCyclic(c))))
     case i => i
   }
+
   def convertCyclic(c: AnyCyclic): String =
     (c.caller, c.target) match {
       case (caller: Task[_], target: Task[_]) =>
-        c.toString + (if (caller eq target) "(task: " + name(caller) + ")" else "(caller: " + name(caller) + ", target: " + name(target) + ")")
+        c.toString + (if (caller eq target) "(task: " + name(caller) + ")"
+                      else "(caller: " + name(caller) + ", target: " + name(target) + ")")
       case _ => c.toString
     }
 
   def liftAnonymous: Incomplete => Incomplete = {
-    case i @ Incomplete(node, tpe, None, causes, None) =>
+    case i @ Incomplete(_, _, None, causes, None) =>
       causes.find(inc => inc.node.isEmpty && (inc.message.isDefined || inc.directCause.isDefined)) match {
         case Some(lift) => i.copy(directCause = lift.directCause, message = lift.message)
         case None       => i
@@ -386,9 +569,19 @@ object EvaluateTask {
     case i => i
   }
 
+  @deprecated("Use processResult2 which doesn't take the unused log param", "1.1.1")
   def processResult[T](result: Result[T], log: Logger, show: Boolean = false): T =
-    onResult(result, log) { v => if (show) println("Result: " + v); v }
-  def onResult[T, S](result: Result[T], log: Logger)(f: T => S): S =
+    processResult2(result, show)
+
+  def processResult2[T](result: Result[T], show: Boolean = false): T =
+    onResult(result) { v =>
+      if (show) println("Result: " + v); v
+    }
+
+  @deprecated("Use variant that doesn't take log", "1.1.1")
+  def onResult[T, S](result: Result[T], log: Logger)(f: T => S): S = onResult(result)(f)
+
+  def onResult[T, S](result: Result[T])(f: T => S): S =
     result match {
       case Value(v) => f(v)
       case Inc(inc) => throw inc
@@ -396,14 +589,15 @@ object EvaluateTask {
 
   // if the return type Seq[Setting[_]] is not explicitly given, scalac hangs
   val injectStreams: ScopedKey[_] => Seq[Setting[_]] = scoped =>
-    if (scoped.key == streams.key)
-      Seq(streams in scoped.scope := {
+    if (scoped.key == streams.key) {
+      Seq(scoped.scope / streams := {
         (streamsManager map { mgr =>
           val stream = mgr(scoped)
           stream.open()
           stream
         }).value
       })
-    else
+    } else {
       Nil
+    }
 }
diff --git a/main/src/main/scala/sbt/Extracted.scala b/main/src/main/scala/sbt/Extracted.scala
index dff713b17..cec5beb4c 100644
--- a/main/src/main/scala/sbt/Extracted.scala
+++ b/main/src/main/scala/sbt/Extracted.scala
@@ -1,14 +1,27 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import sbt.internal.{ Load, BuildStructure, Act, Aggregation, SessionSettings }
-import Project._
 import Scope.GlobalScope
 import Def.{ ScopedKey, Setting }
 import sbt.internal.util.complete.Parser
-import sbt.internal.util.{ AttributeKey, Show }
+import sbt.internal.util.AttributeKey
+import sbt.util.Show
 import std.Transform.DummyTaskMap
+import sbt.EvaluateTask.extractedTaskConfig
+import scala.annotation.nowarn
 
-final case class Extracted(structure: BuildStructure, session: SessionSettings, currentRef: ProjectRef)(implicit val showKey: Show[ScopedKey[_]]) {
+final case class Extracted(
+    structure: BuildStructure,
+    session: SessionSettings,
+    currentRef: ProjectRef
+)(implicit val showKey: Show[ScopedKey[_]]) {
   def rootProject = structure.rootProject
   lazy val currentUnit = structure units currentRef.build
   lazy val currentProject = currentUnit defined currentRef.project
@@ -17,7 +30,7 @@ final case class Extracted(structure: BuildStructure, session: SessionSettings,
   /**
    * Gets the value assigned to `key` in the computed settings map.
    * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
-   * Other axes are resolved to be `Global` if they are not specified.
+   * Other axes are resolved to be `Zero` if they are not specified.
    */
   def get[T](key: SettingKey[T]): T = getOrError(inCurrent(key.scope), key.key)
   def get[T](key: TaskKey[T]): Task[T] = getOrError(inCurrent(key.scope), key.key)
@@ -25,56 +38,59 @@ final case class Extracted(structure: BuildStructure, session: SessionSettings,
   /**
    * Gets the value assigned to `key` in the computed settings map wrapped in Some.  If it does not exist, None is returned.
    * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
-   * Other axes are resolved to be `Global` if they are not specified.
+   * Other axes are resolved to be `Zero` if they are not specified.
    */
   def getOpt[T](key: SettingKey[T]): Option[T] = structure.data.get(inCurrent(key.scope), key.key)
-  def getOpt[T](key: TaskKey[T]): Option[Task[T]] = structure.data.get(inCurrent(key.scope), key.key)
+  def getOpt[T](key: TaskKey[T]): Option[Task[T]] =
+    structure.data.get(inCurrent(key.scope), key.key)
 
+  @nowarn
   private[this] def inCurrent[T](scope: Scope): Scope =
-    if (scope.project == This) scope.copy(project = Select(currentRef)) else scope
+    if (scope.project == This) scope in currentRef else scope
 
   /**
    * Runs the task specified by `key` and returns the transformed State and the resulting value of the task.
    * If the project axis is not defined for the key, it is resolved to be the current project.
-   * Other axes are resolved to `Global` if unspecified.
+   * Other axes are resolved to `Zero` if unspecified.
    *
-   * This method requests execution of only the given task and does not aggregate execution.  See `runAggregated` for that.
+   * This method requests execution of only the given task and does not aggregate execution.
+   * See `runAggregated` for that.
    */
-  def runTask[T](key: TaskKey[T], state: State): (State, T) =
-    {
-      import EvaluateTask._
-      val rkey = resolve(key.scopedKey)
-      val config = extractedTaskConfig(this, structure, state)
-      val value: Option[(State, Result[T])] = apply(structure, key.scopedKey, state, currentRef, config)
-      val (newS, result) = getOrError(rkey.scope, rkey.key, value)
-      (newS, processResult(result, newS.log))
-    }
+  def runTask[T](key: TaskKey[T], state: State): (State, T) = {
+    val rkey = resolve(key)
+    val config = extractedTaskConfig(this, structure, state)
+    val value: Option[(State, Result[T])] =
+      EvaluateTask(structure, key.scopedKey, state, currentRef, config)
+    val (newS, result) = getOrError(rkey.scope, rkey.key, value)
+    (newS, EvaluateTask.processResult2(result))
+  }
 
   /**
    * Runs the input task specified by `key`, using the `input` as the input to it, and returns the transformed State
    * and the resulting value of the input task.
    *
    * If the project axis is not defined for the key, it is resolved to be the current project.
-   * Other axes are resolved to `Global` if unspecified.
+   * Other axes are resolved to `Zero` if unspecified.
    *
    * This method requests execution of only the given task and does not aggregate execution.
    */
   def runInputTask[T](key: InputKey[T], input: String, state: State): (State, T) = {
-    import EvaluateTask._
-
-    val scopedKey = Scoped.scopedSetting(
-      Scope.resolveScope(Load.projectScope(currentRef), currentRef.build, structure.rootProject)(key.scope), key.key)
-    val rkey = resolve(scopedKey.scopedKey)
-    val inputTask = get(Scoped.scopedSetting(rkey.scope, rkey.key))
+    val key2 = Scoped.scopedSetting(
+      Scope.resolveScope(Load.projectScope(currentRef), currentRef.build, rootProject)(key.scope),
+      key.key
+    )
+    val rkey = resolve(key2)
+    val inputTask = get(rkey)
     val task = Parser.parse(input, inputTask.parser(state)) match {
       case Right(t)  => t
       case Left(msg) => sys.error(s"Invalid programmatic input:\n$msg")
     }
     val config = extractedTaskConfig(this, structure, state)
-    withStreams(structure, state) { str =>
-      val nv = nodeView(state, str, rkey :: Nil)
-      val (newS, result) = EvaluateTask.runTask(task, state, str, structure.index.triggers, config)(nv)
-      (newS, processResult(result, newS.log))
+    EvaluateTask.withStreams(structure, state) { str =>
+      val nv = EvaluateTask.nodeView(state, str, rkey.scopedKey :: Nil)
+      val (newS, result) =
+        EvaluateTask.runTask(task, state, str, structure.index.triggers, config)(nv)
+      (newS, EvaluateTask.processResult2(result))
     }
   }
 
@@ -82,27 +98,60 @@ final case class Extracted(structure: BuildStructure, session: SessionSettings,
    * Runs the tasks selected by aggregating `key` and returns the transformed State.
    * If the project axis is not defined for the key, it is resolved to be the current project.
    * The project axis is what determines where aggregation starts, so ensure this is set to what you want.
-   * Other axes are resolved to `Global` if unspecified.
+   * Other axes are resolved to `Zero` if unspecified.
    */
-  def runAggregated[T](key: TaskKey[T], state: State): State =
-    {
-      val rkey = resolve(key.scopedKey)
-      val keys = Aggregation.aggregate(rkey, ScopeMask(), structure.extra)
-      val tasks = Act.keyValues(structure)(keys)
-      Aggregation.runTasks(state, structure, tasks, DummyTaskMap(Nil), show = Aggregation.defaultShow(state, false))(showKey)
-    }
+  def runAggregated[T](key: TaskKey[T], state: State): State = {
+    val rkey = resolve(key)
+    val keys = Aggregation.aggregate(rkey, ScopeMask(), structure.extra)
+    val tasks = Act.keyValues(structure)(keys)
+    Aggregation.runTasks(
+      state,
+      tasks,
+      DummyTaskMap(Nil),
+      show = Aggregation.defaultShow(state, false),
+    )(showKey)
+  }
 
-  private[this] def resolve[T](key: ScopedKey[T]): ScopedKey[T] =
-    Project.mapScope(Scope.resolveScope(GlobalScope, currentRef.build, rootProject))(key.scopedKey)
-  private def getOrError[T](scope: Scope, key: AttributeKey[_], value: Option[T])(implicit display: Show[ScopedKey[_]]): T =
-    value getOrElse sys.error(display(ScopedKey(scope, key)) + " is undefined.")
-  private def getOrError[T](scope: Scope, key: AttributeKey[T])(implicit display: Show[ScopedKey[_]]): T =
-    structure.data.get(scope, key) getOrElse sys.error(display(ScopedKey(scope, key)) + " is undefined.")
+  @nowarn
+  private[this] def resolve[K <: Scoped.ScopingSetting[K] with Scoped](key: K): K =
+    key in Scope.resolveScope(GlobalScope, currentRef.build, rootProject)(key.scope)
 
+  private def getOrError[T](scope: Scope, key: AttributeKey[_], value: Option[T])(
+      implicit display: Show[ScopedKey[_]]
+  ): T =
+    value getOrElse sys.error(display.show(ScopedKey(scope, key)) + " is undefined.")
+
+  private def getOrError[T](scope: Scope, key: AttributeKey[T])(
+      implicit display: Show[ScopedKey[_]]
+  ): T =
+    getOrError(scope, key, structure.data.get(scope, key))(display)
+
+  @deprecated(
+    "This discards session settings. Migrate to appendWithSession or appendWithoutSession.",
+    "1.2.0"
+  )
   def append(settings: Seq[Setting[_]], state: State): State =
-    {
-      val appendSettings = Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, settings)
-      val newStructure = Load.reapply(session.original ++ appendSettings, structure)
-      Project.setProject(session, newStructure, state)
-    }
+    appendWithoutSession(settings, state)
+
+  /** Appends the given settings to all the build state settings, including session settings. */
+  def appendWithSession(settings: Seq[Setting[_]], state: State): State =
+    appendImpl(settings, state, session.mergeSettings)
+
+  /**
+   * Appends the given settings to the original build state settings, discarding any settings
+   * appended to the session in the process.
+   */
+  def appendWithoutSession(settings: Seq[Setting[_]], state: State): State =
+    appendImpl(settings, state, session.original)
+
+  private[this] def appendImpl(
+      settings: Seq[Setting[_]],
+      state: State,
+      sessionSettings: Seq[Setting[_]],
+  ): State = {
+    val appendSettings =
+      Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, settings)
+    val newStructure = Load.reapply(sessionSettings ++ appendSettings, structure)
+    Project.setProject(session, newStructure, state)
+  }
 }
diff --git a/main/src/main/scala/sbt/InteractionService.scala b/main/src/main/scala/sbt/InteractionService.scala
new file mode 100644
index 000000000..6a37d4ff2
--- /dev/null
+++ b/main/src/main/scala/sbt/InteractionService.scala
@@ -0,0 +1,28 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+/**
+ * InteractionService provides an abstration over standard input.
+ * In the future this could be used to ask for inputs from
+ * other forms of sbt clients such as thin clients and IDEs.
+ */
+abstract class InteractionService {
+
+  /** Prompts the user for input, optionally with a mask for characters. */
+  def readLine(prompt: String, mask: Boolean): Option[String]
+
+  /** Ask the user to confirm something (yes or no) before continuing. */
+  def confirm(msg: String): Boolean
+
+  def terminalWidth: Int
+
+  def terminalHeight: Int
+
+  // TODO - Ask for input with autocomplete?
+}
diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala
index 33ac5f3f2..bd2075346 100644
--- a/main/src/main/scala/sbt/Keys.scala
+++ b/main/src/main/scala/sbt/Keys.scala
@@ -1,452 +1,626 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
+import java.nio.file.{ Path => NioPath }
 import java.io.File
 import java.net.URL
-import scala.concurrent.duration.{ FiniteDuration, Duration }
-import Def.ScopedKey
+
+import lmcoursier.definitions.{ CacheLogger, ModuleMatchers, Reconciliation }
+import lmcoursier.{ CoursierConfiguration, FallbackDependency }
+import org.apache.ivy.core.module.descriptor.ModuleDescriptor
+import org.apache.ivy.core.module.id.ModuleRevisionId
+import org.apache.logging.log4j.core.{ Appender => XAppender }
+import sbt.BuildSyntax._
+import sbt.Def.ScopedKey
+import sbt.KeyRanks._
+import sbt.internal.InMemoryCacheStore.CacheStoreFactoryFactory
+import sbt.internal._
+import sbt.internal.bsp._
 import sbt.internal.inc.ScalaInstance
-import xsbti.compile.{
-  DefinesClass,
-  ClasspathOptions,
-  CompileAnalysis,
-  CompileOptions,
-  CompileOrder,
-  Compilers,
-  CompileResult,
-  GlobalsCache,
-  IncOptions,
-  Inputs,
-  PreviousResult,
-  Setup
-}
-import scala.xml.{ Node => XNode, NodeSeq }
-import org.apache.ivy.core.module.{ descriptor, id }
-import descriptor.ModuleDescriptor, id.ModuleRevisionId
-import testing.Framework
-import KeyRanks._
-
-import sbt.internal.{ BuildStructure, LoadedBuild, PluginDiscovery, BuildDependencies, SessionSettings }
-import sbt.io.FileFilter
 import sbt.internal.io.WatchState
-import sbt.internal.util.{ AttributeKey, SourcePosition }
-
+import sbt.internal.librarymanagement.{ CompatibilityWarningOptions, IvySbt }
+import sbt.internal.remotecache.RemoteCacheArtifact
+import sbt.internal.server.{ BuildServerReporter, ServerHandler }
+import sbt.internal.util.{ AttributeKey, ProgressState, SourcePosition }
+import sbt.io._
 import sbt.librarymanagement.Configurations.CompilerPlugin
-import sbt.librarymanagement.{
-  Artifact,
-  Configuration,
-  ConflictManager,
-  ConflictWarning,
-  Credentials,
-  CrossVersion,
-  Developer,
-  EvictionWarning,
-  EvictionWarningOptions,
-  IvyScala,
-  MavenRepository,
-  ModuleConfiguration,
-  ModuleID,
-  ModuleInfo,
-  Resolver,
-  ScalaVersion,
-  ScmInfo,
-  TrackLevel,
-  UpdateOptions,
-  UpdateReport
-}
-import sbt.internal.librarymanagement.{
-  CompatibilityWarningOptions,
-  DeliverConfiguration,
-  GetClassifiersModule,
-  IvyConfiguration,
-  IvyPaths,
-  IvySbt,
-  MakePomConfiguration,
-  ModuleSettings,
-  PublishConfiguration,
-  RetrieveConfiguration,
-  SbtExclusionRule,
-  UnresolvedWarningConfiguration,
-  UpdateConfiguration,
-  UpdateLogging
-}
-import sbt.util.{ AbstractLogger, Level, Logger }
+import sbt.librarymanagement.LibraryManagementCodec._
+import sbt.librarymanagement._
+import sbt.librarymanagement.ivy.{ Credentials, IvyConfiguration, IvyPaths, UpdateOptions }
+import sbt.nio.file.Glob
+import sbt.testing.Framework
+import sbt.util.{ Level, Logger, LoggerContext }
+import xsbti.{ FileConverter, VirtualFile }
+import xsbti.compile._
+import xsbti.compile.analysis.ReadStamps
+
+import scala.concurrent.duration.{ Duration, FiniteDuration }
+import scala.xml.{ NodeSeq, Node => XNode }
+
+// format: off
 
 object Keys {
+  // Normally we prefer concrete datatype like Vector, but due to ++= implicits and for backward compatibility,
+  // for keys we should stick to using Seq.
+
   val TraceValues = "-1 to disable, 0 for up to the first sbt frame, or a positive number to set the maximum number of frames shown."
 
   // logging
-  val logLevel = SettingKey[Level.Value]("log-level", "The amount of logging sent to the screen.", ASetting)
-  val persistLogLevel = SettingKey[Level.Value]("persist-log-level", "The amount of logging sent to a file for persistence.", CSetting)
-  val traceLevel = SettingKey[Int]("trace-level", "The amount of a stack trace displayed.  " + TraceValues, ASetting)
-  val persistTraceLevel = SettingKey[Int]("persist-trace-level", "The amount of stack trace persisted.", CSetting)
-  val showSuccess = SettingKey[Boolean]("show-success", "If true, displays a success message after running a command successfully.", CSetting)
-  val showTiming = SettingKey[Boolean]("show-timing", "If true, the command success message includes the completion time.", CSetting)
-  val timingFormat = SettingKey[java.text.DateFormat]("timing-format", "The format used for displaying the completion time.", CSetting)
-  val extraLoggers = SettingKey[ScopedKey[_] => Seq[AbstractLogger]]("extra-loggers", "A function that provides additional loggers for a given setting.", DSetting)
-  val logManager = SettingKey[LogManager]("log-manager", "The log manager, which creates Loggers for different contexts.", DSetting)
-  val logBuffered = SettingKey[Boolean]("log-buffered", "True if logging should be buffered until work completes.", CSetting)
-  val sLog = SettingKey[Logger]("setting-logger", "Logger usable by settings during project loading.", CSetting)
+  val logLevel = SettingKey(BasicKeys.logLevel).withRank(ASetting)
+  val persistLogLevel = settingKey[Level.Value]("The amount of logging sent to a file for persistence.").withRank(CSetting)
+  val traceLevel = settingKey[Int]("The amount of a stack trace displayed.  " + TraceValues).withRank(ASetting)
+  val persistTraceLevel = settingKey[Int]("The amount of stack trace persisted.").withRank(CSetting)
+  val showSuccess = settingKey[Boolean]("If true, displays a success message after running a command successfully.").withRank(CSetting)
+  val showTiming = settingKey[Boolean]("If true, the command success message includes the completion time.").withRank(CSetting)
+  val timingFormat = settingKey[java.text.DateFormat]("The format used for displaying the completion time.").withRank(CSetting)
+  @deprecated("", "1.4.0")
+  val extraLoggers = settingKey[ScopedKey[_] => Seq[XAppender]]("A function that provides additional loggers for a given setting.").withRank(DSetting)
+  val extraAppenders = settingKey[AppenderSupplier]("A function that provides additional loggers for a given setting.").withRank(DSetting)
+  val useLog4J = settingKey[Boolean]("Toggles whether or not to use log4j for sbt internal loggers.").withRank(Invisible)
+  val logManager = settingKey[LogManager]("The log manager, which creates Loggers for different contexts.").withRank(DSetting)
+  private[sbt] val loggerContext = AttributeKey[LoggerContext]("sbt-logger-context", "The logger config which creates Loggers for different contexts.", Int.MaxValue)
+  val logBuffered = settingKey[Boolean]("True if logging should be buffered until work completes.").withRank(CSetting)
+  val sLog = settingKey[Logger]("Logger usable by settings during project loading.").withRank(CSetting)
+  val serverLog = taskKey[Unit]("A dummy task to set server log level using Global / serverLog / logLevel.").withRank(CTask)
+  val canonicalInput = settingKey[Boolean]("Toggles whether a task should use canonical input (line buffered with echo) or raw input").withRank(DSetting)
+  val echoInput = settingKey[Boolean]("Toggles whether a task should echo user input").withRank(DSetting)
+  val terminal = taskKey[Terminal]("The Terminal associated with a task").withRank(DTask)
+  private[sbt] val terminalKey = AttributeKey[Terminal]("terminal-key", Invisible)
 
   // Project keys
-  val autoGeneratedProject = SettingKey[Boolean]("autogeneratedProject", "If it exists, represents that the project (and name) were automatically created, rather than user specified.", DSetting)
-  val projectCommand = AttributeKey[Boolean]("project-command", "Marks Commands that were registered for the current Project.", Invisible)
-  val sessionSettings = AttributeKey[SessionSettings]("session-settings", "Tracks current build, project, and setting modifications.", DSetting)
-  val stateBuildStructure = AttributeKey[BuildStructure]("build-structure", "Data structure containing all information about the build definition.", BSetting)
-  val buildStructure = TaskKey[BuildStructure]("build-structure", "Provides access to the build structure, settings, and streams manager.", DTask)
-  val loadedBuild = SettingKey[LoadedBuild]("loaded-build", "Provides access to the loaded project structure.  This is the information available before settings are evaluated.", DSetting)
-  val buildDependencies = SettingKey[BuildDependencies]("build-dependencies", "Definitive source of inter-project dependencies for compilation and dependency management.\n\tThis is populated by default by the dependencies declared on Project instances, but may be modified.\n\tThe main restriction is that new builds may not be introduced.", DSetting)
-  val appConfiguration = SettingKey[xsbti.AppConfiguration]("app-configuration", "Provides access to the launched sbt configuration, including the ScalaProvider, Launcher, and GlobalLock.", DSetting)
-  val thisProject = SettingKey[ResolvedProject]("this-project", "Provides the current project for the referencing scope.", CSetting)
-  val thisProjectRef = SettingKey[ProjectRef]("this-project-ref", "Provides a fully-resolved reference to the current project for the referencing scope.", CSetting)
-  val configuration = SettingKey[Configuration]("configuration", "Provides the current configuration of the referencing scope.", CSetting)
-  val commands = SettingKey[Seq[Command]]("commands", "Defines commands to be registered when this project or build is the current selected one.", CSetting)
-  val initialize = SettingKey[Unit]("initialize", "A convenience setting for performing side-effects during initialization.", BSetting)
-  val onLoad = SettingKey[State => State]("on-load", "Transformation to apply to the build state when the build is loaded.", DSetting)
-  val onUnload = SettingKey[State => State]("on-unload", "Transformation to apply to the build state when the build is unloaded.", DSetting)
-  val onLoadMessage = SettingKey[String]("on-load-message", "Message to display when the project is loaded.", DSetting)
-  val transformState = AttributeKey[State => State]("transform-state", "State transformation to apply after tasks run.", DSetting)
+  val autoGeneratedProject = settingKey[Boolean]("If it exists, represents that the project (and name) were automatically created, rather than user specified.").withRank(DSetting)
+  val projectCommand = AttributeKey[Boolean]("projectCommand", "Marks Commands that were registered for the current Project.", Invisible)
+  val sessionSettings = AttributeKey[SessionSettings]("sessionSettings", "Tracks current build, project, and setting modifications.", DSetting)
+  val stateBuildStructure = AttributeKey[BuildStructure]("stateBuildStructure", "Data structure containing all information about the build definition.", BSetting)
+  val buildStructure = taskKey[BuildStructure]("Provides access to the build structure, settings, and streams manager.").withRank(DTask)
+  val loadedBuild = settingKey[LoadedBuild]("Provides access to the loaded project structure.  This is the information available before settings are evaluated.").withRank(DSetting)
+  val buildDependencies = settingKey[BuildDependencies]("Definitive source of inter-project dependencies for compilation and dependency management.\n\tThis is populated by default by the dependencies declared on Project instances, but may be modified.\n\tThe main restriction is that new builds may not be introduced.").withRank(DSetting)
+  val appConfiguration = settingKey[xsbti.AppConfiguration]("Provides access to the launched sbt configuration, including the ScalaProvider, Launcher, and GlobalLock.").withRank(DSetting)
+  val thisProject = settingKey[ResolvedProject]("Provides the current project for the referencing scope.").withRank(CSetting)
+  val thisProjectRef = settingKey[ProjectRef]("Provides a fully-resolved reference to the current project for the referencing scope.").withRank(CSetting)
+  val configuration = settingKey[Configuration]("Provides the current configuration of the referencing scope.").withRank(CSetting)
+  val commands = settingKey[Seq[Command]]("Defines commands to be registered when this project or build is the current selected one.").withRank(CSetting)
+  val initialize = settingKey[Unit]("A convenience setting for performing side-effects during initialization.").withRank(BSetting)
+  val onLoad = settingKey[State => State]("Transformation to apply to the build state when the build is loaded.").withRank(DSetting)
+  val onUnload = settingKey[State => State]("Transformation to apply to the build state when the build is unloaded.").withRank(DSetting)
+  val onLoadMessage = settingKey[String]("Message to display when the project is loaded.").withRank(DSetting)
+  val transformState = AttributeKey[State => State]("transformState", "State transformation to apply after tasks run.", DSetting)
 
-  val onComplete = SettingKey[() => Unit]("on-complete", "Hook to run when task evaluation completes.  The type of this setting is subject to change, pending the resolution of SI-2915.", DSetting)
+  val onComplete = settingKey[() => Unit]("Hook to run when task evaluation completes.  The type of this setting is subject to change, pending the resolution of SI-2915.").withRank(DSetting)
 
   // Command keys
   val historyPath = SettingKey(BasicKeys.historyPath)
   val shellPrompt = SettingKey(BasicKeys.shellPrompt)
+  val colorShellPrompt = SettingKey(BasicKeys.colorShellPrompt)
+  val autoStartServer = SettingKey(BasicKeys.autoStartServer)
   val serverPort = SettingKey(BasicKeys.serverPort)
+  val serverHost = SettingKey(BasicKeys.serverHost)
+  val serverAuthentication = SettingKey(BasicKeys.serverAuthentication)
+  val serverConnectionType = SettingKey(BasicKeys.serverConnectionType)
+  val serverIdleTimeout = SettingKey(BasicKeys.serverIdleTimeout)
+  val windowsServerSecurityLevel = SettingKey(BasicKeys.windowsServerSecurityLevel)
+  val serverUseJni = SettingKey(BasicKeys.serverUseJni)
+  val fullServerHandlers = SettingKey(BasicKeys.fullServerHandlers)
+  val serverHandlers = settingKey[Seq[ServerHandler]]("User-defined server handlers.")
+
   val analysis = AttributeKey[CompileAnalysis]("analysis", "Analysis of compilation, including dependencies and generated outputs.", DSetting)
+  val suppressSbtShellNotification = settingKey[Boolean]("""True to suppress the "Executing in batch mode.." message.""").withRank(CSetting)
+  val pollInterval = settingKey[FiniteDuration]("Interval between checks for modified sources by the continuous execution command.").withRank(BMinusSetting)
+  val watchAntiEntropy = settingKey[FiniteDuration]("Duration for which the watch EventMonitor will ignore events for a file after that file has triggered a build.").withRank(BMinusSetting)
+  val watchService = settingKey[() => WatchService]("Service to use to monitor file system changes.").withRank(BMinusSetting).withRank(DSetting)
+
+  // Deprecated watch apis
+  @deprecated("This is no longer used for continuous execution", "1.3.0")
   val watch = SettingKey(BasicKeys.watch)
-  val pollInterval = SettingKey[Int]("poll-interval", "Interval between checks for modified sources by the continuous execution command.", BMinusSetting)
-  val watchSources = TaskKey[Seq[File]]("watch-sources", "Defines the sources in this project for continuous execution to watch for changes.", BMinusSetting)
-  val watchTransitiveSources = TaskKey[Seq[File]]("watch-transitive-sources", "Defines the sources in all projects for continuous execution to watch.", CSetting)
-  val watchingMessage = SettingKey[WatchState => String]("watching-message", "The message to show when triggered execution waits for sources to change.", DSetting)
-  val triggeredMessage = SettingKey[WatchState => String]("triggered-message", "The message to show before triggered execution executes an action after sources change.", DSetting)
+  val watchSources = taskKey[Seq[Watched.WatchSource]]("Defines the sources in this project for continuous execution to watch for changes.").withRank(BMinusSetting)
+  @deprecated("This is for legacy builds only and will be removed in a future version of sbt", "1.3.0")
+  val watchTransitiveSources = taskKey[Seq[Watched.WatchSource]]("Defines the sources in all projects for continuous execution to watch.").withRank(CSetting)
+  @deprecated("Use watchStartMessage instead", "1.3.0")
+  val watchingMessage = settingKey[WatchState => String]("The message to show when triggered execution waits for sources to change.").withRank(DSetting)
+  @deprecated("Use watchTriggeredMessage instead", "1.3.0")
+  val triggeredMessage = settingKey[WatchState => String]("The message to show before triggered execution executes an action after sources change.").withRank(DSetting)
 
   // Path Keys
-  val baseDirectory = SettingKey[File]("base-directory", "The base directory.  Depending on the scope, this is the base directory for the build, project, configuration, or task.", AMinusSetting)
-  val target = SettingKey[File]("target", "Main directory for files generated by the build.", AMinusSetting)
-  val crossTarget = SettingKey[File]("cross-target", "Main directory for files generated by the build that are cross-built.", BSetting)
+  val baseDirectory = settingKey[File]("The base directory.  Depending on the scope, this is the base directory for the build, project, configuration, or task.").withRank(AMinusSetting)
+  val target = settingKey[File]("Main directory for files generated by the build.").withRank(AMinusSetting)
+  val crossTarget = settingKey[File]("Main directory for files generated by the build that are cross-built.").withRank(BSetting)
 
   // Source paths
-  val sourceDirectory = SettingKey[File]("source-directory", "Default directory containing sources.", AMinusSetting)
-  val sourceManaged = SettingKey[File]("source-managed", "Default directory for sources generated by the build.", BPlusSetting)
-  val scalaSource = SettingKey[File]("scala-source", "Default Scala source directory.", ASetting)
-  val javaSource = SettingKey[File]("java-source", "Default Java source directory.", ASetting)
-  val sourceDirectories = SettingKey[Seq[File]]("source-directories", "List of all source directories, both managed and unmanaged.", AMinusSetting)
-  val unmanagedSourceDirectories = SettingKey[Seq[File]]("unmanaged-source-directories", "Unmanaged source directories, which contain manually created sources.", ASetting)
-  val unmanagedSources = TaskKey[Seq[File]]("unmanaged-sources", "Unmanaged sources, which are manually created.", BPlusTask)
-  val managedSourceDirectories = SettingKey[Seq[File]]("managed-source-directories", "Managed source directories, which contain sources generated by the build.", BSetting)
-  val managedSources = TaskKey[Seq[File]]("managed-sources", "Sources generated by the build.", BTask)
-  val sources = TaskKey[Seq[File]]("sources", "All sources, both managed and unmanaged.", BTask)
-  val sourcesInBase = SettingKey[Boolean]("sources-in-base", "If true, sources from the project's base directory are included as main sources.")
+  val sourceDirectory = settingKey[File]("Default directory containing sources.").withRank(AMinusSetting)
+  val sourceManaged = settingKey[File]("Default directory for sources generated by the build.").withRank(BPlusSetting)
+  val scalaSource = settingKey[File]("Default Scala source directory.").withRank(ASetting)
+  val javaSource = settingKey[File]("Default Java source directory.").withRank(ASetting)
+  val sourceDirectories = settingKey[Seq[File]]("List of all source directories, both managed and unmanaged.").withRank(AMinusSetting)
+  val unmanagedSourceDirectories = settingKey[Seq[File]]("Unmanaged source directories, which contain manually created sources.").withRank(ASetting)
+  val unmanagedSources = taskKey[Seq[File]]("Unmanaged sources, which are manually created.").withRank(BPlusTask)
+  val managedSourceDirectories = settingKey[Seq[File]]("Managed source directories, which contain sources generated by the build.").withRank(BSetting)
+  val managedSources = taskKey[Seq[File]]("Sources generated by the build.").withRank(BTask)
+  val sources = taskKey[Seq[File]]("All sources, both managed and unmanaged.").withRank(BTask)
+  val sourcesInBase = settingKey[Boolean]("If true, sources from the project's base directory are included as main sources.")
 
   // Filters
-  val includeFilter = SettingKey[FileFilter]("include-filter", "Filter for including sources and resources files from default directories.", CSetting)
-  val excludeFilter = SettingKey[FileFilter]("exclude-filter", "Filter for excluding sources and resources files from default directories.", CSetting)
+  val includeFilter = settingKey[FileFilter]("Filter for including sources and resources files from default directories.").withRank(CSetting)
+  val excludeFilter = settingKey[FileFilter]("Filter for excluding sources and resources files from default directories.").withRank(CSetting)
 
   // Resource paths
-  val resourceDirectory = SettingKey[File]("resource-directory", "Default unmanaged resource directory, used for user-defined resources.", ASetting)
-  val resourceManaged = SettingKey[File]("resource-managed", "Default managed resource directory, used when generating resources.", BSetting)
-  val unmanagedResourceDirectories = SettingKey[Seq[File]]("unmanaged-resource-directories", "Unmanaged resource directories, containing resources manually created by the user.", AMinusSetting)
-  val unmanagedResources = TaskKey[Seq[File]]("unmanaged-resources", "Unmanaged resources, which are manually created.", BPlusTask)
-  val managedResourceDirectories = SettingKey[Seq[File]]("managed-resource-directories", "List of managed resource directories.", AMinusSetting)
-  val managedResources = TaskKey[Seq[File]]("managed-resources", "Resources generated by the build.", BTask)
-  val resourceDirectories = SettingKey[Seq[File]]("resource-directories", "List of all resource directories, both managed and unmanaged.", BPlusSetting)
-  val resources = TaskKey[Seq[File]]("resources", "All resource files, both managed and unmanaged.", BTask)
+  val resourceDirectory = settingKey[File]("Default unmanaged resource directory, used for user-defined resources.").withRank(ASetting)
+  val resourceManaged = settingKey[File]("Default managed resource directory, used when generating resources.").withRank(BSetting)
+  val unmanagedResourceDirectories = settingKey[Seq[File]]("Unmanaged resource directories, containing resources manually created by the user.").withRank(AMinusSetting)
+  val unmanagedResources = taskKey[Seq[File]]("Unmanaged resources, which are manually created.").withRank(BPlusTask)
+  val managedResourceDirectories = settingKey[Seq[File]]("List of managed resource directories.").withRank(AMinusSetting)
+  val managedResources = taskKey[Seq[File]]("Resources generated by the build.").withRank(BTask)
+  val resourceDirectories = settingKey[Seq[File]]("List of all resource directories, both managed and unmanaged.").withRank(BPlusSetting)
+  val resources = taskKey[Seq[File]]("All resource files, both managed and unmanaged.").withRank(BTask)
 
   // Output paths
-  val classDirectory = SettingKey[File]("class-directory", "Directory for compiled classes and copied resources.", AMinusSetting)
-  val cleanFiles = SettingKey[Seq[File]]("clean-files", "The files to recursively delete during a clean.", BSetting)
-  val cleanKeepFiles = SettingKey[Seq[File]]("clean-keep-files", "Files to keep during a clean.", CSetting)
-  val crossPaths = SettingKey[Boolean]("cross-paths", "If true, enables cross paths, which distinguish input and output directories for cross-building.", ASetting)
-  val taskTemporaryDirectory = SettingKey[File]("task-temporary-directory", "Directory used for temporary files for tasks that is deleted after each task execution.", DSetting)
+  val classDirectory = settingKey[File]("Directory for compiled classes and copied resources.").withRank(AMinusSetting)
+  val earlyOutput = settingKey[VirtualFile]("JAR file for pickles used for build pipelining")
+  val backendOutput = settingKey[VirtualFile]("Directory or JAR file for compiled classes and copied resources")
+  val cleanFiles = taskKey[Seq[File]]("The files to recursively delete during a clean.").withRank(BSetting)
+  val cleanKeepFiles = settingKey[Seq[File]]("Files or directories to keep during a clean. Must be direct children of target.").withRank(CSetting)
+  val cleanKeepGlobs = settingKey[Seq[Glob]]("Globs to keep during a clean. Must be direct children of target.").withRank(CSetting)
+  val crossPaths = settingKey[Boolean]("If true, enables cross paths, which distinguish input and output directories for cross-building.").withRank(ASetting)
+  val taskTemporaryDirectory = settingKey[File]("Directory used for temporary files for tasks that is deleted after each task execution.").withRank(DSetting)
 
   // Generators
-  val sourceGenerators = SettingKey[Seq[Task[Seq[File]]]]("source-generators", "List of tasks that generate sources.", CSetting)
-  val resourceGenerators = SettingKey[Seq[Task[Seq[File]]]]("resource-generators", "List of tasks that generate resources.", CSetting)
+  val sourceGenerators = settingKey[Seq[Task[Seq[File]]]]("List of tasks that generate sources.").withRank(CSetting)
+  val resourceGenerators = settingKey[Seq[Task[Seq[File]]]]("List of tasks that generate resources.").withRank(CSetting)
 
   // compile/doc keys
-  val autoCompilerPlugins = SettingKey[Boolean]("auto-compiler-plugins", "If true, enables automatically generating -Xplugin arguments to the compiler based on the classpath for the " + CompilerPlugin.name + " configuration.", AMinusSetting)
-  val maxErrors = SettingKey[Int]("max-errors", "The maximum number of errors, such as compile errors, to list.", ASetting)
-  val scalacOptions = TaskKey[Seq[String]]("scalac-options", "Options for the Scala compiler.", BPlusTask)
-  val javacOptions = TaskKey[Seq[String]]("javac-options", "Options for the Java compiler.", BPlusTask)
-  val incOptions = TaskKey[IncOptions]("inc-options", "Options for the incremental compiler.", BTask)
-  val compileOrder = SettingKey[CompileOrder]("compile-order", "Configures the order in which Java and sources within a single compilation are compiled.  Valid values are: JavaThenScala, ScalaThenJava, or Mixed.", BPlusSetting)
-  val initialCommands = SettingKey[String]("initial-commands", "Initial commands to execute when starting up the Scala interpreter.", AMinusSetting)
-  val cleanupCommands = SettingKey[String]("cleanup-commands", "Commands to execute before the Scala interpreter exits.", BMinusSetting)
-  val compileOptions = TaskKey[CompileOptions]("compile-options", "Collects basic options to configure compilers", DTask)
-  val compileInputs = TaskKey[Inputs]("compile-inputs", "Collects all inputs needed for compilation.", DTask)
-  val scalaHome = SettingKey[Option[File]]("scala-home", "If Some, defines the local Scala installation to use for compilation, running, and testing.", ASetting)
-  val scalaInstance = TaskKey[ScalaInstance]("scala-instance", "Defines the Scala instance to use for compilation, running, and testing.", DTask)
-  val scalaOrganization = SettingKey[String]("scala-organization", "Organization/group ID of the Scala used in the project. Default value is 'org.scala-lang'. This is an advanced setting used for clones of the Scala Language. It should be disregarded in standard use cases.", CSetting)
-  val scalaVersion = SettingKey[String]("scala-version", "The version of Scala used for building.", APlusSetting)
-  val scalaBinaryVersion = SettingKey[String]("scala-binary-version", "The Scala version substring describing binary compatibility.", BPlusSetting)
-  val crossScalaVersions = SettingKey[Seq[String]]("cross-scala-versions", "The versions of Scala used when cross-building.", BPlusSetting)
-  val crossVersion = SettingKey[CrossVersion]("cross-version", "Configures handling of the Scala version when cross-building.", CSetting)
-  val classpathOptions = SettingKey[ClasspathOptions]("classpath-options", "Configures handling of Scala classpaths.", DSetting)
-  val discoveredSbtPlugins = TaskKey[PluginDiscovery.DiscoveredNames]("discovered-sbt-plugins", "The names of sbt plugin-related modules (modules that extend Build, Plugin, AutoPlugin) defined by this project.", CTask)
-  val sbtPlugin = SettingKey[Boolean]("sbt-plugin", "If true, enables adding sbt as a dependency and auto-generation of the plugin descriptor file.", BMinusSetting)
-  val printWarnings = TaskKey[Unit]("print-warnings", "Shows warnings from compilation, including ones that weren't printed initially.", BPlusTask)
-  val fileInputOptions = SettingKey[Seq[String]]("file-input-options", "Options that take file input, which may invalidate the cache.", CSetting)
-  val scalaCompilerBridgeSource = SettingKey[ModuleID]("scala-compiler-bridge-source", "Configures the module ID of the sources of the compiler bridge.", CSetting)
+  val autoCompilerPlugins = settingKey[Boolean]("If true, enables automatically generating -Xplugin arguments to the compiler based on the classpath for the " + CompilerPlugin.name + " configuration.").withRank(AMinusSetting)
+  val maxErrors = settingKey[Int]("The maximum number of errors, such as compile errors, to list.").withRank(ASetting)
+  val scalacOptions = taskKey[Seq[String]]("Options for the Scala compiler.").withRank(BPlusTask)
+  val javacOptions = taskKey[Seq[String]]("Options for the Java compiler.").withRank(BPlusTask)
+  val incOptions = taskKey[IncOptions]("Options for the incremental compiler.").withRank(BTask)
+  val extraIncOptions = taskKey[Seq[(String, String)]]("Extra options for the incremental compiler").withRank(CTask)
+  val compileOrder = settingKey[CompileOrder]("Configures the order in which Java and sources within a single compilation are compiled.  Valid values are: JavaThenScala, ScalaThenJava, or Mixed.").withRank(BPlusSetting)
+  val initialCommands = settingKey[String]("Initial commands to execute when starting up the Scala interpreter.").withRank(AMinusSetting)
+  val cleanupCommands = settingKey[String]("Commands to execute before the Scala interpreter exits.").withRank(BMinusSetting)
+  val asciiGraphWidth = settingKey[Int]("Determines maximum width of the settings graph in ASCII mode").withRank(AMinusSetting)
+  val compileOptions = taskKey[CompileOptions]("Collects basic options to configure compilers").withRank(DTask)
+  val compileInputs = taskKey[Inputs]("Collects all inputs needed for compilation.").withRank(DTask)
+  val scalaHome = settingKey[Option[File]]("If Some, defines the local Scala installation to use for compilation, running, and testing.").withRank(ASetting)
+  val scalaInstance = taskKey[ScalaInstance]("Defines the Scala instance to use for compilation, running, and testing.").withRank(DTask)
+  val scalaOrganization = settingKey[String]("Organization/group ID of the Scala used in the project. Default value is 'org.scala-lang'. This is an advanced setting used for clones of the Scala Language. It should be disregarded in standard use cases.").withRank(CSetting)
+  val scalaVersion = settingKey[String]("The version of Scala used for building.").withRank(APlusSetting)
+  val scalaBinaryVersion = settingKey[String]("The Scala version substring describing binary compatibility.").withRank(BPlusSetting)
+  val crossScalaVersions = settingKey[Seq[String]]("The versions of Scala used when cross-building.").withRank(BPlusSetting)
+  val crossVersion = settingKey[CrossVersion]("Configures handling of the Scala version when cross-building.").withRank(CSetting)
+  val classpathOptions = settingKey[ClasspathOptions]("Configures handling of Scala classpaths.").withRank(DSetting)
+  val discoveredSbtPlugins = taskKey[PluginDiscovery.DiscoveredNames]("The names of sbt plugin-related modules (modules that extend Build, Plugin, AutoPlugin) defined by this project.").withRank(CTask)
+  val sbtPlugin = settingKey[Boolean]("If true, enables adding sbt as a dependency and auto-generation of the plugin descriptor file.").withRank(BMinusSetting)
+  val isMetaBuild = settingKey[Boolean]("If true, this is a metabuild, a project inside project/ directory, and sbt is added to the classpath.").withRank(DSetting)
+  val reresolveSbtArtifacts = settingKey[Boolean]("If true, include sbt into the metabuild dependency graph. Otherwise reuse the artifacts resolved by the launcher on startup.").withRank(DSetting)
+  val pluginCrossBuild = taskKey[Unit]("Dummy task to scope `sbtVersion in pluginCrossBuild`, which gets used for plugin compilation.")
+  val crossSbtVersions = settingKey[Seq[String]]("The versions of Sbt used when cross-building an sbt plugin.")
+  val printWarnings = taskKey[Unit]("Shows warnings from compilation, including ones that weren't printed initially.").withRank(BPlusTask)
+  val fileInputOptions = settingKey[Seq[String]]("Options that take file input, which may invalidate the cache.").withRank(CSetting)
+  val scalaCompilerBridgeBinaryJar = taskKey[Option[File]]("Optionally, the jar of the compiler bridge. When not None, this takes precedence over scalaCompilerBridgeSource").withRank(CSetting)
+  val scalaCompilerBridgeSource = settingKey[ModuleID]("Configures the module ID of the sources of the compiler bridge when scalaCompilerBridgeBinaryJar is None").withRank(CSetting)
+  val scalaCompilerBridgeScope = taskKey[Unit]("The compiler bridge scope.").withRank(DTask)
+  val scalaArtifacts = settingKey[Seq[String]]("Configures the list of artifacts which should match the Scala binary version").withRank(CSetting)
+  val enableBinaryCompileAnalysis = settingKey[Boolean]("Writes the analysis file in binary format")
+  val crossJavaVersions = settingKey[Seq[String]]("The java versions used during JDK cross testing").withRank(BPlusSetting)
+  val semanticdbEnabled = settingKey[Boolean]("Enables SemanticDB Scalac plugin").withRank(CSetting)
+  val semanticdbCompilerPlugin = settingKey[ModuleID]("SemanticDB Scalac plugin").withRank(CSetting)
+  val semanticdbVersion = settingKey[String]("SemanticDB version").withRank(CSetting)
+  val semanticdbIncludeInJar = settingKey[Boolean]("Include *.semanticdb files in published artifacts").withRank(CSetting)
+  val semanticdbTargetRoot = settingKey[File]("The output directory to produce META-INF/semanticdb/**/*.semanticdb files").withRank(CSetting)
+  val semanticdbOptions = settingKey[Seq[String]]("The Scalac options introduced for SemanticDB").withRank(CSetting)
 
-  val clean = TaskKey[Unit]("clean", "Deletes files produced by the build, such as generated sources, compiled classes, and task caches.", APlusTask)
-  val console = TaskKey[Unit]("console", "Starts the Scala interpreter with the project classes on the classpath.", APlusTask)
-  val consoleQuick = TaskKey[Unit]("console-quick", "Starts the Scala interpreter with the project dependencies on the classpath.", ATask, console)
-  val consoleProject = TaskKey[Unit]("console-project", "Starts the Scala interpreter with the sbt and the build definition on the classpath and useful imports.", AMinusTask)
-  val compile = TaskKey[CompileAnalysis]("compile", "Compiles sources.", APlusTask)
-  val manipulateBytecode = TaskKey[CompileResult]("manipulateBytecode", "Manipulates generated bytecode", BTask)
-  val compileIncremental = TaskKey[CompileResult]("compileIncremental", "Actually runs the incremental compilation", DTask)
-  val previousCompile = TaskKey[PreviousResult]("readAnalysis", "Read the incremental compiler analysis from disk", DTask)
-  val compilers = TaskKey[Compilers]("compilers", "Defines the Scala and Java compilers to use for compilation.", DTask)
-  val compileAnalysisFilename = TaskKey[String]("compileAnalysisFilename", "Defines the filename used to store the incremental compiler analysis file (inside the streams cacheDirectory).", DTask)
-  val compileIncSetup = TaskKey[Setup]("inc-compile-setup", "Configures aspects of incremental compilation.", DTask)
-  val compilerCache = TaskKey[GlobalsCache]("compiler-cache", "Cache of scala.tools.nsc.Global instances.  This should typically be cached so that it isn't recreated every task run.", DTask)
-  val stateCompilerCache = AttributeKey[GlobalsCache]("compiler-cache", "Internal use: Global cache.")
-  val classpathEntryDefinesClass = TaskKey[File => DefinesClass]("classpath-entry-defines-class", "Internal use: provides a function that determines whether the provided file contains a given class.", Invisible)
-  val doc = TaskKey[File]("doc", "Generates API documentation.", AMinusTask)
-  val copyResources = TaskKey[Seq[(File, File)]]("copy-resources", "Copies resources to the output directory.", AMinusTask)
-  val aggregate = SettingKey[Boolean]("aggregate", "Configures task aggregation.", BMinusSetting)
-  val sourcePositionMappers = TaskKey[Seq[xsbti.Position => Option[xsbti.Position]]]("source-position-mappers", "Maps positions in generated source files to the original source it was generated from", DTask)
+  val clean = taskKey[Unit]("Deletes files produced by the build, such as generated sources, compiled classes, and task caches.").withRank(APlusTask)
+  private[sbt] val cleanIvy = taskKey[Unit]("Deletes the ivy cached resolution")
+  val console = taskKey[Unit]("Starts the Scala interpreter with the project classes on the classpath.").withRank(APlusTask)
+  val consoleQuick = TaskKey[Unit]("consoleQuick", "Starts the Scala interpreter with the project dependencies on the classpath.", ATask, console)
+  val consoleProject = taskKey[Unit]("Starts the Scala interpreter with the sbt and the build definition on the classpath and useful imports.").withRank(AMinusTask)
+  val compile = taskKey[CompileAnalysis]("Compiles sources.").withRank(APlusTask)
+  val manipulateBytecode = taskKey[CompileResult]("Manipulates generated bytecode").withRank(BTask)
+  val compileIncremental = taskKey[CompileResult]("Actually runs the incremental compilation").withRank(DTask)
+  val previousCompile = taskKey[PreviousResult]("Read the incremental compiler analysis from disk").withRank(DTask)
+  val tastyFiles = taskKey[Seq[File]]("Returns the TASTy files produced by compilation").withRank(DTask)
+  private[sbt] val compileScalaBackend = taskKey[CompileResult]("Compiles only Scala sources if pipelining is enabled. Compiles both Scala and Java sources otherwise").withRank(Invisible)
+  private[sbt] val compileEarly = taskKey[CompileAnalysis]("Compiles only Scala sources if pipelining is enabled, and produce an early output (pickle JAR)").withRank(Invisible)
+  private[sbt] val earlyOutputPing = taskKey[PromiseWrap[Boolean]]("When pipelining is enabled, this returns true when early output (pickle JAR) is created; false otherwise").withRank(Invisible)
+  private[sbt] val compileJava = taskKey[CompileResult]("Compiles only Java sources (called only for pipelining)").withRank(Invisible)
+  private[sbt] val compileSplit = taskKey[CompileResult]("When pipelining is enabled, compile Scala then Java; otherwise compile both").withRank(Invisible)
+
+  val compileProgress = taskKey[CompileProgress]("Callback used by the compiler to report phase progress")
+  val compilers = taskKey[Compilers]("Defines the Scala and Java compilers to use for compilation.").withRank(DTask)
+  val compileAnalysisFilename = taskKey[String]("Defines the filename used for compileAnalysisFile.").withRank(DTask)
+  val compileAnalysisTargetRoot = settingKey[File]("The output directory to produce Zinc Analysis files").withRank(DSetting)
+  val earlyCompileAnalysisTargetRoot = settingKey[File]("The output directory to produce Zinc Analysis files").withRank(DSetting)
+  val compileAnalysisFile = taskKey[File]("Zinc analysis storage.").withRank(DSetting)
+  val earlyCompileAnalysisFile = taskKey[File]("Zinc analysis storage for early compilation").withRank(DSetting)
+  val compileIncSetup = taskKey[Setup]("Configures aspects of incremental compilation.").withRank(DTask)
+  val compilerCache = taskKey[GlobalsCache]("Cache of scala.tools.nsc.Global instances.  This should typically be cached so that it isn't recreated every task run.").withRank(DTask)
+  val stateCompilerCache = AttributeKey[GlobalsCache]("stateCompilerCache", "Internal use: Global cache.")
+  val classpathEntryDefinesClass = taskKey[File => DefinesClass]("Internal use: provides a function that determines whether the provided file contains a given class.").withRank(Invisible)
+  private[sbt] val classpathDefinesClassCache = settingKey[VirtualFileValueCache[DefinesClass]]("Internal use: a cache of jar classpath entries that persists across command evaluations.").withRank(Invisible)
+  val persistJarClasspath = settingKey[Boolean]("Toggles whether or not to cache jar classpath entries between command evaluations")
+  val classpathEntryDefinesClassVF = taskKey[VirtualFile => DefinesClass]("Internal use: provides a function that determines whether the provided file contains a given class.").withRank(Invisible)
+  val doc = taskKey[File]("Generates API documentation.").withRank(AMinusTask)
+  val copyResources = taskKey[Seq[(File, File)]]("Copies resources to the output directory.").withRank(AMinusTask)
+  val aggregate = settingKey[Boolean]("Configures task aggregation.").withRank(BMinusSetting)
+  val sourcePositionMappers = taskKey[Seq[xsbti.Position => Option[xsbti.Position]]]("Maps positions in generated source files to the original source it was generated from").withRank(DTask)
+  private[sbt] val externalHooks = taskKey[ExternalHooks]("The external hooks used by zinc.")
+  val auxiliaryClassFiles = taskKey[Seq[AuxiliaryClassFiles]]("The auxiliary class files that must be managed by Zinc (for instance the TASTy files)")
+  val fileConverter = settingKey[FileConverter]("The file converter used to convert between Path and VirtualFile")
+  val allowMachinePath = settingKey[Boolean]("Allow machine-specific paths during conversion.")
+  val reportAbsolutePath = settingKey[Boolean]("Report absolute paths during compilation.")
+  val rootPaths = settingKey[Map[String, NioPath]]("The root paths used to abstract machine-specific paths.")
+  private[sbt] val timeWrappedStamper = settingKey[ReadStamps]("The stamper to create timestamp or hash.")
+  private[sbt] val reusableStamper = taskKey[ReadStamps]("The stamper can be reused across subprojects and sessions.")
 
   // package keys
-  val packageBin = TaskKey[File]("package-bin", "Produces a main artifact, such as a binary jar.", ATask)
-  val `package` = TaskKey[File]("package", "Produces the main artifact, such as a binary jar.  This is typically an alias for the task that actually does the packaging.", APlusTask)
-  val packageDoc = TaskKey[File]("package-doc", "Produces a documentation artifact, such as a jar containing API documentation.", AMinusTask)
-  val packageSrc = TaskKey[File]("package-src", "Produces a source artifact, such as a jar containing sources and resources.", AMinusTask)
+  val packageBin = taskKey[File]("Produces a main artifact, such as a binary jar.").withRank(ATask)
+  val `package` = taskKey[File]("Produces the main artifact, such as a binary jar.  This is typically an alias for the task that actually does the packaging.").withRank(APlusTask)
+  val packageDoc = taskKey[File]("Produces a documentation artifact, such as a jar containing API documentation.").withRank(AMinusTask)
+  val packageSrc = taskKey[File]("Produces a source artifact, such as a jar containing sources and resources.").withRank(AMinusTask)
+  val packageCache = taskKey[File]("Produces the main artifact for caching.")
 
-  val packageOptions = TaskKey[Seq[PackageOption]]("package-options", "Options for packaging.", BTask)
-  val packageConfiguration = TaskKey[Package.Configuration]("package-configuration", "Collects all inputs needed for packaging.", DTask)
-  val artifactPath = SettingKey[File]("artifact-path", "The location of a generated artifact.", BPlusSetting)
-  val artifact = SettingKey[Artifact]("artifact", "Describes an artifact.", BMinusSetting)
-  val artifactClassifier = SettingKey[Option[String]]("artifact-classifier", "Sets the classifier used by the default artifact definition.", BSetting)
-  val artifactName = SettingKey[(ScalaVersion, ModuleID, Artifact) => String]("artifact-name", "Function that produces the artifact name from its definition.", CSetting)
-  val mappings = TaskKey[Seq[(File, String)]]("mappings", "Defines the mappings from a file to a path, used by packaging, for example.", BTask)
-  val fileMappings = TaskKey[Seq[(File, File)]]("file-mappings", "Defines the mappings from a file to a file, used for copying files, for example.", BMinusTask)
+  val packageOptions = taskKey[Seq[PackageOption]]("Options for packaging.").withRank(BTask)
+  val packageTimestamp = settingKey[Option[Long]]("Overwrites timestamps in JAR file to make the build reproducible; None keeps the existing timestamps (useful for web resources)").withRank(CSetting)
+  val packageConfiguration = taskKey[Package.Configuration]("Collects all inputs needed for packaging.").withRank(DTask)
+  val artifactPath = settingKey[File]("The location of a generated artifact.").withRank(BPlusSetting)
+  val artifact = settingKey[Artifact]("Describes an artifact.").withRank(BMinusSetting)
+  val artifactClassifier = settingKey[Option[String]]("Sets the classifier used by the default artifact definition.").withRank(BSetting)
+  val artifactName = settingKey[(ScalaVersion, ModuleID, Artifact) => String]("Function that produces the artifact name from its definition.").withRank(CSetting)
+  val mappings = taskKey[Seq[(File, String)]]("Defines the mappings from a file to a path, used by packaging, for example.").withRank(BTask)
+  val fileMappings = taskKey[Seq[(File, File)]]("Defines the mappings from a file to a file, used for copying files, for example.").withRank(BMinusTask)
 
   // Run Keys
-  val selectMainClass = TaskKey[Option[String]]("select-main-class", "Selects the main class to run.", BMinusTask)
-  val mainClass = TaskKey[Option[String]]("main-class", "Defines the main class for packaging or running.", BPlusTask)
-  val run = InputKey[Unit]("run", "Runs a main class, passing along arguments provided on the command line.", APlusTask)
-  val runMain = InputKey[Unit]("run-main", "Runs the main class selected by the first argument, passing the remaining arguments to the main method.", ATask)
-  val discoveredMainClasses = TaskKey[Seq[String]]("discovered-main-classes", "Auto-detects main classes.", BMinusTask)
-  val runner = TaskKey[ScalaRun]("runner", "Implementation used to run a main class.", DTask)
-  val trapExit = SettingKey[Boolean]("trap-exit", "If true, enables exit trapping and thread management for 'run'-like tasks.  This is currently only suitable for serially-executed 'run'-like tasks.", CSetting)
+  val selectMainClass = taskKey[Option[String]]("Selects the main class to run.").withRank(BMinusTask)
+  val mainClass = taskKey[Option[String]]("Defines the main class for packaging or running.").withRank(BPlusTask)
+  val run = inputKey[Unit]("Runs a main class, passing along arguments provided on the command line.").withRank(APlusTask)
+  val runMain = inputKey[Unit]("Runs the main class selected by the first argument, passing the remaining arguments to the main method.").withRank(ATask)
+  val discoveredMainClasses = taskKey[Seq[String]]("Auto-detects main classes.").withRank(BMinusTask)
+  val runner = taskKey[ScalaRun]("Implementation used to run a main class.").withRank(DTask)
+  val trapExit = settingKey[Boolean]("If true, enables exit trapping and thread management for 'run'-like tasks.  This is currently only suitable for serially-executed 'run'-like tasks.").withRank(CSetting)
 
-  val fork = SettingKey[Boolean]("fork", "If true, forks a new JVM when running.  If false, runs in the same JVM as the build.", ASetting)
-  val outputStrategy = SettingKey[Option[sbt.OutputStrategy]]("output-strategy", "Selects how to log output when running a main class.", DSetting)
-  val connectInput = SettingKey[Boolean]("connect-input", "If true, connects standard input when running a main class forked.", CSetting)
-  val javaHome = SettingKey[Option[File]]("java-home", "Selects the Java installation used for compiling and forking.  If None, uses the Java installation running the build.", ASetting)
-  val javaOptions = TaskKey[Seq[String]]("java-options", "Options passed to a new JVM when forking.", BPlusTask)
-  val envVars = TaskKey[Map[String, String]]("envVars", "Environment variables used when forking a new JVM", BTask)
+  val fork = settingKey[Boolean]("If true, forks a new JVM when running.  If false, runs in the same JVM as the build.").withRank(ASetting)
+  val forkOptions = taskKey[ForkOptions]("Configures JVM forking.").withRank(DSetting)
+  val outputStrategy = settingKey[Option[sbt.OutputStrategy]]("Selects how to log output when running a main class.").withRank(DSetting)
+  val connectInput = settingKey[Boolean]("If true, connects standard input when running a main class forked.").withRank(CSetting)
+  val javaHome = settingKey[Option[File]]("Selects the Java installation used for compiling and forking.  If None, uses the Java installation running the build.").withRank(ASetting)
+  val discoveredJavaHomes = settingKey[Map[String, File]]("Discovered Java home directories")
+  val javaHomes = settingKey[Map[String, File]]("The user-defined additional Java home directories")
+  val fullJavaHomes = settingKey[Map[String, File]]("Combines discoveredJavaHomes and custom javaHomes.").withRank(CTask)
+
+  val javaOptions = taskKey[Seq[String]]("Options passed to a new JVM when forking.").withRank(BPlusTask)
+  val envVars = taskKey[Map[String, String]]("Environment variables used when forking a new JVM").withRank(BTask)
+
+  val bgJobServiceDirectory = settingKey[File]("The directory for temporary files used by background jobs.")
+  val bgJobService = settingKey[BackgroundJobService]("Job manager used to run background jobs.")
+  val bgList = taskKey[Seq[JobHandle]]("List running background jobs.")
+  val ps = taskKey[Seq[JobHandle]]("bgList variant that displays on the log.")
+  val bgStop = inputKey[Unit]("Stop a background job by providing its ID.")
+  val bgWaitFor = inputKey[Unit]("Wait for a background job to finish by providing its ID.")
+  val bgRun = inputKey[JobHandle]("Start an application's default main class as a background job")
+  val fgRun = inputKey[Unit]("Start an application's default main class as a foreground job")
+  val bgRunMain = inputKey[JobHandle]("Start a provided main class as a background job")
+  val fgRunMain = inputKey[Unit]("Start a provided main class as a foreground job")
+  val bgCopyClasspath = settingKey[Boolean]("Copies classpath on bgRun to prevent conflict.")
+  val bgHashClasspath = settingKey[Boolean]("Toggles whether to use a hash or the last modified time to stamp the classpath jars")
+  val classLoaderLayeringStrategy = settingKey[ClassLoaderLayeringStrategy]("Creates the classloader layering strategy for the particular configuration.")
 
   // Test Keys
-  val testLoader = TaskKey[ClassLoader]("test-loader", "Provides the class loader used for testing.", DTask)
-  val loadedTestFrameworks = TaskKey[Map[TestFramework, Framework]]("loaded-test-frameworks", "Loads Framework definitions from the test loader.", DTask)
-  val definedTests = TaskKey[Seq[TestDefinition]]("defined-tests", "Provides the list of defined tests.", BMinusTask)
-  val definedTestNames = TaskKey[Seq[String]]("defined-test-names", "Provides the set of defined test names.", BMinusTask)
-  val executeTests = TaskKey[Tests.Output]("execute-tests", "Executes all tests, producing a report.", CTask)
-  val test = TaskKey[Unit]("test", "Executes all tests.", APlusTask)
-  val testOnly = InputKey[Unit]("test-only", "Executes the tests provided as arguments or all tests if no arguments are provided.", ATask)
-  val testQuick = InputKey[Unit]("test-quick", "Executes the tests that either failed before, were not run or whose transitive dependencies changed, among those provided as arguments.", ATask)
-  val testOptions = TaskKey[Seq[TestOption]]("test-options", "Options for running tests.", BPlusTask)
-  val testFrameworks = SettingKey[Seq[TestFramework]]("test-frameworks", "Registered, although not necessarily present, test frameworks.", CTask)
-  val testListeners = TaskKey[Seq[TestReportListener]]("test-listeners", "Defines test listeners.", DTask)
-  val testForkedParallel = SettingKey[Boolean]("test-forked-parallel", "Whether forked tests should be executed in parallel", CTask)
-  val testExecution = TaskKey[Tests.Execution]("test-execution", "Settings controlling test execution", DTask)
-  val testFilter = TaskKey[Seq[String] => Seq[String => Boolean]]("test-filter", "Filter controlling whether the test is executed", DTask)
-  val testResultLogger = SettingKey[TestResultLogger]("test-result-logger", "Logs results after a test task completes.", DTask)
-  val testGrouping = TaskKey[Seq[Tests.Group]]("test-grouping", "Collects discovered tests into groups. Whether to fork and the options for forking are configurable on a per-group basis.", BMinusTask)
-  val isModule = AttributeKey[Boolean]("is-module", "True if the target is a module.", DSetting)
+  val testLoader = taskKey[ClassLoader]("Provides the class loader used for testing.").withRank(DTask)
+  val loadedTestFrameworks = taskKey[Map[TestFramework, Framework]]("Loads Framework definitions from the test loader.").withRank(DTask)
+  val definedTests = taskKey[Seq[TestDefinition]]("Provides the list of defined tests.").withRank(BMinusTask)
+  val definedTestNames = taskKey[Seq[String]]("Provides the set of defined test names.").withRank(BMinusTask)
+  val executeTests = taskKey[Tests.Output]("Executes all tests, producing a report.").withRank(CTask)
+  val test = taskKey[Unit]("Executes all tests.").withRank(APlusTask)
+  val testOnly = inputKey[Unit]("Executes the tests provided as arguments or all tests if no arguments are provided.").withRank(ATask)
+  val testQuick = inputKey[Unit]("Executes the tests that either failed before, were not run or whose transitive dependencies changed, among those provided as arguments.").withRank(ATask)
+  val testOptions = taskKey[Seq[TestOption]]("Options for running tests.").withRank(BPlusTask)
+  val testFrameworks = settingKey[Seq[TestFramework]]("Registered, although not necessarily present, test frameworks.").withRank(CTask)
+  val testListeners = taskKey[Seq[TestReportListener]]("Defines test listeners.").withRank(DTask)
+  val testForkedParallel = settingKey[Boolean]("Whether forked tests should be executed in parallel").withRank(CTask)
+  val testExecution = taskKey[Tests.Execution]("Settings controlling test execution").withRank(DTask)
+  val testFilter = taskKey[Seq[String] => Seq[String => Boolean]]("Filter controlling whether the test is executed").withRank(DTask)
+  val testResultLogger = settingKey[TestResultLogger]("Logs results after a test task completes.").withRank(DTask)
+  val testGrouping = taskKey[Seq[Tests.Group]]("Collects discovered tests into groups. Whether to fork and the options for forking are configurable on a per-group basis.").withRank(BMinusTask)
+  val isModule = AttributeKey[Boolean]("isModule", "True if the target is a module.", DSetting)
 
   // Classpath/Dependency Management Keys
   type Classpath = Def.Classpath
+  type VirtualClasspath = Def.VirtualClasspath
 
-  val name = SettingKey[String]("name", "Project name.", APlusSetting)
-  val normalizedName = SettingKey[String]("normalized-name", "Project name transformed from mixed case and spaces to lowercase and dash-separated.", BSetting)
-  val description = SettingKey[String]("description", "Project description.", BSetting)
-  val homepage = SettingKey[Option[URL]]("homepage", "Project homepage.", BSetting)
-  val startYear = SettingKey[Option[Int]]("start-year", "Year in which the project started.", BMinusSetting)
-  val licenses = SettingKey[Seq[(String, URL)]]("licenses", "Project licenses as (name, url) pairs.", BMinusSetting)
-  val organization = SettingKey[String]("organization", "Organization/group ID.", APlusSetting)
-  val organizationName = SettingKey[String]("organization-name", "Organization full/formal name.", BMinusSetting)
-  val organizationHomepage = SettingKey[Option[URL]]("organization-homepage", "Organization homepage.", BMinusSetting)
-  val developers = SettingKey[List[Developer]]("developers", "List of developers implicated in the project", BMinusSetting)
-  val apiURL = SettingKey[Option[URL]]("api-url", "Base URL for API documentation.", BMinusSetting)
-  val entryApiURL = AttributeKey[URL]("entry-api-url", "Base URL for the API documentation for a classpath entry.")
-  val apiMappings = TaskKey[Map[File, URL]]("api-mappings", "Mappings from classpath entry to API documentation base URL.", BMinusSetting)
-  val autoAPIMappings = SettingKey[Boolean]("auto-api-mappings", "If true, automatically manages mappings to the API doc URL.", BMinusSetting)
-  val scmInfo = SettingKey[Option[ScmInfo]]("scm-info", "Basic SCM information for the project.", BMinusSetting)
-  val projectInfo = SettingKey[ModuleInfo]("project-info", "Addition project information like formal name, homepage, licenses etc.", CSetting)
-  val defaultConfiguration = SettingKey[Option[Configuration]]("default-configuration", "Defines the configuration used when none is specified for a dependency in ivyXML.", CSetting)
+  val name = settingKey[String]("Project name.").withRank(APlusSetting)
+  val normalizedName = settingKey[String]("Project name transformed from mixed case and spaces to lowercase and dash-separated.").withRank(BSetting)
+  val description = settingKey[String]("Project description.").withRank(BSetting)
+  val homepage = settingKey[Option[URL]]("Project homepage.").withRank(BSetting)
+  val startYear = settingKey[Option[Int]]("Year in which the project started.").withRank(BMinusSetting)
+  val licenses = settingKey[Seq[(String, URL)]]("Project licenses as (name, url) pairs.").withRank(BMinusSetting)
+  val organization = settingKey[String]("Organization/group ID.").withRank(APlusSetting)
+  val organizationName = settingKey[String]("Organization full/formal name.").withRank(BMinusSetting)
+  val organizationHomepage = settingKey[Option[URL]]("Organization homepage.").withRank(BMinusSetting)
+  val developers = settingKey[List[Developer]]("List of developers implicated in the project").withRank(BMinusSetting)
+  val apiURL = settingKey[Option[URL]]("Base URL for API documentation.").withRank(BMinusSetting)
+  val entryApiURL = AttributeKey[URL]("entryApiURL", "Base URL for the API documentation for a classpath entry.")
+  val apiMappings = taskKey[Map[File, URL]]("Mappings from classpath entry to API documentation base URL.").withRank(BMinusSetting)
+  val autoAPIMappings = settingKey[Boolean]("If true, automatically manages mappings to the API doc URL.").withRank(BMinusSetting)
+  val scmInfo = settingKey[Option[ScmInfo]]("Basic SCM information for the project.").withRank(BMinusSetting)
+  val projectInfo = settingKey[ModuleInfo]("Addition project information like formal name, homepage, licenses etc.").withRank(CSetting)
+  val defaultConfiguration = settingKey[Option[Configuration]]("Defines the configuration used when none is specified for a dependency in ivyXML.").withRank(CSetting)
 
-  val products = TaskKey[Seq[File]]("products", "Build products that get packaged.", BMinusTask)
-  // TODO: This is used by exportedProducts, exportedProductsIfMissing, exportedProductsNoTracking..
-  @deprecated("This task is unused by the default project and will be removed.", "0.13.0")
-  val productDirectories = TaskKey[Seq[File]]("product-directories", "Base directories of build products.", CTask)
-  val exportJars = SettingKey[Boolean]("export-jars", "Determines whether the exported classpath for this project contains classes (false) or a packaged jar (true).", BSetting)
-  val exportedProducts = TaskKey[Classpath]("exported-products", "Build products that go on the exported classpath.", CTask)
-  val exportedProductsIfMissing = TaskKey[Classpath]("exported-products-if-missing", "Build products that go on the exported classpath if missing.", CTask)
-  val exportedProductsNoTracking = TaskKey[Classpath]("exported-products-no-tracking", "Just the exported classpath without triggering the compilation.", CTask)
-  val unmanagedClasspath = TaskKey[Classpath]("unmanaged-classpath", "Classpath entries (deep) that are manually managed.", BPlusTask)
-  val unmanagedJars = TaskKey[Classpath]("unmanaged-jars", "Classpath entries for the current project (shallow) that are manually managed.", BPlusTask)
-  val managedClasspath = TaskKey[Classpath]("managed-classpath", "The classpath consisting of external, managed library dependencies.", BMinusTask)
-  val internalDependencyClasspath = TaskKey[Classpath]("internal-dependency-classpath", "The internal (inter-project) classpath.", CTask)
-  val externalDependencyClasspath = TaskKey[Classpath]("external-dependency-classpath", "The classpath consisting of library dependencies, both managed and unmanaged.", BMinusTask)
-  val dependencyClasspath = TaskKey[Classpath]("dependency-classpath", "The classpath consisting of internal and external, managed and unmanaged dependencies.", BPlusTask)
-  val fullClasspath = TaskKey[Classpath]("full-classpath", "The exported classpath, consisting of build products and unmanaged and managed, internal and external dependencies.", BPlusTask)
-  val trackInternalDependencies = SettingKey[TrackLevel]("track-internal-dependencies", "The level of tracking for the internal (inter-project) dependency.", BSetting)
-  val exportToInternal = SettingKey[TrackLevel]("export-to-internal", "The level of tracking for this project by the internal callers.", BSetting)
+  val products = taskKey[Seq[File]]("Build products that get packaged.").withRank(BMinusTask)
+  val productDirectories = taskKey[Seq[File]]("Base directories of build products.").withRank(CTask)
+  val exportJars = settingKey[Boolean]("Determines whether the exported classpath for this project contains classes (false) or a packaged jar (true).").withRank(BSetting)
+  val exportedProducts = taskKey[Classpath]("Build products that go on the exported classpath.").withRank(CTask)
+  val exportedProductsIfMissing = taskKey[Classpath]("Build products that go on the exported classpath if missing.").withRank(CTask)
+  val exportedProductsNoTracking = taskKey[Classpath]("Just the exported classpath without triggering the compilation.").withRank(CTask)
+  val unmanagedClasspath = taskKey[Classpath]("Classpath entries (deep) that are manually managed.").withRank(BPlusTask)
+  val unmanagedJars = taskKey[Classpath]("Classpath entries for the current project (shallow) that are manually managed.").withRank(BPlusTask)
+  val managedClasspath = taskKey[Classpath]("The classpath consisting of external, managed library dependencies.").withRank(BMinusTask)
+  val internalDependencyClasspath = taskKey[Classpath]("The internal (inter-project) classpath.").withRank(CTask)
+  val externalDependencyClasspath = taskKey[Classpath]("The classpath consisting of library dependencies, both managed and unmanaged.").withRank(BMinusTask)
+  val dependencyClasspath = taskKey[Classpath]("The classpath consisting of internal and external, managed and unmanaged dependencies.").withRank(BPlusTask)
+  val dependencyVirtualClasspath = taskKey[VirtualClasspath]("The classpath consisting of internal and external, managed and unmanaged dependencies.").withRank(CTask)
+  val dependencyPicklePath = taskKey[VirtualClasspath]("The classpath consisting of internal pickles and external, managed and unmanaged dependencies. This task is promise-blocked.")
+  val internalDependencyPicklePath = taskKey[VirtualClasspath]("The internal (inter-project) pickles. This task is promise-blocked.")
+  val fullClasspath = taskKey[Classpath]("The exported classpath, consisting of build products and unmanaged and managed, internal and external dependencies.").withRank(BPlusTask)
+  val trackInternalDependencies = settingKey[TrackLevel]("The level of tracking for the internal (inter-project) dependency.").withRank(BSetting)
+  val exportToInternal = settingKey[TrackLevel]("The level of tracking for this project by the internal callers.").withRank(BSetting)
+  val exportedProductJars = taskKey[Classpath]("Build products that go on the exported classpath as JARs.")
+  val exportedProductJarsIfMissing = taskKey[Classpath]("Build products that go on the exported classpath as JARs if missing.")
+  val exportedProductJarsNoTracking = taskKey[Classpath]("Just the exported classpath as JARs without triggering the compilation.")
+  val exportedPickles = taskKey[VirtualClasspath]("Build products that go on the exported compilation classpath as JARs. Note this is promise-blocked.").withRank(DTask)
+  val pickleProducts = taskKey[Seq[VirtualFile]]("Pickle JARs").withRank(DTask)
+  val internalDependencyAsJars = taskKey[Classpath]("The internal (inter-project) classpath as JARs.")
+  val dependencyClasspathAsJars = taskKey[Classpath]("The classpath consisting of internal and external, managed and unmanaged dependencies, all as JARs.")
+  val fullClasspathAsJars = taskKey[Classpath]("The exported classpath, consisting of build products and unmanaged and managed, internal and external dependencies, all as JARs.")
+  val internalDependencyConfigurations = settingKey[Seq[(ProjectRef, Set[String])]]("The project configurations that this configuration depends on")
+  val closeClassLoaders = settingKey[Boolean]("Close classloaders in run and test when the task completes.").withRank(DSetting)
+  val allowZombieClassLoaders = settingKey[Boolean]("Allow a classloader that has previously been closed by `run` or `test` to continue loading classes.")
+  // val useRemoteCache = settingKey[Boolean]("Use remote cache.")
+  val remoteCacheId = taskKey[String]("Unique identifier for the remote cache.")
+  val remoteCacheProjectId = taskKey[ModuleID]("ModuleID used for remote cache JARs.")
+  val remoteCacheIdCandidates = taskKey[Seq[String]]("Remote cache ids to pull.")
+  val remoteCacheArtifacts = taskKey[Seq[RemoteCacheArtifact]]("Remote cache artifact definitions.")
+  val remoteCacheArtifact = taskKey[RemoteCacheArtifact]("The remote cache artifact definition.")
+  val pullRemoteCache = taskKey[Unit]("Retrieve remote cache.")
+  val pushRemoteCache = taskKey[Unit]("Push remote cache to the cache server.")
+  val pushRemoteCacheArtifact = settingKey[Boolean]("Enables publishing an artifact to remote cache.")
+  val pushRemoteCacheConfiguration = taskKey[PublishConfiguration]("")
+  val pushRemoteCacheTo = settingKey[Option[Resolver]]("The resolver to publish remote cache to.")
+  val remoteCacheResolvers = settingKey[Seq[Resolver]]("Resolvers for remote cache.")
+  val remoteCachePom = taskKey[File]("Generates a pom for publishing when publishing Maven-style.")
+  val localCacheDirectory = settingKey[File]("Directory to pull the remote cache to.")
+  val usePipelining = settingKey[Boolean]("Use subproject pipelining for compilation.").withRank(BSetting)
+  val exportPipelining = settingKey[Boolean]("Product early output so downstream subprojects can do pipelining.").withRank(BSetting)
 
-  val internalConfigurationMap = SettingKey[Configuration => Configuration]("internal-configuration-map", "Maps configurations to the actual configuration used to define the classpath.", CSetting)
-  val classpathConfiguration = TaskKey[Configuration]("classpath-configuration", "The configuration used to define the classpath.", CTask)
-  val ivyConfiguration = TaskKey[IvyConfiguration]("ivy-configuration", "General dependency management (Ivy) settings, such as the resolvers and paths to use.", DTask)
-  val ivyConfigurations = SettingKey[Seq[Configuration]]("ivy-configurations", "The defined configurations for dependency management.  This may be different from the configurations for Project settings.", BSetting)
-  // This setting was created to workaround the limitation of derived tasks not being able to use task-scoped task: ivyConfiguration in updateSbtClassifiers
-  val bootIvyConfiguration = TaskKey[IvyConfiguration]("boot-ivy-configuration", "General dependency management (Ivy) settings, configured to retrieve sbt's components.", DTask)
-  val moduleSettings = TaskKey[ModuleSettings]("module-settings", "Module settings, which configure dependency management for a specific module, such as a project.", DTask)
-  val unmanagedBase = SettingKey[File]("unmanaged-base", "The default directory for manually managed libraries.", ASetting)
-  val updateConfiguration = SettingKey[UpdateConfiguration]("update-configuration", "Configuration for resolving and retrieving managed dependencies.", DSetting)
-  val updateOptions = SettingKey[UpdateOptions]("update-options", "Options for resolving managed dependencies.", DSetting)
-  val unresolvedWarningConfiguration = TaskKey[UnresolvedWarningConfiguration]("unresolved-warning-configuration", "Configuration for unresolved dependency warning.", DTask)
-  val dependencyPositions = TaskKey[Map[ModuleID, SourcePosition]]("dependency-positions", "Source positions where the dependencies are defined.", DTask)
-  val ivySbt = TaskKey[IvySbt]("ivy-sbt", "Provides the sbt interface to Ivy.", CTask)
-  val ivyModule = TaskKey[IvySbt#Module]("ivy-module", "Provides the sbt interface to a configured Ivy module.", CTask)
-  val updateCacheName = TaskKey[String]("updateCacheName", "Defines the directory name used to store the update cache files (inside the streams cacheDirectory).", DTask)
-  val update = TaskKey[UpdateReport]("update", "Resolves and optionally retrieves dependencies, producing a report.", ATask)
-  val evicted = TaskKey[EvictionWarning]("evicted", "Display detailed eviction warnings.", CTask)
-  val evictionWarningOptions = SettingKey[EvictionWarningOptions]("eviction-warning-options", "Options on eviction warnings after resolving managed dependencies.", DSetting)
-  val transitiveUpdate = TaskKey[Seq[UpdateReport]]("transitive-update", "UpdateReports for the internal dependencies of this project.", DTask)
-  val updateClassifiers = TaskKey[UpdateReport]("update-classifiers", "Resolves and optionally retrieves classified artifacts, such as javadocs and sources, for dependency definitions, transitively.", BPlusTask, update)
-  val transitiveClassifiers = SettingKey[Seq[String]]("transitive-classifiers", "List of classifiers used for transitively obtaining extra artifacts for sbt or declared dependencies.", BSetting)
-  val updateSbtClassifiers = TaskKey[UpdateReport]("update-sbt-classifiers", "Resolves and optionally retrieves classifiers, such as javadocs and sources, for sbt, transitively.", BPlusTask, updateClassifiers)
-  val sourceArtifactTypes = SettingKey[Set[String]]("source-artifact-types", "Ivy artifact types that correspond to source artifacts. Used by IDEs to resolve these resources.", BSetting)
-  val docArtifactTypes = SettingKey[Set[String]]("doc-artifact-types", "Ivy artifact types that correspond to javadoc artifacts. Used by IDEs to resolve these resources.", BSetting)
+  val bspConfig = taskKey[Unit]("Create or update the BSP connection files").withRank(DSetting)
+  val bspEnabled = SettingKey[Boolean](BasicKeys.bspEnabled)
+  val bspTargetIdentifier = settingKey[BuildTargetIdentifier]("Build target identifier of a project and configuration.").withRank(DSetting)
+  val bspWorkspace = settingKey[Map[BuildTargetIdentifier, Scope]]("Mapping of BSP build targets to sbt scopes").withRank(DSetting)
+  val bspInternalDependencyConfigurations = settingKey[Seq[(ProjectRef, Set[ConfigKey])]]("The project configurations that this configuration depends on, possibly transitivly").withRank(DSetting)
+  val bspWorkspaceBuildTargets = taskKey[Seq[BuildTarget]]("List all the BSP build targets").withRank(DTask)
+  val bspBuildTarget = taskKey[BuildTarget]("Description of the BSP build targets").withRank(DTask)
+  val bspBuildTargetSources = inputKey[Unit]("").withRank(DTask)
+  val bspBuildTargetSourcesItem = taskKey[SourcesItem]("").withRank(DTask)
+  val bspBuildTargetDependencySources = inputKey[Unit]("").withRank(DTask)
+  val bspBuildTargetDependencySourcesItem = taskKey[DependencySourcesItem]("").withRank(DTask)
+  val bspBuildTargetCompile = inputKey[Unit]("").withRank(DTask)
+  val bspBuildTargetCompileItem = taskKey[Int]("").withRank(DTask)
+  val bspBuildTargetTest = inputKey[Unit]("Corresponds to buildTarget/test request").withRank(DTask)
+  val bspBuildTargetRun = inputKey[Unit]("Corresponds to buildTarget/run request").withRank(DTask)
+  val bspBuildTargetScalacOptions = inputKey[Unit]("").withRank(DTask)
+  val bspBuildTargetScalacOptionsItem = taskKey[ScalacOptionsItem]("").withRank(DTask)
+  val bspScalaTestClasses = inputKey[Unit]("Corresponds to buildTarget/scalaTestClasses request").withRank(DTask)
+  val bspScalaTestClassesItem = taskKey[ScalaTestClassesItem]("").withRank(DTask)
+  val bspScalaMainClasses = inputKey[Unit]("Corresponds to buildTarget/scalaMainClasses request").withRank(DTask)
+  val bspScalaMainClassesItem = taskKey[ScalaMainClassesItem]("").withRank(DTask)
+  val bspReporter = taskKey[BuildServerReporter]("").withRank(DTask)
 
-  val publishConfiguration = TaskKey[PublishConfiguration]("publish-configuration", "Configuration for publishing to a repository.", DTask)
-  val publishLocalConfiguration = TaskKey[PublishConfiguration]("publish-local-configuration", "Configuration for publishing to the local Ivy repository.", DTask)
-  val publishM2Configuration = TaskKey[PublishConfiguration]("publish-m2-configuration", "Configuration for publishing to the local Maven repository.", DTask)
-  val deliverConfiguration = TaskKey[DeliverConfiguration]("deliver-configuration", "Configuration for generating the finished Ivy file for publishing.", DTask)
-  val deliverLocalConfiguration = TaskKey[DeliverConfiguration]("deliver-local-configuration", "Configuration for generating the finished Ivy file for local publishing.", DTask)
-  val makePomConfiguration = SettingKey[MakePomConfiguration]("make-pom-configuration", "Configuration for generating a pom.", DSetting)
-  val packagedArtifacts = TaskKey[Map[Artifact, File]]("packaged-artifacts", "Packages all artifacts for publishing and maps the Artifact definition to the generated file.", CTask)
-  val publishMavenStyle = SettingKey[Boolean]("publish-maven-style", "Configures whether to generate and publish a pom (true) or Ivy file (false).", BSetting)
-  val credentials = TaskKey[Seq[Credentials]]("credentials", "The credentials to use for updating and publishing.", BMinusTask)
+  val useCoursier = settingKey[Boolean]("Use Coursier for dependency resolution.").withRank(BSetting)
+  val csrCacheDirectory = settingKey[File]("Coursier cache directory. Uses -Dsbt.coursier.home or Coursier's default.").withRank(CSetting)
+  val csrMavenProfiles = settingKey[Set[String]]("").withRank(CSetting)
+  val csrConfiguration = taskKey[CoursierConfiguration]("General dependency management (Coursier) settings, such as the resolvers and options to use.").withRank(DTask)
+  val csrProject = taskKey[lmcoursier.definitions.Project]("")
+  val csrResolvers = taskKey[Seq[Resolver]]("")
+  val csrRecursiveResolvers = taskKey[Seq[Resolver]]("Resolvers of the current project, plus those of all from its inter-dependency projects")
+  val csrSbtResolvers = taskKey[Seq[Resolver]]("Resolvers used for sbt artifacts.")
+  val csrInterProjectDependencies = taskKey[Seq[lmcoursier.definitions.Project]]("Projects the current project depends on, possibly transitively")
+  val csrExtraProjects = taskKey[Seq[lmcoursier.definitions.Project]]("").withRank(CTask)
+  val csrFallbackDependencies = taskKey[Seq[FallbackDependency]]("")
+  val csrLogger = taskKey[Option[CacheLogger]]("")
+  val csrExtraCredentials = taskKey[Seq[lmcoursier.credentials.Credentials]]("")
+  val csrPublications = taskKey[Seq[(lmcoursier.definitions.Configuration, lmcoursier.definitions.Publication)]]("")
+  val csrReconciliations = settingKey[Seq[(ModuleMatchers, Reconciliation)]]("Strategy to reconcile version conflicts.")
 
-  val makePom = TaskKey[File]("make-pom", "Generates a pom for publishing when publishing Maven-style.", BPlusTask)
-  val deliver = TaskKey[File]("deliver", "Generates the Ivy file for publishing to a repository.", BTask)
-  val deliverLocal = TaskKey[File]("deliver-local", "Generates the Ivy file for publishing to the local repository.", BTask)
-  val publish = TaskKey[Unit]("publish", "Publishes artifacts to a repository.", APlusTask)
-  val publishLocal = TaskKey[Unit]("publish-local", "Publishes artifacts to the local Ivy repository.", APlusTask)
-  val publishM2 = TaskKey[Unit]("publish-m2", "Publishes artifacts to the local Maven repository.", ATask)
+  val internalConfigurationMap = settingKey[Configuration => Configuration]("Maps configurations to the actual configuration used to define the classpath.").withRank(CSetting)
+  val classpathConfiguration = taskKey[Configuration]("The configuration used to define the classpath.").withRank(CTask)
+  val ivyConfiguration = taskKey[IvyConfiguration]("General dependency management (Ivy) settings, such as the resolvers and paths to use.").withRank(DTask)
+  val ivyConfigurations = settingKey[Seq[Configuration]]("The defined configurations for dependency management.  This may be different from the configurations for Project settings.").withRank(BSetting)
+  // This setting was created to work around the limitation of derived tasks not being able to use task-scoped task: ivyConfiguration in updateSbtClassifiers
+  val bootIvyConfiguration = taskKey[IvyConfiguration]("General dependency management (Ivy) settings, configured to retrieve sbt's components.").withRank(DTask)
+  val bootDependencyResolution = taskKey[DependencyResolution]("Dependency resolution to retrieve sbt's components.").withRank(CTask)
+  val scalaCompilerBridgeDependencyResolution = taskKey[DependencyResolution]("Dependency resolution to retrieve the compiler bridge.").withRank(CTask)
+  val moduleSettings = taskKey[ModuleSettings]("Module settings, which configure dependency management for a specific module, such as a project.").withRank(DTask)
+  val unmanagedBase = settingKey[File]("The default directory for manually managed libraries.").withRank(ASetting)
+  val updateConfiguration = settingKey[UpdateConfiguration]("Configuration for resolving and retrieving managed dependencies.").withRank(DSetting)
+  val updateOptions = settingKey[UpdateOptions]("Options for resolving managed dependencies.").withRank(DSetting)
+  val unresolvedWarningConfiguration = taskKey[UnresolvedWarningConfiguration]("Configuration for unresolved dependency warning.").withRank(DTask)
+  val dependencyPositions = taskKey[Map[ModuleID, SourcePosition]]("Source positions where the dependencies are defined.").withRank(DTask)
+  val dependencyResolution = taskKey[DependencyResolution]("Provides the sbt interface to dependency resolution.").withRank(CTask)
+  val publisher = taskKey[Publisher]("Provides the sbt interface to publisher")
+  val ivySbt = taskKey[IvySbt]("Provides the sbt interface to Ivy.").withRank(CTask)
+  val ivyModule = taskKey[IvySbt#Module]("Provides the sbt interface to a configured Ivy module.").withRank(CTask)
+  val updateCacheName = taskKey[String]("Defines the directory name used to store the update cache files (inside the streams cacheDirectory).").withRank(DTask)
+  val update = taskKey[UpdateReport]("Resolves and optionally retrieves dependencies, producing a report.").withRank(ATask)
+  val updateFull = taskKey[UpdateReport]("Resolves and optionally retrieves dependencies, producing a full report with callers.").withRank(CTask)
+  val evicted = taskKey[EvictionWarning]("Display detailed eviction warnings.").withRank(CTask)
+  val evictionWarningOptions = settingKey[EvictionWarningOptions]("Options on eviction warnings after resolving managed dependencies.").withRank(DSetting)
+  val evictionErrorLevel = settingKey[Level.Value]("The log level for the detected eviction errors. Level.Error will throw an error.").withRank(DSetting)
+  val assumedEvictionErrorLevel = settingKey[Level.Value]("The log level for the assumed eviction errors. Level.Error will throw an error.").withRank(DSetting)
+  val assumedVersionScheme = settingKey[String]("The assumed version scheme of a Scala library when POM doesn't have versionScheme.").withRank(DSetting)
+  val assumedVersionSchemeJava = settingKey[String]("The assumed version scheme of a Java library when POM doesn't have versionScheme.").withRank(DSetting)
+  val transitiveUpdate = taskKey[Seq[UpdateReport]]("UpdateReports for the internal dependencies of this project.").withRank(DTask)
+  val updateClassifiers = TaskKey[UpdateReport]("updateClassifiers", "Resolves and optionally retrieves classified artifacts, such as javadocs and sources, for dependency definitions, transitively.", BPlusTask, update)
+  val transitiveClassifiers = settingKey[Seq[String]]("List of classifiers used for transitively obtaining extra artifacts for sbt or declared dependencies.").withRank(BSetting)
+  val updateSbtClassifiers = TaskKey[UpdateReport]("updateSbtClassifiers", "Resolves and optionally retrieves classifiers, such as javadocs and sources, for sbt, transitively.", BPlusTask, updateClassifiers)
+  val sourceArtifactTypes = settingKey[Seq[String]]("Ivy artifact types that correspond to source artifacts. Used by IDEs to resolve these resources.").withRank(BSetting)
+  val docArtifactTypes = settingKey[Seq[String]]("Ivy artifact types that correspond to javadoc artifacts. Used by IDEs to resolve these resources.").withRank(BSetting)
 
-  val pomExtra = SettingKey[NodeSeq]("pom-extra", "Extra XML to insert into the generated POM.", BSetting)
-  val pomPostProcess = SettingKey[XNode => XNode]("pom-post-process", "Transforms the generated POM.", CSetting)
-  val pomIncludeRepository = SettingKey[MavenRepository => Boolean]("pom-include-repository", "Selects repositories to include in the generated POM.", CSetting)
-  val pomAllRepositories = SettingKey[Boolean]("pom-all-repositories", "If true, includes repositories used in module configurations in the pom repositories section.  If false, only the common repositories are included.", BMinusSetting)
+  val publishConfiguration = taskKey[PublishConfiguration]("Configuration for publishing to a repository.").withRank(DTask)
+  val publishLocalConfiguration = taskKey[PublishConfiguration]("Configuration for publishing to the local Ivy repository.").withRank(DTask)
+  val publishM2Configuration = taskKey[PublishConfiguration]("Configuration for publishing to the local Maven repository.").withRank(DTask)
+  val makePomConfiguration = settingKey[MakePomConfiguration]("Configuration for generating a pom.").withRank(DSetting)
+  val makeIvyXmlConfiguration = taskKey[PublishConfiguration]("Configuration for generating ivy.xml.").withRank(DSetting)
+  val makeIvyXmlLocalConfiguration = taskKey[PublishConfiguration]("Configuration for generating ivy.xml.").withRank(DSetting)
+  val packagedArtifacts = taskKey[Map[Artifact, File]]("Packages all artifacts for publishing and maps the Artifact definition to the generated file.").withRank(CTask)
+  val publishMavenStyle = settingKey[Boolean]("Configures whether to generate and publish a pom (true) or Ivy file (false).").withRank(BSetting)
+  val credentials = taskKey[Seq[Credentials]]("The credentials to use for updating and publishing.").withRank(BMinusTask)
+  val allCredentials = taskKey[Seq[Credentials]]("Aggregated credentials across current and root subprojects. Do not rewire this task.").withRank(DTask)
 
-  val moduleName = SettingKey[String]("module-name", "The name of the current module, used for dependency management.", BSetting)
-  val version = SettingKey[String]("version", "The version/revision of the current module.", APlusSetting)
-  val isSnapshot = SettingKey[Boolean]("is-snapshot", "True if the the version of the project is a snapshot version.", BPlusSetting)
-  val moduleID = SettingKey[ModuleID]("module-id", "A dependency management descriptor.  This is currently used for associating a ModuleID with a classpath entry.", BPlusSetting)
-  val projectID = SettingKey[ModuleID]("project-id", "The dependency management descriptor for the current module.", BMinusSetting)
-  val overrideBuildResolvers = SettingKey[Boolean]("override-build-resolvers", "Whether or not all the build resolvers should be overridden with what's defined from the launcher.", BMinusSetting)
-  val bootResolvers = TaskKey[Option[Seq[Resolver]]]("boot-resolvers", "The resolvers used by the sbt launcher.", BMinusSetting)
-  val appResolvers = SettingKey[Option[Seq[Resolver]]]("app-resolvers", "The resolvers configured for this application by the sbt launcher.", BMinusSetting)
-  val externalResolvers = TaskKey[Seq[Resolver]]("external-resolvers", "The external resolvers for automatically managed dependencies.", BMinusSetting)
-  val resolvers = SettingKey[Seq[Resolver]]("resolvers", "The user-defined additional resolvers for automatically managed dependencies.", BMinusTask)
-  val projectResolver = TaskKey[Resolver]("project-resolver", "Resolver that handles inter-project dependencies.", DTask)
-  val fullResolvers = TaskKey[Seq[Resolver]]("full-resolvers", "Combines the project resolver, default resolvers, and user-defined resolvers.", CTask)
-  val otherResolvers = TaskKey[Seq[Resolver]]("other-resolvers", "Resolvers not included in the main resolver chain, such as those in module configurations.", CSetting)
-  val useJCenter = SettingKey[Boolean]("use-jcenter", "Use JCenter as the default repository.", BSetting)
-  val moduleConfigurations = SettingKey[Seq[ModuleConfiguration]]("module-configurations", "Defines module configurations, which override resolvers on a per-module basis.", BMinusSetting)
-  val retrievePattern = SettingKey[String]("retrieve-pattern", "Pattern used to retrieve managed dependencies to the current build.", DSetting)
-  val retrieveConfiguration = SettingKey[Option[RetrieveConfiguration]]("retrieve-configuration", "Configures retrieving dependencies to the current build.", DSetting)
-  val offline = SettingKey[Boolean]("offline", "Configures sbt to work without a network connection where possible.", ASetting)
-  val ivyPaths = SettingKey[IvyPaths]("ivy-paths", "Configures paths used by Ivy for dependency management.", DSetting)
-  val dependencyCacheDirectory = TaskKey[File]("dependency-cache-directory", "The base directory for cached dependencies.", DTask)
-  val libraryDependencies = SettingKey[Seq[ModuleID]]("library-dependencies", "Declares managed dependencies.", APlusSetting)
-  val dependencyOverrides = SettingKey[Set[ModuleID]]("dependency-overrides", "Declares managed dependency overrides.", BSetting)
-  val excludeDependencies = SettingKey[Seq[SbtExclusionRule]]("exclude-dependencies", "Declares managed dependency exclusions.", BSetting)
-  val allDependencies = TaskKey[Seq[ModuleID]]("all-dependencies", "Inter-project and library dependencies.", CTask)
-  val projectDependencies = TaskKey[Seq[ModuleID]]("project-dependencies", "Inter-project dependencies.", DTask)
-  val ivyXML = SettingKey[NodeSeq]("ivy-xml", "Defines inline Ivy XML for configuring dependency management.", BSetting)
-  val ivyScala = SettingKey[Option[IvyScala]]("ivy-scala", "Configures how Scala dependencies are checked, filtered, and injected.", CSetting)
-  val ivyValidate = SettingKey[Boolean]("ivy-validate", "Enables/disables Ivy validation of module metadata.", BSetting)
-  val ivyLoggingLevel = SettingKey[UpdateLogging.Value]("ivy-logging-level", "The logging level for updating.", BSetting)
-  val publishTo = TaskKey[Option[Resolver]]("publish-to", "The resolver to publish to.", ASetting)
-  val artifacts = SettingKey[Seq[Artifact]]("artifacts", "The artifact definitions for the current module.  Must be consistent with " + packagedArtifacts.key.label + ".", BSetting)
-  val projectDescriptors = TaskKey[Map[ModuleRevisionId, ModuleDescriptor]]("project-descriptors", "Project dependency map for the inter-project resolver.", DTask)
-  val autoUpdate = SettingKey[Boolean]("auto-update", "<unimplemented>", Invisible)
-  val retrieveManaged = SettingKey[Boolean]("retrieve-managed", "If true, enables retrieving dependencies to the current build.  Otherwise, dependencies are used directly from the cache.", BSetting)
-  val retrieveManagedSync = SettingKey[Boolean]("retrieve-managed-sync", "If true, enables synchronizing the dependencies retrieved to the current build by removed unneeded files.", BSetting)
-  val configurationsToRetrieve = SettingKey[Option[Set[Configuration]]]("configurations-to-retrieve", "An optional set of configurations from which to retrieve dependencies if retrieveManaged is set to true", BSetting)
-  val managedDirectory = SettingKey[File]("managed-directory", "Directory to which managed dependencies are retrieved.", BSetting)
-  val classpathTypes = SettingKey[Set[String]]("classpath-types", "Artifact types that are included on the classpath.", BSetting)
-  val publishArtifact = SettingKey[Boolean]("publish-artifact", "Enables (true) or disables (false) publishing an artifact.", AMinusSetting)
-  val packagedArtifact = TaskKey[(Artifact, File)]("packaged-artifact", "Generates a packaged artifact, returning the Artifact and the produced File.", CTask)
-  val checksums = SettingKey[Seq[String]]("checksums", "The list of checksums to generate and to verify for dependencies.", BSetting)
-  val forceUpdatePeriod = SettingKey[Option[FiniteDuration]]("force-update-period", "Duration after which to force a full update to occur", CSetting)
+  val makePom = taskKey[File]("Generates a pom for publishing when publishing Maven-style.").withRank(BPlusTask)
+  val deliver = taskKey[File]("Generates the Ivy file for publishing to a repository.").withRank(BTask)
+  val deliverLocal = taskKey[File]("Generates the Ivy file for publishing to the local repository.").withRank(BTask)
+  // makeIvyXml is currently identical to the confusingly-named "deliver", which may be deprecated in the future
+  val makeIvyXml = taskKey[File]("Generates the Ivy file for publishing to a repository.").withRank(BTask)
+  val publish = taskKey[Unit]("Publishes artifacts to a repository.").withRank(APlusTask)
+  val publishLocal = taskKey[Unit]("Publishes artifacts to the local Ivy repository.").withRank(APlusTask)
+  val publishM2 = taskKey[Unit]("Publishes artifacts to the local Maven repository.").withRank(ATask)
 
-  val classifiersModule = TaskKey[GetClassifiersModule]("classifiers-module", rank = CTask)
-  val compatibilityWarningOptions = SettingKey[CompatibilityWarningOptions]("compatibility-warning", "Configures warnings around Maven incompatibility.", CSetting)
-  val conflictWarning = SettingKey[ConflictWarning]("conflict-warning", "Configures warnings for conflicts in dependency management.", CSetting)
-  val conflictManager = SettingKey[ConflictManager]("conflict-manager", "Selects the conflict manager to use for dependency management.", CSetting)
-  val autoScalaLibrary = SettingKey[Boolean]("auto-scala-library", "Adds a dependency on scala-library if true.", ASetting)
-  val managedScalaInstance = SettingKey[Boolean]("managed-scala-instance", "Automatically obtains Scala tools as managed dependencies if true.", BSetting)
-  val sbtResolver = SettingKey[Resolver]("sbt-resolver", "Provides a resolver for obtaining sbt as a dependency.", BMinusSetting)
-  val sbtDependency = SettingKey[ModuleID]("sbt-dependency", "Provides a definition for declaring the current version of sbt.", BMinusSetting)
-  val sbtVersion = SettingKey[String]("sbt-version", "Provides the version of sbt.  This setting should be not be modified.", AMinusSetting)
-  val sbtBinaryVersion = SettingKey[String]("sbt-binary-version", "Defines the binary compatibility version substring.", BPlusSetting)
-  val skip = TaskKey[Boolean]("skip", "For tasks that support it (currently only 'compile' and 'update'), setting skip to true will force the task to not to do its work.  This exact semantics may vary by task.", BSetting)
+  val pomExtra = settingKey[NodeSeq]("Extra XML to insert into the generated POM.").withRank(BSetting)
+  val pomPostProcess = settingKey[XNode => XNode]("Transforms the generated POM.").withRank(CSetting)
+  val pomIncludeRepository = settingKey[MavenRepository => Boolean]("Selects repositories to include in the generated POM.").withRank(CSetting)
+  val pomAllRepositories = settingKey[Boolean]("If true, includes repositories used in module configurations in the pom repositories section.  If false, only the common repositories are included.").withRank(BMinusSetting)
+
+  val moduleName = settingKey[String]("The name of the current module, used for dependency management.").withRank(BSetting)
+  val version = settingKey[String]("The version/revision of the current module.").withRank(APlusSetting)
+  val isSnapshot = settingKey[Boolean]("True if the version of the project is a snapshot version.").withRank(BPlusSetting)
+  val moduleID = settingKey[ModuleID]("A dependency management descriptor.  This is currently used for associating a ModuleID with a classpath entry.").withRank(BPlusSetting)
+  val projectID = settingKey[ModuleID]("The dependency management descriptor for the current module.").withRank(BMinusSetting)
+  val overrideBuildResolvers = settingKey[Boolean]("Whether or not all the build resolvers should be overridden with what's defined from the launcher.").withRank(BMinusSetting)
+  val bootResolvers = taskKey[Option[Seq[Resolver]]]("The resolvers used by the sbt launcher.").withRank(BMinusSetting)
+  val appResolvers = settingKey[Option[Seq[Resolver]]]("The resolvers configured for this application by the sbt launcher.").withRank(BMinusSetting)
+  val externalResolvers = taskKey[Seq[Resolver]]("The external resolvers for automatically managed dependencies.").withRank(BMinusSetting)
+  val resolvers = settingKey[Seq[Resolver]]("The user-defined additional resolvers for automatically managed dependencies.").withRank(BMinusTask)
+  val projectResolver = taskKey[Resolver]("Resolver that handles inter-project dependencies.").withRank(DTask)
+  val fullResolvers = taskKey[Seq[Resolver]]("Combines the project resolver, default resolvers, and user-defined resolvers.").withRank(CTask)
+  val otherResolvers = taskKey[Seq[Resolver]]("Resolvers not included in the main resolver chain, such as those in module configurations.").withRank(CSetting)
+  val scalaCompilerBridgeResolvers = taskKey[Seq[Resolver]]("Resolvers used to resolve compiler bridges.").withRank(CSetting)
+  val includePluginResolvers = settingKey[Boolean]("Include the resolvers from the metabuild.").withRank(CSetting)
+  val useJCenter = settingKey[Boolean]("Use JCenter as the default repository.").withRank(CSetting)
+  val moduleConfigurations = settingKey[Seq[ModuleConfiguration]]("Defines module configurations, which override resolvers on a per-module basis.").withRank(BMinusSetting)
+  val retrievePattern = settingKey[String]("Pattern used to retrieve managed dependencies to the current build.").withRank(DSetting)
+  val retrieveConfiguration = settingKey[Option[RetrieveConfiguration]]("Configures retrieving dependencies to the current build.").withRank(DSetting)
+  val offline = settingKey[Boolean]("Configures sbt to work without a network connection where possible.").withRank(ASetting)
+  val ivyPaths = settingKey[IvyPaths]("Configures paths used by Ivy for dependency management.").withRank(DSetting)
+  val dependencyCacheDirectory = taskKey[File]("The base directory for cached dependencies.").withRank(DTask)
+  val libraryDependencies = settingKey[Seq[ModuleID]]("Declares managed dependencies.").withRank(APlusSetting)
+  val dependencyOverrides = settingKey[Seq[ModuleID]]("Declares managed dependency overrides.").withRank(BSetting)
+  val excludeDependencies = settingKey[Seq[InclExclRule]]("Declares managed dependency exclusions.").withRank(BSetting)
+  val allExcludeDependencies = settingKey[Seq[InclExclRule]]("User-defined dependency exclusions and sbt itself in the case of metabuild.").withRank(CTask)
+  val allDependencies = taskKey[Seq[ModuleID]]("Inter-project and library dependencies.").withRank(CTask)
+  val projectDependencies = taskKey[Seq[ModuleID]]("Inter-project dependencies.").withRank(DTask)
+  val ivyXML = settingKey[NodeSeq]("Defines inline Ivy XML for configuring dependency management.").withRank(BSetting)
+  val scalaModuleInfo = settingKey[Option[ScalaModuleInfo]]("Configures how Scala dependencies are checked, filtered, and injected.").withRank(CSetting)
+  val ivyValidate = settingKey[Boolean]("Enables/disables Ivy validation of module metadata.").withRank(BSetting)
+  val ivyLoggingLevel = settingKey[UpdateLogging]("The logging level for updating.").withRank(BSetting)
+  val publishTo = taskKey[Option[Resolver]]("The resolver to publish to.").withRank(ASetting)
+  val artifacts = settingKey[Seq[Artifact]]("The artifact definitions for the current module.  Must be consistent with " + packagedArtifacts.key.label + ".").withRank(BSetting)
+  val projectDescriptors = taskKey[Map[ModuleRevisionId, ModuleDescriptor]]("Project dependency map for the inter-project resolver.").withRank(DTask)
+  val autoUpdate = settingKey[Boolean]("<unimplemented>").withRank(Invisible)
+  val retrieveManaged = settingKey[Boolean]("If true, enables retrieving dependencies to the current build.  Otherwise, dependencies are used directly from the cache.").withRank(BSetting)
+  val retrieveManagedSync = settingKey[Boolean]("If true, enables synchronizing the dependencies retrieved to the current build by removed unneeded files.").withRank(BSetting)
+  val configurationsToRetrieve = settingKey[Option[Seq[ConfigRef]]]("An optional set of configurations from which to retrieve dependencies if retrieveManaged is set to true").withRank(BSetting)
+  val managedDirectory = settingKey[File]("Directory to which managed dependencies are retrieved.").withRank(BSetting)
+  val classpathTypes = settingKey[Set[String]]("Artifact types that are included on the classpath.").withRank(BSetting)
+  val publishArtifact = settingKey[Boolean]("Enables (true) or disables (false) publishing an artifact.").withRank(AMinusSetting)
+  val packagedArtifact = taskKey[(Artifact, File)]("Generates a packaged artifact, returning the Artifact and the produced File.").withRank(CTask)
+  val checksums = settingKey[Seq[String]]("The list of checksums to generate and to verify for dependencies.").withRank(BSetting)
+  val forceUpdatePeriod = settingKey[Option[FiniteDuration]]("Duration after which to force a full update to occur").withRank(CSetting)
+  val versionScheme = settingKey[Option[String]]("""Version scheme used for the subproject: Supported values are Some("early-semver"), Some("pvp"), and Some("semver-spec")""").withRank(BSetting)
+  val libraryDependencySchemes = settingKey[Seq[ModuleID]]("""Version scheme to use for specific modules set as "org" %% "name" % "<scheme>": Supported values are "early-semver", "pvp", "semver-spec", "always", and "strict".""").withRank(BSetting)
+
+  val classifiersModule = taskKey[GetClassifiersModule]("classifiers-module").withRank(CTask)
+  val compatibilityWarningOptions = settingKey[CompatibilityWarningOptions]("Configures warnings around Maven incompatibility.").withRank(CSetting)
+  val conflictWarning = settingKey[ConflictWarning]("Configures warnings for conflicts in dependency management.").withRank(CSetting)
+  val conflictManager = settingKey[ConflictManager]("Selects the conflict manager to use for dependency management.").withRank(CSetting)
+  val autoScalaLibrary = settingKey[Boolean]("Adds a dependency on scala-library if true.").withRank(ASetting)
+  val managedScalaInstance = settingKey[Boolean]("Automatically obtains Scala tools as managed dependencies if true.").withRank(BSetting)
+  val sbtResolver = settingKey[Resolver]("Provides a resolver for obtaining sbt as a dependency.").withRank(BMinusSetting)
+  val sbtResolvers = settingKey[Seq[Resolver]]("The external resolvers for sbt and plugin dependencies.").withRank(BMinusSetting)
+  val sbtDependency = settingKey[ModuleID]("Provides a definition for declaring the current version of sbt.").withRank(BMinusSetting)
+  val sbtVersion = settingKey[String]("Provides the version of sbt.  This setting should not be modified.").withRank(AMinusSetting)
+  val sbtBinaryVersion = settingKey[String]("Defines the binary compatibility version substring.").withRank(BPlusSetting)
+  val skip = taskKey[Boolean]("For tasks that support it (currently only 'compile', 'update', and 'publish'), setting skip to true will force the task to not to do its work.  This exact semantics may vary by task.").withRank(BSetting)
+  val templateResolverInfos = settingKey[Seq[TemplateResolverInfo]]("Template resolvers used for 'new'.").withRank(BSetting)
+  val interactionService = taskKey[InteractionService]("Service used to ask for user input through the current user interface(s).").withRank(CTask)
+  val insideCI = SettingKey[Boolean]("insideCI", "Determines if the sbt is running in a Continuous Integration environment", AMinusSetting)
+
+  // sbt server internal
+  val collectAnalyses = taskKey[Unit]("Collect analysis file locations for later use.")
 
   // special
-  val sessionVars = AttributeKey[SessionVar.Map]("session-vars", "Bindings that exist for the duration of the session.", Invisible)
-  val parallelExecution = SettingKey[Boolean]("parallel-execution", "Enables (true) or disables (false) parallel execution of tasks.", BMinusSetting)
-  val tags = SettingKey[Seq[(Tags.Tag, Int)]]("tags", ConcurrentRestrictions.tagsKey.label, BSetting)
-  val concurrentRestrictions = SettingKey[Seq[Tags.Rule]]("concurrent-restrictions", "Rules describing restrictions on concurrent task execution.", BSetting)
-  val cancelable = SettingKey[Boolean]("cancelable", "Enables (true) or disables (false) the ability to interrupt task execution with CTRL+C.", BMinusSetting)
-  val forcegc = SettingKey[Boolean]("forcegc", "Enables (true) or disables (false) forcing garbage collection after task run when needed.", BMinusSetting)
-  val minForcegcInterval = SettingKey[Duration]("min-forcegc-interval", "Minimal interval to check for forcing garbage collection.")
+  val sessionVars = AttributeKey[SessionVar.Map]("sessionVars", "Bindings that exist for the duration of the session.", Invisible)
+  val parallelExecution = settingKey[Boolean]("Enables (true) or disables (false) parallel execution of tasks.").withRank(BMinusSetting)
+  val tags = settingKey[Seq[(Tags.Tag, Int)]](ConcurrentRestrictions.tagsKey.description.getOrElse("tags")).withRank(BSetting)
+  val concurrentRestrictions = settingKey[Seq[Tags.Rule]]("Rules describing restrictions on concurrent task execution.").withRank(BSetting)
+  val cancelable = settingKey[Boolean]("Enables (true) or disables (false) the ability to interrupt task execution with CTRL+C.").withRank(BMinusSetting)
+  val forcegc = settingKey[Boolean]("Enables (true) or disables (false) forcing garbage collection after task run when needed.").withRank(BMinusSetting)
+  val minForcegcInterval = settingKey[Duration]("Minimal interval to check for forcing garbage collection.")
   val settingsData = std.FullInstance.settingsData
-  val streams = TaskKey[TaskStreams]("streams", "Provides streams for logging and persisting data.", DTask)
+  val streams = taskKey[TaskStreams]("Provides streams for logging and persisting data.").withRank(DTask)
   val taskDefinitionKey = Def.taskDefinitionKey
-  val (executionRoots, dummyRoots) = Def.dummy[Seq[ScopedKey[_]]]("execution-roots", "The list of root tasks for this task execution.  Roots are the top-level tasks that were directly requested to be run.")
-
+  val (executionRoots, dummyRoots) = Def.dummy[Seq[ScopedKey[_]]]("executionRoots", "The list of root tasks for this task execution.  Roots are the top-level tasks that were directly requested to be run.")
   val state = Def.stateKey
   val streamsManager = Def.streamsManagerKey
-
-  @deprecated("Implementation detail.", "0.13.1")
-  val isDummyTask = Def.isDummyTask
-  @deprecated("Implementation detail.", "0.13.1")
-  val dummyState = Def.dummyState
-  @deprecated("Implementation detail.", "0.13.2")
-  val dummyStreamsManager = Def.dummyStreamsManager
-
-  val stateStreams = AttributeKey[Streams]("streams-manager", "Streams manager, which provides streams for different contexts.  Setting this on State will override the default Streams implementation.")
-  val resolvedScoped = Def.resolvedScoped
-  val pluginData = TaskKey[PluginData]("plugin-data", "Information from the plugin build needed in the main build definition.", DTask)
-  val globalPluginUpdate = TaskKey[UpdateReport]("global-plugin-update", "A hook to get the UpdateReport of the global plugin.", DTask)
-
   // wrapper to work around SI-2915
-  private[sbt] final class TaskProgress(val progress: ExecuteProgress[Task])
-  private[sbt] val executeProgress = SettingKey[State => TaskProgress]("executeProgress", "Experimental task execution listener.", DTask)
-  private[sbt] val taskCancelStrategy = SettingKey[State => TaskCancellationStrategy]("taskCancelStrategy", "Experimental task cancellation handler.", DTask)
+  final class TaskProgress(val progress: ExecuteProgress[Task])
+  object TaskProgress {
+    def apply(progress: ExecuteProgress[Task]): TaskProgress = new TaskProgress(progress)
+  }
+  private[sbt] val currentTaskProgress = AttributeKey[TaskProgress]("current-task-progress")
+  private[sbt] val taskProgress = AttributeKey[sbt.internal.TaskProgress]("active-task-progress")
+  val useSuperShell = settingKey[Boolean]("Enables (true) or disables the super shell.")
+  val superShellMaxTasks = settingKey[Int]("The max number of tasks to display in the supershell progress report")
+  val superShellSleep = settingKey[FiniteDuration]("The minimum duration to sleep between progress reports")
+  val superShellThreshold = settingKey[FiniteDuration]("The minimum amount of time a task must be running to appear in the supershell progress report")
+  val turbo = settingKey[Boolean]("Enables (true) or disables optional performance features.")
+  // This key can be used to add custom ExecuteProgress instances
+  val progressReports = settingKey[Seq[TaskProgress]]("A function that returns a list of progress reporters.").withRank(DTask)
+  @deprecated("unused", "1.4.0")
+  private[sbt] val progressState = settingKey[Option[ProgressState]]("The optional progress state if supershell is enabled.").withRank(Invisible)
+  private[sbt] val postProgressReports = settingKey[Unit]("Internally used to modify logger.").withRank(DTask)
+  @deprecated("No longer used", "1.3.0")
+  private[sbt] val executeProgress = settingKey[State => TaskProgress]("Experimental task execution listener.").withRank(DTask)
+  val lintUnused = inputKey[Unit]("Check for keys unused by other settings and tasks.")
+  val lintIncludeFilter = settingKey[String => Boolean]("Filters key names that should be included in the lint check.")
+  val lintExcludeFilter = settingKey[String => Boolean]("Filters key names that should be excluded in the lint check.")
+  val excludeLintKeys = settingKey[Set[Def.KeyedInitialize[_]]]("Keys excluded from lintUnused task")
+  val includeLintKeys = settingKey[Set[Def.KeyedInitialize[_]]]("Task keys that are included into lintUnused task")
+  val lintUnusedKeysOnLoad = settingKey[Boolean]("Toggles whether or not to check for unused keys during startup")
+
+  val useScalaReplJLine = settingKey[Boolean]("Toggles whether or not to use sbt's forked jline in the scala repl. Enabling this flag may break the thin client in the scala console.").withRank(KeyRanks.Invisible)
+  val scalaInstanceTopLoader = settingKey[ClassLoader]("The top classloader for the scala instance").withRank(KeyRanks.Invisible)
+
+  val stateStreams = AttributeKey[Streams]("stateStreams", "Streams manager, which provides streams for different contexts.  Setting this on State will override the default Streams implementation.")
+  val resolvedScoped = Def.resolvedScoped
+  val pluginData = taskKey[PluginData]("Information from the plugin build needed in the main build definition.").withRank(DTask)
+  val globalPluginUpdate = taskKey[UpdateReport]("A hook to get the UpdateReport of the global plugin.").withRank(DTask)
+  private[sbt] val taskCancelStrategy = settingKey[State => TaskCancellationStrategy]("Experimental task cancellation handler.").withRank(DTask)
+  private[sbt] val cacheStoreFactoryFactory = AttributeKey[CacheStoreFactoryFactory]("cache-store-factory-factory")
+  private[sbt] val bootServerSocket = AttributeKey[BootServerSocket]("boot-server-socket")
+  val fileCacheSize = settingKey[String]("The approximate maximum size in bytes of the cache used to store previous task results. For example, it could be set to \"256M\" to make the maximum size 256 megabytes.")
 
   // Experimental in sbt 0.13.2 to enable grabbing semantic compile failures.
-  private[sbt] val compilerReporter = TaskKey[xsbti.Reporter]("compilerReporter", "Experimental hook to listen (or send) compilation failure messages.", DTask)
+  private[sbt] val compilerReporter = taskKey[xsbti.Reporter]("Experimental hook to listen (or send) compilation failure messages.").withRank(DTask)
 
   val triggeredBy = Def.triggeredBy
   val runBefore = Def.runBefore
 
   type Streams = std.Streams[ScopedKey[_]]
   type TaskStreams = std.TaskStreams[ScopedKey[_]]
-
-  @deprecated("Implementation detail.", "0.13.1")
-  def dummy[T: Manifest](name: String, description: String): (TaskKey[T], Task[T]) = Def.dummy(name, description)
-  @deprecated("Implementation detail.", "0.13.1")
-  def dummyTask[T](name: String): Task[T] = Def.dummyTask(name)
-  @deprecated("Implementation detail.", "0.13.1")
-  def isDummy(t: Task[_]): Boolean = Def.isDummy(t)
 }
+
+// format: on
diff --git a/main/src/main/scala/sbt/LogManager.scala b/main/src/main/scala/sbt/LogManager.scala
deleted file mode 100644
index c2c8a5801..000000000
--- a/main/src/main/scala/sbt/LogManager.scala
+++ /dev/null
@@ -1,118 +0,0 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
- */
-package sbt
-
-import java.io.PrintWriter
-import Def.ScopedKey
-import Scope.GlobalScope
-import Keys.{ logLevel, logManager, persistLogLevel, persistTraceLevel, sLog, traceLevel }
-import scala.Console.{ BLUE, RESET }
-import sbt.internal.util.{ AttributeKey, ConsoleOut, MultiLoggerConfig, Settings, SuppressedTraceContext }
-import sbt.internal.util.MainLogging._
-import sbt.util.{ AbstractLogger, Level, Logger }
-
-object LogManager {
-  def construct(data: Settings[Scope], state: State) = (task: ScopedKey[_], to: PrintWriter) =>
-    {
-      val manager = logManager in task.scope get data getOrElse defaultManager(state.globalLogging.console)
-      manager(data, state, task, to)
-    }
-  @deprecated("Use defaultManager to explicitly specify standard out.", "0.13.0")
-  lazy val default: LogManager = defaultManager(StandardMain.console)
-
-  def defaultManager(console: ConsoleOut): LogManager = withLoggers((sk, s) => defaultScreen(console))
-
-  @deprecated("Explicitly specify standard out.", "0.13.0")
-  def defaults(extra: ScopedKey[_] => Seq[AbstractLogger]): LogManager = defaults(extra, StandardMain.console)
-
-  def defaults(extra: ScopedKey[_] => Seq[AbstractLogger], console: ConsoleOut): LogManager =
-    withLoggers((task, state) => defaultScreen(console, suppressedMessage(task, state)), extra = extra)
-
-  def withScreenLogger(mk: (ScopedKey[_], State) => AbstractLogger): LogManager = withLoggers(screen = mk)
-
-  def withLoggers(screen: (ScopedKey[_], State) => AbstractLogger = (sk, s) => defaultScreen(s.globalLogging.console),
-    backed: PrintWriter => AbstractLogger = defaultBacked(),
-    extra: ScopedKey[_] => Seq[AbstractLogger] = _ => Nil): LogManager = new LogManager {
-    def apply(data: Settings[Scope], state: State, task: ScopedKey[_], to: PrintWriter): Logger =
-      defaultLogger(data, state, task, screen(task, state), backed(to), extra(task).toList)
-  }
-
-  def defaultLogger(data: Settings[Scope], state: State, task: ScopedKey[_], console: AbstractLogger, backed: AbstractLogger, extra: List[AbstractLogger]): Logger =
-    {
-      val scope = task.scope
-      // to change from global being the default to overriding, switch the order of state.get and data.get
-      def getOr[T](key: AttributeKey[T], default: T): T = data.get(scope, key) orElse state.get(key) getOrElse default
-      val screenLevel = getOr(logLevel.key, Level.Info)
-      val backingLevel = getOr(persistLogLevel.key, Level.Debug)
-      val screenTrace = getOr(traceLevel.key, defaultTraceLevel(state))
-      val backingTrace = getOr(persistTraceLevel.key, Int.MaxValue)
-      val extraBacked = state.globalLogging.backed :: Nil
-      multiLogger(MultiLoggerConfig(console, backed, extraBacked ::: extra, screenLevel, backingLevel, screenTrace, backingTrace))
-    }
-  def defaultTraceLevel(state: State): Int =
-    if (state.interactive) -1 else Int.MaxValue
-  def suppressedMessage(key: ScopedKey[_], state: State): SuppressedTraceContext => Option[String] =
-    {
-      lazy val display = Project.showContextKey(state)
-      def commandBase = "last " + display(unwrapStreamsKey(key))
-      def command(useColor: Boolean) = if (useColor) BLUE + commandBase + RESET else "'" + commandBase + "'"
-      context => Some("Stack trace suppressed: run %s for the full output.".format(command(context.useColor)))
-    }
-  def unwrapStreamsKey(key: ScopedKey[_]): ScopedKey[_] = key.scope.task match {
-    case Select(task) => ScopedKey(key.scope.copy(task = Global), task)
-    case _            => key // should never get here
-  }
-
-  // if global logging levels are not explicitly set, set them from project settings
-  private[sbt] def setGlobalLogLevels(s: State, data: Settings[Scope]): State =
-    if (hasExplicitGlobalLogLevels(s))
-      s
-    else {
-      val logging = s.globalLogging
-      def get[T](key: SettingKey[T]) = key in GlobalScope get data
-      def transfer(l: AbstractLogger, traceKey: SettingKey[Int], levelKey: SettingKey[Level.Value]): Unit = {
-        get(traceKey).foreach(l.setTrace)
-        get(levelKey).foreach(l.setLevel)
-      }
-      logging.full match {
-        case a: AbstractLogger => transfer(a, traceLevel, logLevel)
-        case _                 => ()
-      }
-      transfer(logging.backed, persistTraceLevel, persistLogLevel)
-      s
-    }
-
-  def setGlobalLogLevel(s: State, level: Level.Value): State = {
-    s.globalLogging.full match {
-      case a: AbstractLogger => a.setLevel(level)
-      case _                 => ()
-    }
-    s.put(BasicKeys.explicitGlobalLogLevels, true).put(Keys.logLevel.key, level)
-  }
-
-  private[this] def hasExplicitGlobalLogLevels(s: State): Boolean =
-    State.getBoolean(s, BasicKeys.explicitGlobalLogLevels, default = false)
-
-  private[sbt] def settingsLogger(state: State): Def.Setting[_] =
-    // strict to avoid retaining a reference to `state`
-    sLog in GlobalScope :== globalWrapper(state)
-
-  // construct a Logger that delegates to the global logger, but only holds a weak reference
-  //  this is an approximation to the ideal that would invalidate the delegate after loading completes
-  private[this] def globalWrapper(s: State): Logger = {
-    new Logger {
-      private[this] val ref = new java.lang.ref.WeakReference(s.globalLogging.full)
-      private[this] def slog: Logger = Option(ref.get) getOrElse sys.error("Settings logger used after project was loaded.")
-
-      override val ansiCodesSupported = slog.ansiCodesSupported
-      override def trace(t: => Throwable) = slog.trace(t)
-      override def success(message: => String) = slog.success(message)
-      override def log(level: Level.Value, message: => String) = slog.log(level, message)
-    }
-  }
-}
-
-trait LogManager {
-  def apply(data: Settings[Scope], state: State, task: ScopedKey[_], writer: PrintWriter): Logger
-}
diff --git a/main/src/main/scala/sbt/Main.scala b/main/src/main/scala/sbt/Main.scala
index 58c2ccc86..2064fa514 100644
--- a/main/src/main/scala/sbt/Main.scala
+++ b/main/src/main/scala/sbt/Main.scala
@@ -1,134 +1,348 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010, 2011  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import sbt.internal.{
-  Act,
-  Aggregation,
-  BuildStructure,
-  BuildUnit,
-  CommandStrings,
-  EvaluateConfigurations,
-  Inspect,
-  IvyConsole,
-  Load,
-  LoadedBuildUnit,
-  Output,
-  PluginsDebug,
-  ProjectNavigation,
-  Script,
-  SessionSettings,
-  SettingCompletions
-}
-import sbt.internal.util.{ AttributeKey, AttributeMap, complete, ConsoleOut, GlobalLogging, LineRange, MainLogging, SimpleReader, Types }
-import sbt.util.{ Level, Logger }
-
-import complete.{ DefaultParsers, Parser }
-import sbt.internal.inc.{ CompilerCache, ScalaInstance }
-import sbt.compiler.EvalImports
-import Types.{ const, idFun }
-import Aggregation.AnyKeys
-import Project.LoadAction
-
-import scala.annotation.tailrec
-import sbt.io.IO
-import sbt.io.syntax._
-import StandardMain._
-
-import java.io.File
+import java.io.{ File, IOException }
 import java.net.URI
-import java.util.Locale
-import scala.util.control.NonFatal
+import java.nio.channels.ClosedChannelException
+import java.nio.file.{ FileAlreadyExistsException, FileSystems, Files }
+import java.util.Properties
+import java.util.concurrent.ForkJoinPool
+import java.util.concurrent.atomic.AtomicBoolean
 
-/** This class is the entry point for sbt.*/
+import sbt.BasicCommandStrings.{ Shell, Shutdown, TemplateCommand }
+import sbt.Project.LoadAction
+import sbt.compiler.EvalImports
+import sbt.internal.Aggregation.AnyKeys
+import sbt.internal.CommandStrings.BootCommand
+import sbt.internal._
+import sbt.internal.client.BspClient
+import sbt.internal.inc.ScalaInstance
+import sbt.internal.nio.{ CheckBuildSources, FileTreeRepository }
+import sbt.internal.server.{ BuildServerProtocol, NetworkChannel }
+import sbt.internal.util.Types.{ const, idFun }
+import sbt.internal.util.{ Terminal => ITerminal, _ }
+import sbt.internal.util.complete.{ Parser, SizeParser }
+import sbt.io._
+import sbt.io.syntax._
+import sbt.util.{ Level, Logger, Show }
+import xsbti.compile.CompilerCache
+
+import scala.annotation.{ nowarn, tailrec }
+import scala.concurrent.ExecutionContext
+import scala.concurrent.duration.Duration
+import scala.util.control.NonFatal
+import sbt.internal.io.Retry
+import xsbti.AppProvider
+
+/** This class is the entry point for sbt. */
 final class xMain extends xsbti.AppMain {
   def run(configuration: xsbti.AppConfiguration): xsbti.MainResult =
-    {
+    new XMainConfiguration().run("xMain", configuration)
+}
+private[sbt] object xMain {
+  private[sbt] def dealiasBaseDirectory(config: xsbti.AppConfiguration): xsbti.AppConfiguration = {
+    val dealiasedBase = config.baseDirectory.getCanonicalFile
+    if (config.baseDirectory == dealiasedBase) config
+    else
+      new xsbti.AppConfiguration {
+        override def arguments: Array[String] = config.arguments()
+        override val baseDirectory: File = dealiasedBase
+        override def provider: AppProvider = config.provider()
+      }
+  }
+  private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult = {
+    try {
+      import BasicCommandStrings.{ DashClient, DashDashClient, DashDashServer, runEarly }
       import BasicCommands.early
-      import BasicCommandStrings.runEarly
       import BuiltinCommands.defaults
       import sbt.internal.CommandStrings.{ BootCommand, DefaultsCommand, InitCommand }
-      runManaged(initialState(configuration,
-        Seq(defaults, early),
-        runEarly(DefaultsCommand) :: runEarly(InitCommand) :: BootCommand :: Nil)
-      )
+      import sbt.internal.client.NetworkClient
+
+      // if we detect -Dsbt.client=true or -client, run thin client.
+      val clientModByEnv = SysProp.client
+      val userCommands = configuration.arguments
+        .map(_.trim)
+        .filterNot(_ == DashDashServer)
+      val isClient: String => Boolean = cmd => (cmd == DashClient) || (cmd == DashDashClient)
+      val isBsp: String => Boolean = cmd => (cmd == "-bsp") || (cmd == "--bsp")
+      val isServer = !userCommands.exists(c => isBsp(c) || isClient(c))
+      val bootServerSocket = if (isServer) getSocketOrExit(configuration) match {
+        case (_, Some(e)) => return e
+        case (s, _)       => s
+      }
+      else None
+      if (userCommands.exists(isBsp)) {
+        BspClient.run(dealiasBaseDirectory(configuration))
+      } else {
+        bootServerSocket.foreach(l => ITerminal.setBootStreams(l.inputStream, l.outputStream))
+        val detachStdio = userCommands.exists(_ == BasicCommandStrings.DashDashDetachStdio)
+        ITerminal.withStreams(true, isSubProcess = detachStdio) {
+          if (clientModByEnv || userCommands.exists(isClient)) {
+            val args = userCommands.toList.filterNot(isClient)
+            Exit(NetworkClient.run(dealiasBaseDirectory(configuration), args))
+          } else {
+            val state0 = StandardMain
+              .initialState(
+                dealiasBaseDirectory(configuration),
+                Seq(defaults, early),
+                runEarly(DefaultsCommand) :: runEarly(InitCommand) :: BootCommand :: Nil
+              )
+              .put(BasicKeys.detachStdio, detachStdio)
+            val state = bootServerSocket match {
+              case Some(l) => state0.put(Keys.bootServerSocket, l)
+              case _       => state0
+            }
+            try StandardMain.runManaged(state)
+            finally bootServerSocket.foreach(_.close())
+          }
+        }
+      }
+    } finally {
+      // Clear any stray progress lines
+      ShutdownHooks.close()
+      if (ITerminal.isAnsiSupported) {
+        System.out.print(ConsoleAppender.ClearScreenAfterCursor)
+        System.out.flush()
+      }
+    }
+  }
+
+  private def getSocketOrExit(
+      configuration: xsbti.AppConfiguration
+  ): (Option[BootServerSocket], Option[Exit]) =
+    try (Some(new BootServerSocket(configuration)) -> None)
+    catch {
+      case e: ServerAlreadyBootingException
+          if System.console != null && !ITerminal.startedByRemoteClient =>
+        println(
+          s"sbt thinks that server is already booting because of this exception:\n${e.getCause}\nCreate a new server? y/n (default y)"
+        )
+        val exit = ITerminal.get.withRawInput(System.in.read) match {
+          case 110 => Some(Exit(1))
+          case _   => None
+        }
+        (None, exit)
+      case _: ServerAlreadyBootingException =>
+        if (SysProp.forceServerStart) (None, None)
+        else (None, Some(Exit(2)))
+      case _: UnsatisfiedLinkError => (None, None)
     }
 }
+
 final class ScriptMain extends xsbti.AppMain {
   def run(configuration: xsbti.AppConfiguration): xsbti.MainResult =
-    {
-      import BasicCommandStrings.runEarly
-      runManaged(initialState(configuration,
-        BuiltinCommands.ScriptCommands,
-        runEarly(Level.Error.toString) :: Script.Name :: Nil)
-      )
-    }
+    new XMainConfiguration().run("ScriptMain", configuration)
 }
+private[sbt] object ScriptMain {
+  private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult = {
+    import BasicCommandStrings.runEarly
+    val state = StandardMain.initialState(
+      xMain.dealiasBaseDirectory(configuration),
+      BuiltinCommands.ScriptCommands,
+      runEarly(Level.Error.toString) :: Script.Name :: Nil
+    )
+    StandardMain.runManaged(state)
+  }
+}
+
 final class ConsoleMain extends xsbti.AppMain {
   def run(configuration: xsbti.AppConfiguration): xsbti.MainResult =
-    runManaged(initialState(configuration,
+    new XMainConfiguration().run("ConsoleMain", configuration)
+}
+private[sbt] object ConsoleMain {
+  private[sbt] def run(configuration: xsbti.AppConfiguration): xsbti.MainResult = {
+    val state = StandardMain.initialState(
+      xMain.dealiasBaseDirectory(configuration),
       BuiltinCommands.ConsoleCommands,
-      IvyConsole.Name :: Nil)
+      IvyConsole.Name :: Nil
     )
+    StandardMain.runManaged(state)
+  }
 }
 
 object StandardMain {
-  def runManaged(s: State): xsbti.MainResult =
-    {
-      val previous = TrapExit.installManager()
-      try MainLoop.runLogged(s)
-      finally TrapExit.uninstallManager(previous)
+  private[sbt] lazy val exchange = new CommandExchange()
+  // The access to the pool should be thread safe because lazy val instantiation is thread safe
+  // and pool is only referenced directly in closeRunnable after the executionContext is sure
+  // to have been instantiated
+  private[this] var pool: Option[ForkJoinPool] = None
+  private[sbt] lazy val executionContext: ExecutionContext = ExecutionContext.fromExecutor({
+    val p = new ForkJoinPool
+    pool = Some(p)
+    p
+  })
+
+  private[this] val closeRunnable = () => {
+    exchange.shutdown()
+    pool.foreach(_.shutdownNow())
+  }
+
+  private[this] val isShutdown = new AtomicBoolean(false)
+  def runManaged(s: State): xsbti.MainResult = {
+    val previous = TrapExit.installManager()
+    try {
+      val hook = ShutdownHooks.add(closeRunnable)
+      try {
+        MainLoop.runLogged(s)
+      } catch {
+        case _: InterruptedException if isShutdown.get =>
+          new xsbti.Exit { override def code(): Int = 0 }
+      } finally {
+        try DefaultBackgroundJobService.shutdown()
+        finally hook.close()
+        ()
+      }
+    } finally {
+      TrapExit.uninstallManager(previous)
     }
+  }
 
   /** The common interface to standard output, used for all built-in ConsoleLoggers. */
-  val console = ConsoleOut.systemOutOverwrite(ConsoleOut.overwriteContaining("Resolving "))
+  val console: ConsoleOut =
+    ConsoleOut.systemOutOverwrite(ConsoleOut.overwriteContaining("Resolving "))
+  ConsoleOut.setGlobalProxy(console)
 
-  def initialGlobalLogging: GlobalLogging = GlobalLogging.initial(MainLogging.globalDefault(console), File.createTempFile("sbt", ".log"), console)
-
-  def initialState(configuration: xsbti.AppConfiguration, initialDefinitions: Seq[Command], preCommands: Seq[String]): State =
-    {
-      import BasicCommandStrings.isEarlyCommand
-      val userCommands = configuration.arguments.map(_.trim)
-      val (earlyCommands, normalCommands) = (preCommands ++ userCommands).partition(isEarlyCommand)
-      val commands = earlyCommands ++ normalCommands
-      val initAttrs = BuiltinCommands.initialAttributes
-      val s = State(configuration, initialDefinitions, Set.empty, None, commands, State.newHistory, initAttrs, initialGlobalLogging, State.Continue)
-      s.initializeClassLoaderCache
+  private[this] def initialGlobalLogging(file: Option[File]): GlobalLogging = {
+    def createTemp(attempt: Int = 0): File = Retry {
+      file.foreach(f => if (!f.exists()) IO.createDirectory(f))
+      File.createTempFile("sbt-global-log", ".log", file.orNull)
     }
+    GlobalLogging.initial(
+      MainAppender.globalDefault(ConsoleOut.globalProxy),
+      createTemp(),
+      ConsoleOut.globalProxy
+    )
+  }
+  def initialGlobalLogging(file: File): GlobalLogging = initialGlobalLogging(Option(file))
+  @deprecated("use version that takes file argument", "1.4.0")
+  def initialGlobalLogging: GlobalLogging = initialGlobalLogging(None)
+
+  def initialState(
+      configuration: xsbti.AppConfiguration,
+      initialDefinitions: Seq[Command],
+      preCommands: Seq[String]
+  ): State = {
+    // This is to workaround https://github.com/sbt/io/issues/110
+    sys.props.put("jna.nosys", "true")
+
+    import BasicCommandStrings.{ DashDashDetachStdio, DashDashServer, isEarlyCommand }
+    val userCommands =
+      configuration.arguments
+        .map(_.trim)
+        .filterNot(c => c == DashDashDetachStdio || c == DashDashServer)
+    val (earlyCommands, normalCommands) = (preCommands ++ userCommands).partition(isEarlyCommand)
+    val commands = (earlyCommands ++ normalCommands).toList map { x =>
+      Exec(x, None)
+    }
+    val initAttrs = BuiltinCommands.initialAttributes
+    val s = State(
+      configuration,
+      initialDefinitions,
+      Set.empty,
+      None,
+      commands,
+      State.newHistory,
+      initAttrs,
+      initialGlobalLogging(BuildPaths.globalLoggingStandard(configuration.baseDirectory)),
+      None,
+      State.Continue
+    )
+    s.initializeClassLoaderCache
+  }
 }
 
-import DefaultParsers._
+import sbt.BasicCommandStrings._
+import sbt.BasicCommands._
+import sbt.CommandUtil._
+import sbt.TemplateCommandUtil.templateCommand
 import sbt.internal.CommandStrings._
-import BasicCommandStrings._
-import BasicCommands._
-import CommandUtil._
+import sbt.internal.util.complete.DefaultParsers._
 
 object BuiltinCommands {
   def initialAttributes = AttributeMap.empty
+  import BasicCommands.exit
+  def ConsoleCommands: Seq[Command] =
+    Seq(ignore, exit, IvyConsole.command, setLogLevel, early, act, nop)
 
-  def ConsoleCommands: Seq[Command] = Seq(ignore, exit, IvyConsole.command, setLogLevel, early, act, nop)
-  def ScriptCommands: Seq[Command] = Seq(ignore, exit, Script.command, setLogLevel, early, act, nop)
-  def DefaultCommands: Seq[Command] = Seq(ignore, help, completionsCommand, about, tasks, settingsCommand, loadProject,
-    projects, project, reboot, read, history, set, sessionCommand, inspect, loadProjectImpl, loadFailed, Cross.crossBuild, Cross.switchVersion,
-    Cross.crossRestoreSession, setOnFailure, clearOnFailure, stashOnFailure, popOnFailure, setLogLevel, plugin, plugins,
-    ifLast, multi, shell, BasicCommands.server, continuous, eval, alias, append, last, lastGrep, export, boot, nop, call, exit, early, initialize, act) ++
-    compatCommands
-  def DefaultBootCommands: Seq[String] = LoadProject :: (IfLast + " " + Shell) :: Nil
+  def ScriptCommands: Seq[Command] =
+    Seq(ignore, exit, Script.command, setLogLevel, early, act, nop)
+
+  @nowarn
+  def DefaultCommands: Seq[Command] =
+    Seq(
+      multi,
+      about,
+      tasks,
+      settingsCommand,
+      loadProject,
+      templateCommand,
+      projects,
+      project,
+      set,
+      sessionCommand,
+      inspect,
+      loadProjectImpl,
+      loadFailed,
+      oldLoadFailed,
+      Cross.crossBuild,
+      Cross.switchVersion,
+      CrossJava.switchJavaHome,
+      CrossJava.crossJavaHome,
+      PluginCross.pluginCross,
+      PluginCross.pluginSwitch,
+      Cross.crossRestoreSession,
+      setLogLevel,
+      plugin,
+      plugins,
+      addPluginSbtFile,
+      writeSbtVersion,
+      skipBanner,
+      notifyUsersAboutShell,
+      shell,
+      rebootNetwork,
+      startServer,
+      eval,
+      last,
+      oldLastGrep,
+      lastGrep,
+      export,
+      boot,
+      initialize,
+      act,
+      continuous,
+      clearCaches,
+      NetworkChannel.disconnect,
+      waitCmd,
+      promptChannel,
+    ) ++
+      allBasicCommands ++
+      ContinuousCommands.value ++
+      BuildServerProtocol.commands
+
+  def DefaultBootCommands: Seq[String] =
+    WriteSbtVersion :: LoadProject :: NotifyUsersAboutShell :: s"$IfLast $Shell" :: Nil
 
   def boot = Command.make(BootCommand)(bootParser)
 
-  def about = Command.command(AboutCommand, aboutBrief, aboutDetailed) { s => s.log.info(aboutString(s)); s }
+  def about = Command.command(AboutCommand, aboutBrief, aboutDetailed) { s =>
+    s.log.info(aboutString(s)); s
+  }
 
   def setLogLevel = Command.arb(const(logLevelParser), logLevelHelp)(LogManager.setGlobalLogLevel)
-  private[this] def logLevelParser: Parser[Level.Value] = oneOf(Level.values.toSeq.map(v => v.toString ^^^ v))
+  private[this] def logLevelParser: Parser[Level.Value] =
+    oneOf(Level.values.toSeq.map(v => v.toString ^^^ v))
 
   // This parser schedules the default boot commands unless overridden by an alias
-  def bootParser(s: State) =
-    {
-      val orElse = () => DefaultBootCommands ::: s
-      delegateToAlias(BootCommand, success(orElse))(s)
-    }
+  def bootParser(s: State) = {
+    val orElse = () => DefaultBootCommands.toList ::: s
+    delegateToAlias(BootCommand, success(orElse))(s)
+  }
 
   def sbtName(s: State): String = s.configuration.provider.id.name
   def sbtVersion(s: State): String = s.configuration.provider.id.version
@@ -143,41 +357,81 @@ object BuiltinCommands {
       current + built + aboutPlugins(e)
     } else "No project is currently loaded"
 
-  def aboutPlugins(e: Extracted): String =
-    {
-      def list(b: BuildUnit) = b.plugins.detected.autoPlugins.map(_.value.label)
-      val allPluginNames = e.structure.units.values.flatMap(u => list(u.unit)).toSeq.distinct
-      if (allPluginNames.isEmpty) "" else allPluginNames.mkString("Available Plugins: ", ", ", "")
+  def aboutPlugins(e: Extracted): String = {
+    def plugins(lbu: LoadedBuildUnit) =
+      lbu.unit.plugins.detected.autoPlugins
+        .map(_.value.label)
+
+    val allPluginNames =
+      e.structure.units.values
+        .flatMap(plugins)
+        .toList
+        .distinct
+        .sorted
+
+    if (allPluginNames.isEmpty)
+      ""
+    else
+      ("Available Plugins" +: allPluginNames)
+        .mkString("\n - ")
+  }
+
+  def aboutScala(s: State, e: Extracted): String = {
+    val scalaVersion = e.getOpt(Keys.scalaVersion)
+    val scalaHome = e.getOpt(Keys.scalaHome).flatMap(idFun)
+    val instance =
+      e.getOpt(Keys.scalaInstance).flatMap(_ => quiet(e.runTask(Keys.scalaInstance, s)._2))
+    (scalaVersion, scalaHome, instance) match {
+      case (sv, Some(home), Some(si)) =>
+        "local Scala version " + selectScalaVersion(sv, si) + " at " + home.getAbsolutePath
+      case (_, Some(home), None)  => "a local Scala build at " + home.getAbsolutePath
+      case (sv, None, Some(si))   => "Scala " + selectScalaVersion(sv, si)
+      case (Some(sv), None, None) => "Scala " + sv
+      case (None, None, None)     => ""
     }
-  def aboutScala(s: State, e: Extracted): String =
-    {
-      val scalaVersion = e.getOpt(Keys.scalaVersion)
-      val scalaHome = e.getOpt(Keys.scalaHome).flatMap(idFun)
-      val instance = e.getOpt(Keys.scalaInstance).flatMap(_ => quiet(e.runTask(Keys.scalaInstance, s)._2))
-      (scalaVersion, scalaHome, instance) match {
-        case (sv, Some(home), Some(si)) => "local Scala version " + selectScalaVersion(sv, si) + " at " + home.getAbsolutePath
-        case (_, Some(home), None)      => "a local Scala build at " + home.getAbsolutePath
-        case (sv, None, Some(si))       => "Scala " + selectScalaVersion(sv, si)
-        case (Some(sv), None, None)     => "Scala " + sv
-        case (None, None, None)         => ""
-      }
-    }
-  def aboutString(s: State): String =
-    {
-      val (name, ver, scalaVer, about) = (sbtName(s), sbtVersion(s), scalaVersion(s), aboutProject(s))
-      """This is %s %s
+  }
+
+  def aboutString(s: State): String = {
+    val (name, ver, scalaVer, about) =
+      (sbtName(s), sbtVersion(s), scalaVersion(s), aboutProject(s))
+    """This is %s %s
 			|%s
 			|%s, %s plugins, and build definitions are using Scala %s
 			|""".stripMargin.format(name, ver, about, name, name, scalaVer)
+  }
+
+  private[this] def selectScalaVersion(sv: Option[String], si: ScalaInstance): String =
+    sv match {
+      case Some(si.version) => si.version
+      case _                => si.actualVersion
     }
-  private[this] def selectScalaVersion(sv: Option[String], si: ScalaInstance): String = sv match { case Some(si.version) => si.version; case _ => si.actualVersion }
-  private[this] def quiet[T](t: => T): Option[T] = try { Some(t) } catch { case e: Exception => None }
 
-  def settingsCommand = showSettingLike(SettingsCommand, settingsPreamble, KeyRanks.MainSettingCutoff, key => !isTask(key.manifest))
+  private[this] def quiet[T](t: => T): Option[T] =
+    try Some(t)
+    catch { case _: Exception => None }
 
-  def tasks = showSettingLike(TasksCommand, tasksPreamble, KeyRanks.MainTaskCutoff, key => isTask(key.manifest))
+  def settingsCommand: Command =
+    showSettingLike(
+      SettingsCommand,
+      settingsPreamble,
+      KeyRanks.MainSettingCutoff,
+      key => !isTask(key.manifest)
+    )
 
-  def showSettingLike(command: String, preamble: String, cutoff: Int, keep: AttributeKey[_] => Boolean) =
+  def tasks: Command =
+    showSettingLike(
+      TasksCommand,
+      tasksPreamble,
+      KeyRanks.MainTaskCutoff,
+      key => isTask(key.manifest)
+    )
+
+  def showSettingLike(
+      command: String,
+      preamble: String,
+      cutoff: Int,
+      keep: AttributeKey[_] => Boolean
+  ): Command =
     Command(command, settingsBrief(command), settingsDetailed(command))(showSettingParser(keep)) {
       case (s: State, (verbosity: Int, selected: Option[String])) =>
         if (selected.isEmpty) System.out.println(preamble)
@@ -188,87 +442,124 @@ object BuiltinCommands {
         if (prominentOnly) System.out.println(moreAvailableMessage(command, selected.isDefined))
         s
     }
-  def showSettingParser(keepKeys: AttributeKey[_] => Boolean)(s: State): Parser[(Int, Option[String])] =
+  def showSettingParser(
+      keepKeys: AttributeKey[_] => Boolean
+  )(s: State): Parser[(Int, Option[String])] =
     verbosityParser ~ selectedParser(s, keepKeys).?
   def selectedParser(s: State, keepKeys: AttributeKey[_] => Boolean): Parser[String] =
     singleArgument(allTaskAndSettingKeys(s).filter(keepKeys).map(_.label).toSet)
-  def verbosityParser: Parser[Int] = success(1) | ((Space ~ "-") ~> (
-    'v'.id.+.map(_.size + 1) |
-    ("V" ^^^ Int.MaxValue)
-  ))
-  def taskDetail(keys: Seq[AttributeKey[_]]): Seq[(String, String)] =
-    sortByLabel(withDescription(keys)) flatMap taskStrings
+  def verbosityParser: Parser[Int] =
+    success(1) | ((Space ~ "-") ~> (
+      'v'.id.+.map(_.size + 1) |
+        ("V" ^^^ Int.MaxValue)
+    ))
 
-  def allTaskAndSettingKeys(s: State): Seq[AttributeKey[_]] =
-    {
-      val extracted = Project.extract(s)
-      import extracted._
-      val index = structure.index
-      index.keyIndex.keys(Some(currentRef)).toSeq.map { key =>
-        try
-          Some(index.keyMap(key))
+  def taskDetail(keys: Seq[AttributeKey[_]], firstOnly: Boolean): Seq[(String, String)] =
+    sortByLabel(withDescription(keys)) flatMap { t =>
+      taskStrings(t, firstOnly)
+    }
+
+  def taskDetail(keys: Seq[AttributeKey[_]]): Seq[(String, String)] =
+    taskDetail(keys, false)
+
+  def allTaskAndSettingKeys(s: State): Seq[AttributeKey[_]] = {
+    val extracted = Project.extract(s)
+    import extracted._
+    val index = structure.index
+    index.keyIndex
+      .keys(Some(currentRef))
+      .toSeq
+      .map { key =>
+        try Some(index.keyMap(key))
         catch {
           case NonFatal(ex) =>
-            s.log error ex.getMessage
+            s.log debug ex.getMessage
             None
         }
-      }.collect { case Some(s) => s }.distinct
-    }
+      }
+      .collect { case Some(s) => s }
+      .distinct
+  }
 
   def sortByLabel(keys: Seq[AttributeKey[_]]): Seq[AttributeKey[_]] = keys.sortBy(_.label)
   def sortByRank(keys: Seq[AttributeKey[_]]): Seq[AttributeKey[_]] = keys.sortBy(_.rank)
-  def withDescription(keys: Seq[AttributeKey[_]]): Seq[AttributeKey[_]] = keys.filter(_.description.isDefined)
-  def isTask(mf: Manifest[_])(implicit taskMF: Manifest[Task[_]], inputMF: Manifest[InputTask[_]]): Boolean =
+  def withDescription(keys: Seq[AttributeKey[_]]): Seq[AttributeKey[_]] =
+    keys.filter(_.description.isDefined)
+  def isTask(
+      mf: Manifest[_]
+  )(implicit taskMF: Manifest[Task[_]], inputMF: Manifest[InputTask[_]]): Boolean =
     mf.runtimeClass == taskMF.runtimeClass || mf.runtimeClass == inputMF.runtimeClass
   def topNRanked(n: Int) = (keys: Seq[AttributeKey[_]]) => sortByRank(keys).take(n)
-  def highPass(rankCutoff: Int) = (keys: Seq[AttributeKey[_]]) => sortByRank(keys).takeWhile(_.rank <= rankCutoff)
+  def highPass(rankCutoff: Int) =
+    (keys: Seq[AttributeKey[_]]) => sortByRank(keys).takeWhile(_.rank <= rankCutoff)
 
-  def tasksHelp(s: State, filter: Seq[AttributeKey[_]] => Seq[AttributeKey[_]], arg: Option[String]): String =
-    {
-      val commandAndDescription = taskDetail(filter(allTaskAndSettingKeys(s)))
-      arg match {
-        case Some(selected) => detail(selected, commandAndDescription.toMap)
-        case None           => aligned("  ", "   ", commandAndDescription) mkString ("\n", "\n", "")
-      }
+  def tasksHelp(
+      s: State,
+      filter: Seq[AttributeKey[_]] => Seq[AttributeKey[_]],
+      arg: Option[String]
+  ): String = {
+    val commandAndDescription = taskDetail(filter(allTaskAndSettingKeys(s)), true)
+    arg match {
+      case Some(selected) => detail(selected, commandAndDescription.toMap)
+      case None           => aligned("  ", "   ", commandAndDescription) mkString ("\n", "\n", "")
+    }
+  }
+
+  def taskStrings(key: AttributeKey[_], firstOnly: Boolean): Option[(String, String)] =
+    key.description map { d =>
+      if (firstOnly) (key.label, d.split("\r?\n")(0)) else (key.label, d)
     }
 
-  def taskStrings(key: AttributeKey[_]): Option[(String, String)] = key.description map { d => (key.label, d) }
+  def taskStrings(key: AttributeKey[_]): Option[(String, String)] = taskStrings(key, false)
 
   def defaults = Command.command(DefaultsCommand) { s =>
     s.copy(definedCommands = DefaultCommands)
   }
 
-  def initialize = Command.command(InitCommand) { s =>
-    /*"load-commands -base ~/.sbt/commands" :: */ readLines(readable(sbtRCs(s))) ::: s
+  def initialize: Command = Command.command(InitCommand) { s =>
+    /*"load-commands -base ~/.sbt/commands" :: */
+    readLines(readable(sbtRCs(s))).toList ::: s
   }
 
-  def eval = Command.single(EvalCommand, Help.more(EvalCommand, evalDetailed)) { (s, arg) =>
-    if (Project.isProjectLoaded(s)) loadedEval(s, arg) else rawEval(s, arg)
-    s
+  def eval: Command = Command.single(EvalCommand, Help.more(EvalCommand, evalDetailed)) {
+    (s, arg) =>
+      if (Project.isProjectLoaded(s)) loadedEval(s, arg) else rawEval(s, arg)
+      s
   }
+
+  def continuous: Command = Continuous.continuous
+
   private[this] def loadedEval(s: State, arg: String): Unit = {
     val extracted = Project extract s
     import extracted._
-    val result = session.currentEval().eval(arg, srcName = "<eval>", imports = autoImports(extracted))
+    val result =
+      session.currentEval().eval(arg, srcName = "<eval>", imports = autoImports(extracted))
     s.log.info(s"ans: ${result.tpe} = ${result.getValue(currentLoader)}")
   }
+
   private[this] def rawEval(s: State, arg: String): Unit = {
     val app = s.configuration.provider
     val classpath = app.mainClasspath ++ app.scalaProvider.jars
-    val result = Load.mkEval(classpath, s.baseDir, Nil).eval(arg, srcName = "<eval>", imports = new EvalImports(Nil, ""))
+    val result = Load
+      .mkEval(classpath, s.baseDir, Nil)
+      .eval(arg, srcName = "<eval>", imports = new EvalImports(Nil, ""))
     s.log.info(s"ans: ${result.tpe} = ${result.getValue(app.loader)}")
   }
-  def sessionCommand = Command.make(SessionCommand, sessionBrief, SessionSettings.Help)(SessionSettings.command)
-  def reapply(newSession: SessionSettings, structure: BuildStructure, s: State): State =
-    {
-      s.log.info("Reapplying settings...")
-      // Here, for correct behavior, we also need to re-inject a settings logger, as we'll be re-evaluating settings.
-      val loggerInject = LogManager.settingsLogger(s)
-      val withLogger = newSession.appendRaw(loggerInject :: Nil)
-      val newStructure = Load.reapply(withLogger.mergeSettings, structure)(Project.showContextKey(newSession, structure))
-      Project.setProject(newSession, newStructure, s)
-    }
-  def set = Command(SetCommand, setBrief, setDetailed)(setParser) {
+
+  def sessionCommand: Command =
+    Command.make(SessionCommand, sessionBrief, SessionSettings.Help)(SessionSettings.command)
+
+  def reapply(newSession: SessionSettings, structure: BuildStructure, s: State): State = {
+    s.log.info("Reapplying settings...")
+    // For correct behavior, we also need to re-inject a settings logger, as we'll be re-evaluating settings
+    val loggerInject = LogManager.settingsLogger(s)
+    val withLogger = newSession.appendRaw(loggerInject :: Nil)
+    val show = Project.showContextKey2(newSession)
+    val newStructure = Load.reapply(withLogger.mergeSettings, structure)(show)
+    Project.setProject(newSession, newStructure, s)
+  }
+
+  def set: Command = Command(SetCommand, setBrief, setDetailed)(setParser) {
     case (s, (all, arg)) =>
       val extracted = Project extract s
       import extracted._
@@ -285,33 +576,69 @@ object BuiltinCommands {
         arg,
         LineRange(0, 0)
       )(cl)
-      val setResult = if (all) SettingCompletions.setAll(extracted, settings) else SettingCompletions.setThis(s, extracted, settings, arg)
+      val setResult =
+        if (all) SettingCompletions.setAll(extracted, settings)
+        else SettingCompletions.setThis(extracted, settings, arg)
       s.log.info(setResult.quietSummary)
       s.log.debug(setResult.verboseSummary)
       reapply(setResult.session, structure, s)
   }
-  // @deprecated("Use SettingCompletions.setThis", "0.13.0")
-  def setThis(s: State, extracted: Extracted, settings: Seq[Def.Setting[_]], arg: String) =
-    SettingCompletions.setThis(s, extracted, settings, arg)
-  def inspect = Command(InspectCommand, inspectBrief, inspectDetailed)(Inspect.parser) {
-    case (s, (option, sk)) =>
-      s.log.info(Inspect.output(s, option, sk))
+
+  @deprecated("Use variant that doesn't take a State", "1.1.1")
+  def setThis(
+      s: State,
+      extracted: Extracted,
+      settings: Seq[Def.Setting[_]],
+      arg: String
+  ): SetResult =
+    setThis(extracted, settings, arg)
+
+  def setThis(
+      extracted: Extracted,
+      settings: Seq[Def.Setting[_]],
+      arg: String
+  ): SetResult =
+    SettingCompletions.setThis(extracted, settings, arg)
+
+  def inspect: Command = Command(InspectCommand, inspectBrief, inspectDetailed)(Inspect.parser) {
+    case (s, f) =>
+      s.log.info(f())
       s
   }
 
-  @deprecated("Use Inspect.output", "0.13.0")
-  def inspectOutput(s: State, option: Inspect.Mode, sk: Def.ScopedKey[_]): String = Inspect.output(s, option, sk)
+  @deprecated("Use `lastGrep` instead.", "1.2.0")
+  def oldLastGrep: Command =
+    lastGrepCommand(OldLastGrepCommand, oldLastGrepBrief, oldLastGrepDetailed, { s =>
+      lastGrepParser(s)
+    })
 
-  def lastGrep = Command(LastGrepCommand, lastGrepBrief, lastGrepDetailed)(lastGrepParser) {
-    case (s, (pattern, Some(sks))) =>
-      val (str, _, display) = extractLast(s)
-      Output.lastGrep(sks, str.streams(s), pattern, printLast(s))(display)
-      keepLastLog(s)
-    case (s, (pattern, None)) =>
-      for (logFile <- lastLogFile(s)) yield Output.lastGrep(logFile, pattern, printLast(s))
-      keepLastLog(s)
-  }
-  def extractLast(s: State) = {
+  def lastGrep: Command =
+    lastGrepCommand(LastGrepCommand, lastGrepBrief, lastGrepDetailed, lastGrepParser)
+
+  private def lastGrepCommand(
+      name: String,
+      briefHelp: (String, String),
+      detail: String,
+      parser: State => Parser[(String, Option[AnyKeys])]
+  ): Command =
+    Command(name, briefHelp, detail)(parser) { (s: State, sks: (String, Option[AnyKeys])) =>
+      {
+        if (name == OldLastGrepCommand)
+          s.log.warn(deprecationWarningText(OldLastGrepCommand, LastGrepCommand))
+
+        (s, sks) match {
+          case (s, (pattern, Some(sks))) =>
+            val (str, _, display) = extractLast(s)
+            Output.lastGrep(sks, str.streams(s), pattern, printLast)(display)
+            keepLastLog(s)
+          case (s, (pattern, None)) =>
+            for (logFile <- lastLogFile(s)) yield Output.lastGrep(logFile, pattern, printLast)
+            keepLastLog(s)
+        }
+      }
+    }
+
+  def extractLast(s: State): (BuildStructure, Select[ProjectRef], Show[Def.ScopedKey[_]]) = {
     val ext = Project.extract(s)
     (ext.structure, Select(ext.currentRef), ext.showKey)
   }
@@ -323,65 +650,74 @@ object BuiltinCommands {
       SettingCompletions.settingParser(structure.data, structure.index.keyMap, currentProject)
   }
 
-  @deprecated("Use Inspect.parser", "0.13.0")
-  def inspectParser: State => Parser[(Inspect.Mode, Def.ScopedKey[_])] = Inspect.parser
+  import Def.ScopedKey
+  type KeysParser = Parser[Seq[ScopedKey[T]] forSome { type T }]
 
-  @deprecated("Use Inspect.spacedModeParser", "0.13.0")
-  val spacedModeParser: State => Parser[Inspect.Mode] = Inspect.spacedModeParser
+  val spacedAggregatedParser: State => KeysParser = (s: State) =>
+    Act.requireSession(s, token(Space) ~> Act.aggregatedKeyParser(s))
 
-  @deprecated("Use Inspect.allKeyParser", "0.13.0")
-  def allKeyParser(s: State): Parser[AttributeKey[_]] = Inspect.allKeyParser(s)
+  val aggregatedKeyValueParser: State => Parser[Option[AnyKeys]] = (s: State) =>
+    spacedAggregatedParser(s).map(x => Act.keyValues(s)(x)).?
 
-  @deprecated("Use Inspect.spacedKeyParser", "0.13.0")
-  val spacedKeyParser: State => Parser[Def.ScopedKey[_]] = Inspect.spacedKeyParser
+  val exportParser: State => Parser[() => State] = (s: State) =>
+    Act.requireSession(s, token(Space) ~> exportParser0(s))
 
-  val spacedAggregatedParser = (s: State) => Act.requireSession(s, token(Space) ~> Act.aggregatedKeyParser(s))
-  val aggregatedKeyValueParser: State => Parser[Option[AnyKeys]] = (s: State) => spacedAggregatedParser(s).map(x => Act.keyValues(s)(x)).?
-
-  val exportParser: State => Parser[() => State] = (s: State) => Act.requireSession(s, token(Space) ~> exportParser0(s))
-  private[sbt] def exportParser0(s: State): Parser[() => State] =
-    {
-      val extracted = Project extract s
-      import extracted.{ showKey, structure }
-      val keysParser = token(flag("--last" <~ Space)) ~ Act.aggregatedKeyParser(extracted)
-      val show = Aggregation.ShowConfig(settingValues = true, taskValues = false, print = println _, success = false)
-      for {
-        lastOnly_keys <- keysParser
-        kvs = Act.keyValues(structure)(lastOnly_keys._2)
-        f <- if (lastOnly_keys._1) success(() => s) else Aggregation.evaluatingParser(s, structure, show)(kvs)
-      } yield () => {
-        def export0(s: State): State = lastImpl(s, kvs, Some(ExportStream))
-        val newS = try f() catch {
-          case NonFatal(e) =>
-            try export0(s)
-            finally { throw e }
-        }
-        export0(newS)
+  private[sbt] def exportParser0(s: State): Parser[() => State] = {
+    val extracted = Project extract s
+    import extracted.{ showKey, structure }
+    val keysParser = token(flag("--last" <~ Space)) ~ Act.aggregatedKeyParser(extracted)
+    val show = Aggregation.ShowConfig(
+      settingValues = true,
+      taskValues = false,
+      print = println(_),
+      success = false
+    )
+    for {
+      lastOnly_keys <- keysParser
+      kvs = Act.keyValues(structure)(lastOnly_keys._2)
+      f <- if (lastOnly_keys._1) success(() => s)
+      else Aggregation.evaluatingParser(s, show)(kvs)
+    } yield () => {
+      def export0(s: State): State = lastImpl(s, kvs, Some(ExportStream))
+      val newS = try f()
+      catch {
+        case NonFatal(e) =>
+          try export0(s)
+          finally {
+            throw e
+          }
       }
+      export0(newS)
     }
+  }
 
-  def lastGrepParser(s: State) = Act.requireSession(s, (token(Space) ~> token(NotSpace, "<pattern>")) ~ aggregatedKeyValueParser(s))
-  def last = Command(LastCommand, lastBrief, lastDetailed)(aggregatedKeyValueParser) {
+  def lastGrepParser(s: State): Parser[(String, Option[AnyKeys])] =
+    Act.requireSession(
+      s,
+      (token(Space) ~> token(NotSpace, "<pattern>")) ~ aggregatedKeyValueParser(s)
+    )
+
+  def last: Command = Command(LastCommand, lastBrief, lastDetailed)(aggregatedKeyValueParser) {
     case (s, Some(sks)) => lastImpl(s, sks, None)
     case (s, None) =>
-      for (logFile <- lastLogFile(s)) yield Output.last(logFile, printLast(s))
+      for (logFile <- lastLogFile(s)) yield Output.last(logFile, printLast)
       keepLastLog(s)
   }
-  def export = Command(ExportCommand, exportBrief, exportDetailed)(exportParser)((s, f) => f())
 
-  private[this] def lastImpl(s: State, sks: AnyKeys, sid: Option[String]): State =
-    {
-      val (str, _, display) = extractLast(s)
-      Output.last(sks, str.streams(s), printLast(s), sid)(display)
-      keepLastLog(s)
-    }
+  def export: Command =
+    Command(ExportCommand, exportBrief, exportDetailed)(exportParser)((_, f) => f())
+
+  private[this] def lastImpl(s: State, sks: AnyKeys, sid: Option[String]): State = {
+    val (str, _, display) = extractLast(s)
+    Output.last(sks, str.streams(s), printLast, sid)(display)
+    keepLastLog(s)
+  }
 
   /** Determines the log file that last* commands should operate on.  See also isLastOnly. */
-  def lastLogFile(s: State) =
-    {
-      val backing = s.globalLogging.backing
-      if (isLastOnly(s)) backing.last else Some(backing.file)
-    }
+  def lastLogFile(s: State): Option[File] = {
+    val backing = s.globalLogging.backing
+    if (isLastOnly(s)) backing.last else Some(backing.file)
+  }
 
   /**
    * If false, shift the current log file to be the log file that 'last' will operate on.
@@ -396,50 +732,71 @@ object BuiltinCommands {
    * the last* commands operate on any output since the last 'shell' command and do shift the log file.
    * Otherwise, the output since the previous 'shell' command is used and the log file is not shifted.
    */
-  def isLastOnly(s: State): Boolean = s.history.previous.forall(_ == Shell)
+  def isLastOnly(s: State): Boolean = s.history.previous.forall(_.commandLine == Shell)
 
-  def printLast(s: State): Seq[String] => Unit = _ foreach println
+  @deprecated("Use variant that doesn't take the state", "1.1.1")
+  def printLast(s: State): Seq[String] => Unit = printLast
 
-  def autoImports(extracted: Extracted): EvalImports = new EvalImports(imports(extracted), "<auto-imports>")
-  def imports(extracted: Extracted): Seq[(String, Int)] =
-    {
-      val curi = extracted.currentRef.build
-      extracted.structure.units(curi).imports.map(s => (s, -1))
-    }
+  def printLast: Seq[String] => Unit = _ foreach println
 
-  def listBuild(uri: URI, build: LoadedBuildUnit, current: Boolean, currentID: String, log: Logger) =
-    {
-      log.info("In " + uri)
-      def prefix(id: String) = if (currentID != id) "   " else if (current) " * " else "(*)"
-      for (id <- build.defined.keys.toSeq.sorted) log.info("\t" + prefix(id) + id)
-    }
+  def autoImports(extracted: Extracted): EvalImports =
+    new EvalImports(imports(extracted), "<auto-imports>")
+
+  def imports(extracted: Extracted): Seq[(String, Int)] = {
+    val curi = extracted.currentRef.build
+    extracted.structure.units(curi).imports.map(s => (s, -1))
+  }
+
+  def listBuild(
+      uri: URI,
+      build: LoadedBuildUnit,
+      current: Boolean,
+      currentID: String,
+      log: Logger
+  ): Unit = {
+    log.info(s"In $uri")
+    def prefix(id: String) = if (currentID != id) "   " else if (current) " * " else "(*)"
+    for (id <- build.defined.keys.toSeq.sorted) log.info("\t" + prefix(id) + id)
+  }
+
+  def act: Command = Command.customHelp(Act.actParser, actHelp)
+
+  def actHelp: State => Help = { s =>
+    CommandStrings.showHelp ++ CommandStrings.printHelp ++ CommandStrings.multiTaskHelp ++
+      keysHelp(s)
+  }
 
-  def act = Command.customHelp(Act.actParser, actHelp)
-  def actHelp = (s: State) => CommandStrings.showHelp ++ CommandStrings.multiTaskHelp ++ keysHelp(s)
   def keysHelp(s: State): Help =
     if (Project.isProjectLoaded(s))
       Help.detailOnly(taskDetail(allTaskAndSettingKeys(s)))
     else
       Help.empty
-  def plugins = Command.command(PluginsCommand, pluginsBrief, pluginsDetailed) { s =>
+
+  def plugins: Command = Command.command(PluginsCommand, pluginsBrief, pluginsDetailed) { s =>
     val helpString = PluginsDebug.helpAll(s)
     System.out.println(helpString)
     s
   }
+
   val pluginParser: State => Parser[AutoPlugin] = s => {
     val autoPlugins: Map[String, AutoPlugin] = PluginsDebug.autoPluginMap(s)
     token(Space) ~> Act.knownPluginParser(autoPlugins, "plugin")
   }
-  def plugin = Command(PluginCommand)(pluginParser) { (s, plugin) =>
+
+  def plugin: Command = Command(PluginCommand)(pluginParser) { (s, plugin) =>
     val helpString = PluginsDebug.help(plugin, s)
     System.out.println(helpString)
     s
   }
 
-  def projects = Command(ProjectsCommand, (ProjectsCommand, projectsBrief), projectsDetailed)(s => projectsParser(s).?) {
-    case (s, Some(modifyBuilds)) => transformExtraBuilds(s, modifyBuilds)
-    case (s, None)               => showProjects(s); s
-  }
+  def projects: Command =
+    Command(ProjectsCommand, (ProjectsCommand, projectsBrief), projectsDetailed)(
+      s => projectsParser(s).?
+    ) {
+      case (s, Some(modifyBuilds)) => transformExtraBuilds(s, modifyBuilds)
+      case (s, None)               => showProjects(s); s
+    }
+
   def showProjects(s: State): Unit = {
     val extracted = Project extract s
     import extracted._
@@ -447,96 +804,394 @@ object BuiltinCommands {
     listBuild(curi, structure.units(curi), true, cid, s.log)
     for ((uri, build) <- structure.units if curi != uri) listBuild(uri, build, false, cid, s.log)
   }
-  def transformExtraBuilds(s: State, f: List[URI] => List[URI]): State =
-    {
-      val original = Project.extraBuilds(s)
-      val extraUpdated = Project.updateExtraBuilds(s, f)
-      try doLoadProject(extraUpdated, LoadAction.Current)
-      catch {
-        case e: Exception =>
-          s.log.error("Project loading failed: reverting to previous state.")
-          Project.setExtraBuilds(s, original)
-      }
+
+  def transformExtraBuilds(s: State, f: List[URI] => List[URI]): State = {
+    val original = Project.extraBuilds(s)
+    val extraUpdated = Project.updateExtraBuilds(s, f)
+    try doLoadProject(extraUpdated, LoadAction.Current)
+    catch {
+      case _: Exception =>
+        s.log.error("Project loading failed: reverting to previous state.")
+        Project.setExtraBuilds(s, original)
+    }
+  }
+
+  def projectsParser(s: State): Parser[List[URI] => List[URI]] = {
+    val addBase = token(Space ~> "add") ~> token(Space ~> basicUri, "<build URI>").+
+    val removeBase = token(Space ~> "remove") ~> token(Space ~> Uri(Project.extraBuilds(s).toSet)).+
+    addBase.map(toAdd => (xs: List[URI]) => (toAdd.toList ::: xs).distinct) |
+      removeBase.map(toRemove => (xs: List[URI]) => xs.filterNot(toRemove.toSet))
+  }
+
+  def project: Command =
+    Command.make(ProjectCommand, projectBrief, projectDetailed)(ProjectNavigation.command)
+
+  def loadFailed: Command = Command(LoadFailed)(loadProjectParser)(doLoadFailed)
+  @deprecated("Use `loadFailed` instead.", "1.2.0")
+  def oldLoadFailed: Command =
+    Command(OldLoadFailed) { s =>
+      loadProjectParser(s)
+    } { (s: State, loadArg: String) =>
+      s.log.warn(
+        deprecationWarningText(OldLoadFailed, LoadFailed)
+      )
+      doLoadFailed(s, loadArg)
     }
 
-  def projectsParser(s: State): Parser[List[URI] => List[URI]] =
-    {
-      val addBase = token(Space ~> "add") ~> token(Space ~> basicUri, "<build URI>").+
-      val removeBase = token(Space ~> "remove") ~> token(Space ~> Uri(Project.extraBuilds(s).toSet)).+
-      addBase.map(toAdd => (xs: List[URI]) => (toAdd.toList ::: xs).distinct) |
-        removeBase.map(toRemove => (xs: List[URI]) => xs.filterNot(toRemove.toSet))
-    }
-
-  def project = Command.make(ProjectCommand, projectBrief, projectDetailed)(ProjectNavigation.command)
-
-  def loadFailed = Command(LoadFailed)(loadProjectParser)(doLoadFailed)
-
-  @deprecated("No longer used.", "0.13.2")
-  def handleLoadFailed(s: State): State = doLoadFailed(s, "")
+  private[this] def deprecationWarningText(oldCommand: String, newCommand: String) = {
+    s"The `$oldCommand` command is deprecated in favor of `$newCommand` and will be removed in a later version"
+  }
 
   @tailrec
-  private[this] def doLoadFailed(s: State, loadArg: String): State =
-    {
-      val result = (SimpleReader.readLine("Project loading failed: (r)etry, (q)uit, (l)ast, or (i)gnore? ") getOrElse Quit).toLowerCase(Locale.ENGLISH)
-      def matches(s: String) = !result.isEmpty && (s startsWith result)
-      def retry = loadProjectCommand(LoadProject, loadArg) :: s.clearGlobalLog
-      def ignoreMsg = if (Project.isProjectLoaded(s)) "using previously loaded project" else "no project loaded"
+  private[this] def doLoadFailed(s: State, loadArg: String): State = {
+    s.log.warn("Project loading failed: (r)etry, (q)uit, (l)ast, or (i)gnore? (default: r)")
+    val result = try ITerminal.get.withRawInput(System.in.read) match {
+      case -1 => 'q'.toInt
+      case b  => b
+    } catch { case _: ClosedChannelException => 'q' }
+    def retry: State = loadProjectCommand(LoadProject, loadArg) :: s.clearGlobalLog
+    def ignoreMsg: String =
+      if (Project.isProjectLoaded(s)) "using previously loaded project" else "no project loaded"
 
-      result match {
-        case ""                    => retry
-        case _ if matches("retry") => retry
-        case _ if matches(Quit)    => s.exit(ok = false)
-        case _ if matches("ignore") =>
-          s.log.warn(s"Ignoring load failure: $ignoreMsg."); s
-        case _ if matches("last") => LastCommand :: loadProjectCommand(LoadFailed, loadArg) :: s
-        case _                    => println("Invalid response."); doLoadFailed(s, loadArg)
-      }
+    result.toChar match {
+      case '\n' | '\r' => retry
+      case 'r' | 'R'   => retry
+      case 'q' | 'Q'   => s.exit(ok = false)
+      case 'i' | 'I'   => s.log.warn(s"Ignoring load failure: $ignoreMsg."); s
+      case 'l' | 'L'   => LastCommand :: loadProjectCommand(LoadFailed, loadArg) :: s
+      case c           => println(s"Invalid response: '$c'"); doLoadFailed(s, loadArg)
     }
+  }
 
-  def loadProjectCommands(arg: String) =
+  def loadProjectCommands(arg: String): List[String] =
     StashOnFailure ::
       (OnFailure + " " + loadProjectCommand(LoadFailed, arg)) ::
       loadProjectCommand(LoadProjectImpl, arg) ::
       PopOnFailure ::
       State.FailureWall ::
       Nil
-  def loadProject = Command(LoadProject, LoadProjectBrief, LoadProjectDetailed)(loadProjectParser) { (s, arg) => loadProjectCommands(arg) ::: s }
-  private[this] def loadProjectParser = (s: State) => matched(Project.loadActionParser)
-  private[this] def loadProjectCommand(command: String, arg: String): String = s"$command $arg".trim
 
-  def loadProjectImpl = Command(LoadProjectImpl)(_ => Project.loadActionParser)(doLoadProject)
-  def doLoadProject(s0: State, action: LoadAction.Value): State =
-    {
-      val (s1, base) = Project.loadAction(SessionVar.clear(s0), action)
-      IO.createDirectory(base)
-      val s = if (s1 has Keys.stateCompilerCache) s1 else registerCompilerCache(s1)
+  def loadProject: Command =
+    Command(LoadProject, LoadProjectBrief, LoadProjectDetailed)(loadProjectParser)(
+      (s, arg) => loadProjectCommands(arg) ::: s
+    )
 
-      val (eval, structure) =
-        try Load.defaultLoad(s, base, s.log, Project.inPluginProject(s), Project.extraBuilds(s))
-        catch {
-          case ex: compiler.EvalException =>
-            s0.log.debug(ex.getMessage)
-            ex.getStackTrace map (ste => s"\tat $ste") foreach (s0.log.debug(_))
-            ex.setStackTrace(Array.empty)
-            throw ex
-        }
+  private[this] def loadProjectParser: State => Parser[String] =
+    _ => matched(Project.loadActionParser)
 
-      val session = Load.initialSession(structure, eval, s0)
-      SessionSettings.checkSession(session, s)
-      Project.setProject(session, structure, s)
+  private[this] def loadProjectCommand(command: String, arg: String): String =
+    s"$command $arg".trim
+
+  def loadProjectImpl: Command =
+    Command(LoadProjectImpl)(_ => Project.loadActionParser)(doLoadProject)
+
+  def checkSBTVersionChanged(state: State): Unit = {
+    import sbt.io.syntax._
+    val sbtVersionProperty = "sbt.version"
+
+    // Don't warn if current version has been set in system properties
+    val sbtVersionSystemOpt =
+      Option(System.getProperty(sbtVersionProperty))
+
+    // the intention is to warn if build.properties file has changed during current sbt session
+    // a `reload` will not respect this change while `reboot` will.
+    val buildProps = state.baseDir / "project" / "build.properties"
+    val sbtVersionBuildOpt = if (buildProps.exists) {
+      val buildProperties = new Properties()
+      IO.load(buildProperties, buildProps)
+      Option(buildProperties.getProperty(sbtVersionProperty))
+    } else None
+
+    val sbtVersionOpt = sbtVersionSystemOpt.orElse(sbtVersionBuildOpt)
+
+    sbtVersionOpt.foreach { version =>
+      val appVersion = state.configuration.provider.id.version()
+      if (version != appVersion) {
+        state.log.warn(
+          s"sbt version mismatch, using: $appVersion, " +
+            s"""in build.properties: "$version", use 'reboot' to use the new value.""".stripMargin
+        )
+      }
     }
-  def registerCompilerCache(s: State): State =
-    {
-      val maxCompilers = System.getProperty("sbt.resident.limit")
-      val cache =
-        if (maxCompilers == null)
-          CompilerCache.fresh
-        else {
-          val num = try maxCompilers.toInt catch {
-            case e: NumberFormatException => throw new RuntimeException("Resident compiler limit must be an integer.", e)
+  }
+
+  private def welcomeBanner(state: State): Unit = {
+    import scala.util.Properties
+    val appVersion = state.configuration.provider.id.version()
+    val javaVersion = s"${Properties.javaVendor} Java ${Properties.javaVersion}"
+    state.log.info(s"welcome to sbt $appVersion ($javaVersion)")
+  }
+
+  def doLoadProject(s0: State, action: LoadAction.Value): State = {
+    welcomeBanner(s0)
+    checkSBTVersionChanged(s0)
+    val (s1, base) = Project.loadAction(SessionVar.clear(s0), action)
+    IO.createDirectory(base)
+    val s2 = if (s1 has Keys.stateCompilerCache) s1 else registerCompilerCache(s1)
+
+    val (eval, structure) =
+      try Load.defaultLoad(s2, base, s2.log, Project.inPluginProject(s2), Project.extraBuilds(s2))
+      catch {
+        case ex: compiler.EvalException =>
+          s0.log.debug(ex.getMessage)
+          ex.getStackTrace map (ste => s"\tat $ste") foreach (s0.log.debug(_))
+          ex.setStackTrace(Array.empty)
+          throw ex
+      }
+
+    val session = Load.initialSession(structure, eval, s0)
+    SessionSettings.checkSession(session, s2)
+    val s3 = Project.setProject(
+      session,
+      structure,
+      s2,
+      st => setupGlobalFileTreeRepository(addCacheStoreFactoryFactory(st))
+    )
+    val s4 = s3.put(Keys.useLog4J.key, Project.extract(s3).get(Keys.useLog4J))
+    // This is a workaround for the console task in dotty which uses the classloader cache.
+    // We need to override the top loader in that case so that it gets the forked jline.
+    s4.extendedClassLoaderCache.setParent(Project.extract(s4).get(Keys.scalaInstanceTopLoader))
+    addSuperShellParams(CheckBuildSources.init(LintUnused.lintUnusedFunc(s4)))
+  }
+
+  private val setupGlobalFileTreeRepository: State => State = { state =>
+    state.get(sbt.nio.Keys.globalFileTreeRepository).foreach(_.close())
+    state.put(sbt.nio.Keys.globalFileTreeRepository, FileTreeRepository.default)
+  }
+  private val addSuperShellParams: State => State = (s: State) => {
+    val extracted = Project.extract(s)
+    import scala.concurrent.duration._
+    val sleep = extracted.getOpt(Keys.superShellSleep).getOrElse(SysProp.supershellSleep.millis)
+    val threshold =
+      extracted.getOpt(Keys.superShellThreshold).getOrElse(SysProp.supershellThreshold)
+    val maxItems = extracted.getOpt(Keys.superShellMaxTasks).getOrElse(SysProp.supershellMaxTasks)
+    ITerminal.setConsoleProgressState(new ProgressState(1, maxItems))
+    s.put(Keys.superShellSleep.key, sleep)
+      .put(Keys.superShellThreshold.key, threshold)
+      .put(Keys.superShellMaxTasks.key, maxItems)
+  }
+  private val addCacheStoreFactoryFactory: State => State = (s: State) => {
+    val size = Project
+      .extract(s)
+      .getOpt(Keys.fileCacheSize)
+      .flatMap(SizeParser(_))
+      .getOrElse(SysProp.fileCacheSize)
+    s.get(Keys.cacheStoreFactoryFactory).foreach(_.close())
+    s.put(Keys.cacheStoreFactoryFactory, InMemoryCacheStore.factory(size))
+  }
+
+  def registerCompilerCache(s: State): State = {
+    s.get(Keys.stateCompilerCache).foreach(_.clear())
+    s.put(Keys.stateCompilerCache, CompilerCache.fresh)
+  }
+
+  def clearCaches: Command = {
+    val help = Help.more(ClearCaches, ClearCachesDetailed)
+    val f: State => State = registerCompilerCache _ andThen (_.initializeClassLoaderCache) andThen addCacheStoreFactoryFactory
+    Command.command(ClearCaches, help)(f)
+  }
+
+  private[sbt] def waitCmd: Command =
+    Command.arb(
+      _ => ContinuousCommands.waitWatch.examples() ~> " ".examples() ~> matched(any.*).examples()
+    ) { (s0, channel) =>
+      val exchange = StandardMain.exchange
+      exchange.channelForName(channel) match {
+        case Some(c) if ContinuousCommands.isInWatch(s0, c) =>
+          if (c.terminal.prompt != Prompt.Watch) {
+            c.terminal.setPrompt(Prompt.Watch)
+            c.prompt(ConsolePromptEvent(s0))
+          } else if (c.terminal.isSupershellEnabled) {
+            c.terminal.printStream.print(ConsoleAppender.ClearScreenAfterCursor)
+            c.terminal.printStream.flush()
           }
-          if (num <= 0) CompilerCache.fresh else CompilerCache(num)
-        }
-      s.put(Keys.stateCompilerCache, cache)
+
+          val s1 = exchange.run(s0)
+          val exec: Exec = getExec(s1, Duration.Inf)
+          val wait = s"${ContinuousCommands.waitWatch} $channel"
+          val onFailure =
+            s1.onFailure.map(of => if (of.commandLine == Shell) of.withCommandLine(wait) else of)
+          val waitExec = Exec(wait, None)
+          val remaining: List[Exec] = Exec(FailureWall, None) :: waitExec :: s1.remainingCommands
+          val newState = s1.copy(remainingCommands = exec +: remaining, onFailure = onFailure)
+          if (exec.commandLine.trim.isEmpty) newState
+          else newState.clearGlobalLog
+        case _ => s0
+      }
     }
+
+  private[sbt] def promptChannel = Command.arb(_ => reportParser(PromptChannel)) {
+    (state, channel) =>
+      if (channel == ConsoleChannel.defaultName) {
+        if (!state.remainingCommands.exists(_.commandLine == Shell))
+          state.copy(remainingCommands = state.remainingCommands ::: (Exec(Shell, None) :: Nil))
+        else state
+      } else {
+        StandardMain.exchange.channelForName(channel) match {
+          case Some(nc: NetworkChannel) => nc.prompt()
+          case _                        =>
+        }
+        state
+      }
+  }
+
+  private def getExec(state: State, interval: Duration): Exec = {
+    StandardMain.exchange.blockUntilNextExec(interval, Some(state), state.globalLogging.full)
+  }
+
+  def shell: Command = Command.command(Shell, Help.more(Shell, ShellDetailed)) { s0 =>
+    import sbt.internal.ConsolePromptEvent
+    val exchange = StandardMain.exchange
+    val welcomeState = displayWelcomeBanner(s0)
+    val s1 = exchange run welcomeState
+    /*
+     * It is possible for sbt processes to leak if two are started simultaneously
+     * by a remote client and only one is able to start a server. This seems to
+     * happen primarily on windows.
+     */
+    if (ITerminal.startedByRemoteClient && !exchange.hasServer) {
+      Exec(Shutdown, None) +: s1
+    } else {
+      if (ITerminal.console.prompt == Prompt.Batch) ITerminal.console.setPrompt(Prompt.Pending)
+      exchange prompt ConsolePromptEvent(s0)
+      val minGCInterval = Project
+        .extract(s1)
+        .getOpt(Keys.minForcegcInterval)
+        .getOrElse(GCUtil.defaultMinForcegcInterval)
+      val exec: Exec = getExec(s1, minGCInterval)
+      val newState = s1
+        .copy(
+          onFailure = Some(Exec(Shell, None)),
+          remainingCommands = exec +: Exec(Shell, None) +: s1.remainingCommands
+        )
+        .setInteractive(true)
+      val res =
+        if (exec.commandLine.trim.isEmpty) newState
+        else newState.clearGlobalLog
+      res
+    }
+  }
+
+  def rebootNetwork: Command = Command.arb(_ => (RebootNetwork: Parser[String]).examples()) {
+    (s, _) =>
+      StandardMain.exchange.reboot(s)
+      s
+  }
+  def startServer: Command =
+    Command.command(StartServer, Help.more(StartServer, StartServerDetailed)) { s0 =>
+      val exchange = StandardMain.exchange
+      exchange.runServer(s0)
+    }
+
+  private val sbtVersionRegex = """sbt\.version\s*=.*""".r
+  private def isSbtVersionLine(s: String) = sbtVersionRegex.pattern.matcher(s).matches()
+
+  private def writeSbtVersionUnconditionally(state: State) = {
+    val baseDir = state.baseDir
+    val sbtVersion = BuiltinCommands.sbtVersion(state)
+    val projectDir = baseDir / "project"
+    val buildProps = projectDir / "build.properties"
+
+    val buildPropsLines = if (buildProps.canRead) IO.readLines(buildProps) else Nil
+
+    val sbtVersionAbsent = buildPropsLines forall (!isSbtVersionLine(_))
+
+    if (sbtVersionAbsent) {
+      val warnMsg = s"No sbt.version set in project/build.properties, base directory: $baseDir"
+      try {
+        if (isSbtBuild(baseDir)) {
+          val line = s"sbt.version=$sbtVersion"
+          IO.writeLines(buildProps, line :: buildPropsLines)
+          state.log info s"Updated file $buildProps: set sbt.version to $sbtVersion"
+        } else
+          state.log warn warnMsg
+      } catch {
+        case _: IOException => state.log warn warnMsg
+      }
+    }
+  }
+
+  private def intendsToInvokeNew(state: State) =
+    state.remainingCommands exists (_.commandLine == TemplateCommand)
+
+  private def writeSbtVersion(state: State) =
+    if (SysProp.genBuildProps && !intendsToInvokeNew(state)) {
+      writeSbtVersionUnconditionally(state)
+    }
+
+  private def checkRoot(state: State): Unit =
+    if (SysProp.allowRootDir) ()
+    else {
+      val baseDir = state.baseDir
+      import scala.collection.JavaConverters._
+      // this should return / on Unix and C:\ for Windows.
+      val rootOpt = FileSystems.getDefault.getRootDirectories.asScala.toList.headOption
+      rootOpt foreach { root =>
+        if (baseDir.getAbsolutePath == root.toString) {
+          throw new IllegalStateException(
+            "cannot run sbt from root directory without -Dsbt.rootdir=true; see sbt/sbt#1458"
+          )
+        }
+      }
+    }
+
+  private def WriteSbtVersion = "writeSbtVersion"
+
+  private def writeSbtVersion: Command =
+    Command.command(WriteSbtVersion) { state =>
+      checkRoot(state)
+      writeSbtVersion(state)
+      state
+    }
+
+  private def intendsToInvokeCompile(state: State) =
+    state.remainingCommands exists (_.commandLine == Keys.compile.key.label)
+  private def hasRebooted(state: State) =
+    state.remainingCommands exists (_.commandLine == StartServer)
+
+  private def notifyUsersAboutShell(state: State): Unit = {
+    val suppress = Project extract state getOpt Keys.suppressSbtShellNotification getOrElse false
+    if (!suppress && intendsToInvokeCompile(state) && !hasRebooted(state))
+      state.log info "Executing in batch mode. For better performance use sbt's shell"
+  }
+
+  private def NotifyUsersAboutShell = "notifyUsersAboutShell"
+
+  private def notifyUsersAboutShell: Command =
+    Command.command(NotifyUsersAboutShell) { state =>
+      notifyUsersAboutShell(state); state
+    }
+
+  private[this] def skipWelcomeFile(state: State, version: String) = {
+    val base = BuildPaths.getGlobalBase(state).toPath
+    base.resolve("preferences").resolve(version).resolve(SkipBannerFileName)
+  }
+  private def displayWelcomeBanner(state: State): State = {
+    if (!state.get(bannerHasBeenShown).getOrElse(false)) {
+      try {
+        val version = sbtVersion(state)
+        val skipFile = skipWelcomeFile(state, version)
+        Files.createDirectories(skipFile.getParent)
+        val suppress = !SysProp.banner || Files.exists(skipFile)
+        if (!suppress) {
+          Banner(version).foreach(banner => state.log.info(banner))
+        }
+      } catch { case _: IOException => /* Don't let errors in this command prevent startup */ }
+      state.put(bannerHasBeenShown, true)
+    } else state
+  }
+  private[this] val bannerHasBeenShown =
+    AttributeKey[Boolean]("banner-has-been-shown", Int.MaxValue)
+  private[this] val SkipBannerFileName = "skip-banner"
+  private[this] val SkipBanner = "skipBanner"
+  private[this] def skipBanner: Command = Command.command(SkipBanner)(skipBanner)
+  private def skipBanner(state: State): State = {
+    val skipFile = skipWelcomeFile(state, sbtVersion(state))
+    try Files.createFile(skipFile)
+    catch {
+      case _: FileAlreadyExistsException =>
+      case e: IOException                => state.log.error(s"Couldn't create file $skipFile: $e")
+    }
+    state
+  }
 }
diff --git a/main/src/main/scala/sbt/MainLoop.scala b/main/src/main/scala/sbt/MainLoop.scala
new file mode 100644
index 000000000..351be3700
--- /dev/null
+++ b/main/src/main/scala/sbt/MainLoop.scala
@@ -0,0 +1,342 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.io.PrintWriter
+import java.util.concurrent.RejectedExecutionException
+import java.util.Properties
+
+import sbt.BasicCommandStrings.{ StashOnFailure, networkExecPrefix }
+import sbt.internal.ShutdownHooks
+import sbt.internal.langserver.ErrorCodes
+import sbt.internal.protocol.JsonRpcResponseError
+import sbt.internal.nio.CheckBuildSources.CheckBuildSourcesKey
+import sbt.internal.util.{ ErrorHandling, GlobalLogBacking, Prompt, Terminal => ITerminal }
+import sbt.internal.{ ShutdownHooks, TaskProgress }
+import sbt.io.{ IO, Using }
+import sbt.protocol._
+import sbt.util.{ Logger, LoggerContext }
+
+import scala.annotation.tailrec
+import scala.concurrent.duration._
+import scala.util.control.NonFatal
+import sbt.internal.FastTrackCommands
+import sbt.internal.SysProp
+
+object MainLoop {
+
+  /** Entry point to run the remaining commands in State with managed global logging.*/
+  def runLogged(state: State): xsbti.MainResult = {
+
+    // We've disabled jline shutdown hooks to prevent classloader leaks, and have been careful to always restore
+    // the jline terminal in finally blocks, but hitting ctrl+c prevents finally blocks from being executed, in that
+    // case the only way to restore the terminal is in a shutdown hook.
+    val shutdownHook = ShutdownHooks.add(ITerminal.restore)
+
+    try {
+      runLoggedLoop(state, state.globalLogging.backing)
+    } finally {
+      shutdownHook.close()
+      ()
+    }
+  }
+
+  /** Run loop that evaluates remaining commands and manages changes to global logging configuration.*/
+  @tailrec def runLoggedLoop(state: State, logBacking: GlobalLogBacking): xsbti.MainResult =
+    runAndClearLast(state, logBacking) match {
+      case ret: Return => // delete current and last log files when exiting normally
+        logBacking.file.delete()
+        deleteLastLog(logBacking)
+        ret.result
+      case clear: ClearGlobalLog => // delete previous log file, move current to previous, and start writing to a new file
+        deleteLastLog(logBacking)
+        runLoggedLoop(clear.state, logBacking.shiftNew())
+      case keep: KeepGlobalLog => // make previous log file the current log file
+        logBacking.file.delete
+        runLoggedLoop(keep.state, logBacking.unshift)
+    }
+
+  /** Runs the next sequence of commands, cleaning up global logging after any exceptions. */
+  def runAndClearLast(state: State, logBacking: GlobalLogBacking): RunNext = {
+    try runWithNewLog(state, logBacking)
+    catch {
+      case e: xsbti.FullReload =>
+        deleteLastLog(logBacking)
+        throw e // pass along a reboot request
+      case e: RebootCurrent =>
+        deleteLastLog(logBacking)
+        deleteCurrentArtifacts(state)
+        throw new xsbti.FullReload(e.arguments.toArray, false)
+      case NonFatal(e) =>
+        System.err.println(
+          "sbt appears to be exiting abnormally.\n  The log file for this session is at " + logBacking.file
+        )
+        deleteLastLog(logBacking)
+        throw e
+    }
+  }
+
+  /** Deletes the previous global log file. */
+  def deleteLastLog(logBacking: GlobalLogBacking): Unit =
+    logBacking.last.foreach(_.delete())
+
+  /** Deletes the current sbt artifacts from boot. */
+  private[sbt] def deleteCurrentArtifacts(state: State): Unit = {
+    import sbt.io.syntax._
+    val provider = state.configuration.provider
+    val appId = provider.id
+    // If we can obtain boot directory more accurately it'd be better.
+    val defaultBoot = BuildPaths.defaultGlobalBase / "boot"
+    val buildProps = state.baseDir / "project" / "build.properties"
+    // First try reading the sbt version from build.properties file.
+    val sbtVersionOpt = if (buildProps.exists) {
+      val buildProperties = new Properties()
+      IO.load(buildProperties, buildProps)
+      Option(buildProperties.getProperty("sbt.version"))
+    } else None
+    val sbtVersion = sbtVersionOpt.getOrElse(appId.version)
+    val currentArtDirs = defaultBoot * "*" / appId.groupID / appId.name / sbtVersion
+    currentArtDirs.get foreach { dir =>
+      state.log.info(s"deleting $dir")
+      IO.delete(dir)
+    }
+  }
+
+  /** Runs the next sequence of commands with global logging in place. */
+  def runWithNewLog(state: State, logBacking: GlobalLogBacking): RunNext = {
+    Using.fileWriter(append = true)(logBacking.file) { writer =>
+      val out = new PrintWriter(writer)
+      val full = state.globalLogging.full
+      val newLogging =
+        state.globalLogging.newAppender(full, out, logBacking, LoggerContext.globalContext)
+      // transferLevels(state, newLogging)
+      val loggedState = state.copy(globalLogging = newLogging)
+      try run(loggedState)
+      finally {
+        out.close()
+      }
+    }
+  }
+
+  // /** Transfers logging and trace levels from the old global loggers to the new ones. */
+  // private[this] def transferLevels(state: State, logging: GlobalLogging): Unit = {
+  //   val old = state.globalLogging
+  //   Logger.transferLevels(old.backed, logging.backed)
+  //   (old.full, logging.full) match { // well, this is a hack
+  //     case (oldLog: AbstractLogger, newLog: AbstractLogger) => Logger.transferLevels(oldLog, newLog)
+  //     case _                                                => ()
+  //   }
+  // }
+
+  sealed trait RunNext
+  final class ClearGlobalLog(val state: State) extends RunNext
+  final class KeepGlobalLog(val state: State) extends RunNext
+  final class Return(val result: xsbti.MainResult) extends RunNext
+
+  /** Runs the next sequence of commands that doesn't require global logging changes. */
+  @tailrec def run(state: State): RunNext =
+    state.next match {
+      case State.Continue       => run(next(state))
+      case State.ClearGlobalLog => new ClearGlobalLog(state.continue)
+      case State.KeepLastLog    => new KeepGlobalLog(state.continue)
+      case ret: State.Return    => new Return(ret.result)
+    }
+
+  def next(state: State): State = {
+    val context = LoggerContext(useLog4J = state.get(Keys.useLog4J.key).getOrElse(false))
+    val superShellSleep =
+      state.get(Keys.superShellSleep.key).getOrElse(SysProp.supershellSleep.millis)
+    val superShellThreshold =
+      state.get(Keys.superShellThreshold.key).getOrElse(SysProp.supershellThreshold)
+    val taskProgress = new TaskProgress(superShellSleep, superShellThreshold, state.log)
+    val gcMonitor = if (SysProp.gcMonitor) Some(new sbt.internal.GCMonitor(state.log)) else None
+    try {
+      ErrorHandling.wideConvert {
+        state
+          .put(Keys.loggerContext, context)
+          .put(Keys.taskProgress, taskProgress)
+          .process(processCommand)
+      } match {
+        case Right(s)                  => s.remove(Keys.loggerContext)
+        case Left(t: xsbti.FullReload) => throw t
+        case Left(t: RebootCurrent)    => throw t
+        case Left(t)                   => state.remove(Keys.loggerContext).handleError(t)
+      }
+    } catch {
+      case oom: OutOfMemoryError
+          if oom.getMessage != null && oom.getMessage.contains("Metaspace") =>
+        System.gc() // Since we're under memory pressure, see if more can be freed with a manual gc.
+        val isTestOrRun = state.remainingCommands.headOption.exists { exec =>
+          val cmd = exec.commandLine
+          cmd.contains("test") || cmd.contains("run")
+        }
+        val isConsole = state.remainingCommands.exists(_.commandLine == "shell") ||
+          (state.remainingCommands.last.commandLine == "iflast shell")
+        val testOrRunMessage =
+          if (!isTestOrRun) ""
+          else
+            " If this error occurred during a test or run evaluation, it can be caused by the " +
+              "choice of ClassLoaderLayeringStrategy. Of the available strategies, " +
+              "ClassLoaderLayeringStrategy.ScalaLibrary will typically use the least metaspace. " +
+              (if (isConsole)
+                 " To change the layering strategy for this session, run:\n\n" +
+                   "set ThisBuild / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy." +
+                   "ScalaLibrary"
+               else "")
+        val msg: String =
+          s"Caught $oom\nTo best utilize classloader caching and to prevent file handle leaks, we " +
+            s"recommend running sbt without a MaxMetaspaceSize limit. $testOrRunMessage"
+        state.log.error(msg)
+        state.log.error("\n")
+        state.handleError(oom)
+    } finally {
+      gcMonitor.foreach(_.close())
+      context.close()
+      taskProgress.close()
+    }
+  }
+
+  /** This is the main function State transfer function of the sbt command processing. */
+  def processCommand(exec: Exec, state: State): State = {
+    val channelName = exec.source map (_.channelName)
+    val exchange = StandardMain.exchange
+    exchange.setState(state)
+    exchange.notifyStatus(
+      ExecStatusEvent("Processing", channelName, exec.execId, Vector())
+    )
+    try {
+      def process(): State = {
+        val progressState = state.get(sbt.Keys.currentTaskProgress) match {
+          case Some(_) => state
+          case _ =>
+            if (state.get(Keys.stateBuildStructure).isDefined) {
+              val extracted = Project.extract(state)
+              val progress = EvaluateTask.executeProgress(extracted, extracted.structure, state)
+              state.put(sbt.Keys.currentTaskProgress, new Keys.TaskProgress(progress))
+            } else state
+        }
+        exchange.setState(progressState)
+        exchange.setExec(Some(exec))
+        val (restoreTerminal, termState) = channelName.flatMap(exchange.channelForName) match {
+          case Some(c) =>
+            val prevTerminal = ITerminal.set(c.terminal)
+            // temporarily set the prompt to running during task evaluation
+            c.terminal.setPrompt(Prompt.Running)
+            (() => {
+              ITerminal.set(prevTerminal)
+              c.terminal.flush()
+            }) -> progressState.put(Keys.terminalKey, Terminal(c.terminal))
+          case _ => (() => ()) -> progressState.put(Keys.terminalKey, Terminal(ITerminal.get))
+        }
+        /*
+         * FastTrackCommands.evaluate can be significantly faster than Command.process because
+         * it avoids an expensive parsing step for internal commands that are easy to parse.
+         * Dropping (FastTrackCommands.evaluate ... getOrElse) should be functionally identical
+         * but slower.
+         */
+        val newState = try {
+          FastTrackCommands
+            .evaluate(termState, exec.commandLine)
+            .getOrElse(Command.process(exec.commandLine, termState))
+        } catch {
+          case _: RejectedExecutionException =>
+            // No stack trace since this is just to notify the user which command they cancelled
+            object Cancelled extends Throwable(exec.commandLine, null, true, false) {
+              override def toString: String = s"Cancelled: ${exec.commandLine}"
+            }
+            throw Cancelled
+        } finally {
+          // Flush the terminal output after command evaluation to ensure that all output
+          // is displayed in the thin client before we report the command status. Also
+          // set the prompt to whatever it was before we started evaluating the task.
+          restoreTerminal()
+        }
+        if (exec.execId.fold(true)(!_.startsWith(networkExecPrefix)) &&
+            !exec.commandLine.startsWith(networkExecPrefix)) {
+          val doneEvent = ExecStatusEvent(
+            "Done",
+            channelName,
+            exec.execId,
+            newState.remainingCommands.toVector map (_.commandLine),
+            exitCode(newState, state),
+          )
+          exchange.respondStatus(doneEvent)
+        }
+        exchange.setExec(None)
+        newState.get(sbt.Keys.currentTaskProgress).foreach(_.progress.stop())
+        newState.remove(sbt.Keys.currentTaskProgress).remove(Keys.terminalKey)
+      }
+      state.get(CheckBuildSourcesKey) match {
+        case Some(cbs) =>
+          if (!cbs.needsReload(state, exec)) process()
+          else Exec("reload", None) +: exec +: state.remove(CheckBuildSourcesKey)
+        case _ => process()
+      }
+    } catch {
+      case err: JsonRpcResponseError =>
+        exchange.respondError(err, exec.execId, channelName.map(CommandSource(_)))
+        throw err
+      case err: Throwable =>
+        val errorEvent = ExecStatusEvent(
+          "Error",
+          channelName,
+          exec.execId,
+          Vector(),
+          ExitCode(ErrorCodes.UnknownError),
+          Option(err.getMessage),
+        )
+        StandardMain.exchange.respondStatus(errorEvent)
+        throw err
+    }
+  }
+
+  def logFullException(e: Throwable, log: Logger): Unit = State.logFullException(e, log)
+
+  private[this] type ExitCode = Option[Long]
+  private[this] object ExitCode {
+    def apply(n: Long): ExitCode = Option(n)
+    val Success: ExitCode = ExitCode(0)
+    val Unknown: ExitCode = None
+  }
+
+  private[this] def exitCode(state: State, prevState: State): ExitCode = {
+    exitCodeFromStateNext(state) match {
+      case ExitCode.Success => exitCodeFromStateOnFailure(state, prevState)
+      case x                => x
+    }
+  }
+
+  // State's "next" field indicates the next action for the command processor to take
+  // we'll use that to determine if the command failed
+  private[this] def exitCodeFromStateNext(state: State): ExitCode = {
+    state.next match {
+      case State.Continue       => ExitCode.Success
+      case State.ClearGlobalLog => ExitCode.Success
+      case State.KeepLastLog    => ExitCode.Success
+      case ret: State.Return =>
+        ret.result match {
+          case exit: xsbti.Exit  => ExitCode(exit.code().toLong)
+          case _: xsbti.Continue => ExitCode.Success
+          case _: xsbti.Reboot   => ExitCode.Success
+          case x =>
+            val clazz = if (x eq null) "" else " (class: " + x.getClass + ")"
+            state.log debug s"Unknown main result: $x$clazz"
+            ExitCode.Unknown
+        }
+    }
+  }
+
+  // the shell command specifies an onFailure so that if an exception is thrown
+  // it's handled by executing the shell again, instead of the state failing
+  // so we also use that to indicate that the execution failed
+  private[this] def exitCodeFromStateOnFailure(state: State, prevState: State): ExitCode =
+    if (prevState.onFailure.isDefined && state.onFailure.isEmpty &&
+        state.currentCommand.fold(true)(_.commandLine != StashOnFailure)) {
+      ExitCode(ErrorCodes.UnknownError)
+    } else ExitCode.Success
+}
diff --git a/main/src/main/scala/sbt/OptionSyntax.scala b/main/src/main/scala/sbt/OptionSyntax.scala
new file mode 100644
index 000000000..5716eba36
--- /dev/null
+++ b/main/src/main/scala/sbt/OptionSyntax.scala
@@ -0,0 +1,48 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.util.Optional
+
+// Todo: port this back to Zinc in place of JavaInterfaceUtil.
+trait OptionSyntax {
+  import OptionSyntax._
+  implicit def sbtOptionSyntaxRichOptional[A](optional: Optional[A]): RichOptional[A] =
+    new RichOptional[A](optional)
+
+  implicit def sbtOptionSyntaxRichOption[A](option: Option[A]): RichOption[A] =
+    new RichOption[A](option)
+
+  implicit def sbtOptionSyntaxOptionIdOps[A](a: A): OptionIdOps[A] =
+    new OptionIdOps[A](a)
+
+  final def none[A]: Option[A] = None
+}
+
+object OptionSyntax extends OptionSyntax {
+
+  /** Injects some method. */
+  final class OptionIdOps[A](val a: A) extends AnyVal {
+    def some: Option[A] = Some(a)
+  }
+
+  /** Injects asScala method. */
+  final class RichOptional[A](val optional: Optional[A]) extends AnyVal {
+    def asScala: Option[A] =
+      if (!optional.isPresent) None
+      else Some(optional.get())
+  }
+
+  /** Injects asJava method. */
+  final class RichOption[A](val option: Option[A]) extends AnyVal {
+    def asJava: Optional[A] = option match {
+      case Some(value) => Optional.of(value)
+      case None        => Optional.empty[A]
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/Opts.scala b/main/src/main/scala/sbt/Opts.scala
index 21d051547..720fd0f93 100644
--- a/main/src/main/scala/sbt/Opts.scala
+++ b/main/src/main/scala/sbt/Opts.scala
@@ -1,9 +1,14 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah, Indrajit Raychaudhuri
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import sbt.librarymanagement.{ Credentials, MavenRepository, Resolver }
+import sbt.librarymanagement.{ MavenRepository, Resolver }
+import sbt.librarymanagement.ivy.Credentials
 
 import java.io.File
 import java.net.URL
@@ -27,15 +32,26 @@ object Opts {
     def sourceUrl(u: String): Seq[String] = Seq("-doc-source-url", u)
     def title(t: String): Seq[String] = Seq("-doc-title", t)
     def version(v: String): Seq[String] = Seq("-doc-version", v)
-    def externalAPI(mappings: Iterable[(File, URL)]): Seq[String] = if (mappings.isEmpty) Nil else
-      mappings.map { case (f, u) => s"${f.getAbsolutePath}#${u.toExternalForm}" }.mkString("-doc-external-doc:", ",", "") :: Nil
+    def externalAPI(mappings: Iterable[(File, URL)]): Seq[String] =
+      if (mappings.isEmpty) Nil
+      else
+        mappings
+          .map { case (f, u) => s"${f.getAbsolutePath}#${u.toExternalForm}" }
+          .mkString("-doc-external-doc:", ",", "") :: Nil
   }
   object resolver {
     import sbt.io.syntax._
     val sonatypeReleases = Resolver.sonatypeRepo("releases")
     val sonatypeSnapshots = Resolver.sonatypeRepo("snapshots")
-    val sonatypeStaging = new MavenRepository("sonatype-staging", "https://oss.sonatype.org/service/local/staging/deploy/maven2")
-    val mavenLocalFile = Resolver.file("Local Repository", userHome / ".m2" / "repository" asFile)
+    val sonatypeStaging = MavenRepository(
+      "sonatype-staging",
+      "https://oss.sonatype.org/service/local/staging/deploy/maven2"
+    )
+    val mavenLocalFile = Resolver.file("Local Repository", userHome / ".m2" / "repository")(
+      Resolver.defaultPatterns
+    )
+    val sbtSnapshots = Resolver.bintrayRepo("sbt", "maven-snapshots")
+    val sbtIvySnapshots = Resolver.bintrayIvyRepo("sbt", "ivy-snapshots")
   }
 }
 
@@ -48,20 +64,28 @@ object DefaultOptions {
 
   def javac: Seq[String] = compile.encoding("UTF-8")
   def scalac: Seq[String] = compile.encoding("UTF-8")
-  def javadoc(name: String, version: String): Seq[String] = Seq("-doctitle", "%s %s API".format(name, version))
-  def scaladoc(name: String, version: String): Seq[String] = doc.title(name) ++ doc.version(version)
+  def javadoc(name: String, version: String): Seq[String] =
+    Seq("-doctitle", "%s %s API".format(name, version))
+  def scaladoc(name: String, version: String): Seq[String] =
+    doc.title(name) ++ doc.version(version)
 
-  def resolvers(snapshot: Boolean): Seq[Resolver] = {
-    if (snapshot) Seq(resolver.sonatypeSnapshots) else Nil
+  def resolvers(snapshot: Boolean): Vector[Resolver] = {
+    if (snapshot) Vector(resolver.sbtSnapshots) else Vector.empty
+  }
+  def pluginResolvers(plugin: Boolean, snapshot: Boolean): Vector[Resolver] = {
+    if (plugin && snapshot) Vector(resolver.sbtSnapshots, resolver.sbtIvySnapshots)
+    else Vector.empty
   }
   def addResolvers: Setting[_] = Keys.resolvers ++= { resolvers(Keys.isSnapshot.value) }
+  def addPluginResolvers: Setting[_] =
+    Keys.resolvers ++= pluginResolvers(Keys.sbtPlugin.value, Keys.isSnapshot.value)
 
-  @deprecated("Use `credentials(State)` instead to make use of configuration path dynamically configured via `Keys.globalSettingsDirectory`; relying on ~/.ivy2 is not recommended anymore.", "0.12.0")
-  def credentials: Credentials = Credentials(userHome / ".ivy2" / ".credentials")
-  def credentials(state: State): Credentials = Credentials(getGlobalSettingsDirectory(state, getGlobalBase(state)) / ".credentials")
+  def credentials(state: State): Credentials =
+    Credentials(getGlobalSettingsDirectory(state, getGlobalBase(state)) / ".credentials")
   def addCredentials: Setting[_] = Keys.credentials += { credentials(Keys.state.value) }
 
   def shellPrompt(version: String): State => String =
-    s => "%s:%s:%s> ".format(s.configuration.provider.id.name, extract(s).currentProject.id, version)
+    s =>
+      "%s:%s:%s> ".format(s.configuration.provider.id.name, extract(s).currentProject.id, version)
   def setupShellPrompt: Setting[_] = Keys.shellPrompt := { shellPrompt(Keys.version.value) }
 }
diff --git a/main/src/main/scala/sbt/PluginCross.scala b/main/src/main/scala/sbt/PluginCross.scala
new file mode 100644
index 000000000..679a344dc
--- /dev/null
+++ b/main/src/main/scala/sbt/PluginCross.scala
@@ -0,0 +1,105 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import sbt.internal.util.complete.{ Parser, DefaultParsers }
+import DefaultParsers._
+import sbt.Keys._
+import Scope.GlobalScope
+import Def.ScopedKey
+import sbt.SlashSyntax0._
+import sbt.internal.Load
+import sbt.internal.CommandStrings._
+import Cross.{ spacedFirst, requireSession }
+import sbt.librarymanagement.VersionNumber
+import Project.inScope
+import scala.annotation.nowarn
+
+/**
+ * Module responsible for plugin cross building.
+ */
+private[sbt] object PluginCross {
+  @nowarn
+  lazy val pluginSwitch: Command = {
+    def switchParser(state: State): Parser[(String, String)] = {
+      lazy val switchArgs = token(NotSpace.examples()) ~ (token(
+        Space ~> matched(state.combinedParser)
+      ) ?? "")
+      lazy val nextSpaced = spacedFirst(PluginSwitchCommand)
+      token(PluginSwitchCommand ~ OptSpace) flatMap { _ =>
+        switchArgs & nextSpaced
+      }
+    }
+
+    def crossExclude(s: Def.Setting[_]): Boolean =
+      s.key match {
+        case ScopedKey(Scope(_, _, pluginCrossBuild.key, _), sbtVersion.key) => true
+        case _                                                               => false
+      }
+
+    Command.arb(requireSession(switchParser), pluginSwitchHelp) {
+      case (state, (version, command)) =>
+        val x = Project.extract(state)
+        import x._
+        state.log.info(s"Setting `sbtVersion in pluginCrossBuild` to $version")
+        val add = List(sbtVersion in GlobalScope in pluginCrossBuild :== version) ++
+          List(scalaVersion := scalaVersionSetting.value) ++
+          inScope(GlobalScope.copy(project = Select(currentRef)))(
+            Seq(scalaVersion := scalaVersionSetting.value)
+          )
+        val cleared = session.mergeSettings.filterNot(crossExclude)
+        val newStructure = Load.reapply(cleared ++ add, structure)
+        Project.setProject(session, newStructure, command :: state)
+    }
+  }
+
+  lazy val pluginCross: Command = {
+    def crossParser(state: State): Parser[String] =
+      token(PluginCrossCommand <~ OptSpace) flatMap { _ =>
+        token(
+          matched(
+            state.combinedParser &
+              spacedFirst(PluginCrossCommand)
+          )
+        )
+      }
+    def crossVersions(state: State): List[String] = {
+      val x = Project.extract(state)
+      import x._
+      ((currentRef / crossSbtVersions) get structure.data getOrElse Nil).toList
+    }
+    Command.arb(requireSession(crossParser), pluginCrossHelp) {
+      case (state, command) =>
+        val x = Project.extract(state)
+        import x._
+        val versions = crossVersions(state)
+        val current = (pluginCrossBuild / sbtVersion)
+          .get(structure.data)
+          .map(PluginSwitchCommand + " " + _)
+          .toList
+        if (versions.isEmpty) command :: state
+        else versions.map(PluginSwitchCommand + " " + _ + " " + command) ::: current ::: state
+    }
+  }
+
+  def scalaVersionSetting: Def.Initialize[String] = Def.setting {
+    val scalaV = scalaVersion.value
+    val sv = (pluginCrossBuild / sbtBinaryVersion).value
+    val isPlugin = sbtPlugin.value
+    if (isPlugin) scalaVersionFromSbtBinaryVersion(sv)
+    else scalaV
+  }
+
+  def scalaVersionFromSbtBinaryVersion(sv: String): String =
+    VersionNumber(sv) match {
+      case VersionNumber(Seq(0, 12, _*), _, _) => "2.9.2"
+      case VersionNumber(Seq(0, 13, _*), _, _) => "2.10.7"
+      case VersionNumber(Seq(1, 0, _*), _, _)  => "2.12.13"
+      case _                                   => sys.error(s"Unsupported sbt binary version: $sv")
+    }
+}
diff --git a/main/src/main/scala/sbt/Plugins.scala b/main/src/main/scala/sbt/Plugins.scala
index 64d12723f..502d72111 100644
--- a/main/src/main/scala/sbt/Plugins.scala
+++ b/main/src/main/scala/sbt/Plugins.scala
@@ -1,18 +1,26 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 /*
 TODO:
 - index all available AutoPlugins to get the tasks that will be added
 - error message when a task doesn't exist that it would be provided by plugin x, enabled by natures y,z, blocked by a, b
-*/
+ */
 
 import sbt.librarymanagement.Configuration
 
-import sbt.internal.util.logic.{Atom, Clause, Clauses, Formula, Literal, Logic, Negated}
-import Logic.{CyclicNegation, InitialContradictions, InitialOverlap, LogicException}
+import sbt.internal.util.logic.{ Atom, Clause, Clauses, Formula, Literal, Logic, Negated }
+import Logic.{ CyclicNegation, InitialContradictions, InitialOverlap, LogicException }
 import Def.Setting
 import Plugins._
 import annotation.tailrec
 import sbt.util.Logger
+import PluginTrigger._
 
 /**
  * An AutoPlugin defines a group of settings and the conditions where the settings are automatically added to a build (called "activation").
@@ -60,16 +68,20 @@ import sbt.util.Logger
  * then the `MyPlugin` settings (and anything that activates only when `MyPlugin` is activated) will not be added.
  */
 abstract class AutoPlugin extends Plugins.Basic with PluginsFunctions {
-  /** Determines whether this AutoPlugin will be activated for this project when the `requires` clause is satisfied.
+
+  /**
+   * Determines whether this AutoPlugin will be activated for this project when the `requires` clause is satisfied.
    *
    * When this method returns `allRequirements`, and `requires` method returns `Web && Javascript`, this plugin
    * instance will be added automatically if the `Web` and `Javascript` plugins are enabled.
    *
    * When this method returns `noTrigger`, and `requires` method returns `Web && Javascript`, this plugin
-   * instance will be added only if the build user enables it, but it will automatically add both `Web` and `Javascript`. */
+   * instance will be added only if the build user enables it, but it will automatically add both `Web` and `Javascript`.
+   */
   def trigger: PluginTrigger = noTrigger
 
-  /** This AutoPlugin requires the plugins the [[Plugins]] matcher returned by this method. See [[trigger]].
+  /**
+   * This AutoPlugin requires the plugins the Plugins matcher returned by this method. See [[trigger]].
    */
   def requires: Plugins = plugins.JvmPlugin
 
@@ -77,18 +89,20 @@ abstract class AutoPlugin extends Plugins.Basic with PluginsFunctions {
 
   override def toString: String = label
 
-  /** The [[Configuration]]s to add to each project that activates this AutoPlugin.*/
+  /** The `Configuration`s to add to each project that activates this AutoPlugin.*/
   def projectConfigurations: Seq[Configuration] = Nil
 
-  /** The [[Setting]]s to add in the scope of each project that activates this AutoPlugin. */
+  /** The `Setting`s to add in the scope of each project that activates this AutoPlugin. */
   def projectSettings: Seq[Setting[_]] = Nil
 
-  /** The [[Setting]]s to add to the build scope for each project that activates this AutoPlugin.
-  * The settings returned here are guaranteed to be added to a given build scope only once
-  * regardless of how many projects for that build activate this AutoPlugin. */
+  /**
+   * The `Setting` to add to the build scope for each project that activates this AutoPlugin.
+   * The settings returned here are guaranteed to be added to a given build scope only once
+   * regardless of how many projects for that build activate this AutoPlugin.
+   */
   def buildSettings: Seq[Setting[_]] = Nil
 
-  /** The [[Setting]]s to add to the global scope exactly once if any project activates this AutoPlugin. */
+  /** The `Setting`s to add to the global scope exactly once if any project activates this AutoPlugin. */
   def globalSettings: Seq[Setting[_]] = Nil
 
   // TODO?: def commands: Seq[Command]
@@ -97,16 +111,15 @@ abstract class AutoPlugin extends Plugins.Basic with PluginsFunctions {
   def extraProjects: Seq[Project] = Nil
 
   /** The [[Project]]s to add to the current build based on an existing project. */
-  def derivedProjects(proj: ProjectDefinition[_]): Seq[Project] = Nil
+  def derivedProjects(@deprecated("unused", "") proj: ProjectDefinition[_]): Seq[Project] = Nil
 
   private[sbt] def unary_! : Exclude = Exclude(this)
 
-
   /** If this plugin does not have any requirements, it means it is actually a root plugin. */
   private[sbt] final def isRoot: Boolean =
     requires match {
       case Empty => true
-      case _ => false
+      case _     => false
     }
 
   /** If this plugin does not have any requirements, it means it is actually a root plugin. */
@@ -114,134 +127,187 @@ abstract class AutoPlugin extends Plugins.Basic with PluginsFunctions {
     isRoot && (trigger == AllRequirements)
 }
 
-/** An error that occurs when auto-plugins aren't configured properly.
-* It translates the error from the underlying logic system to be targeted at end users. */
-final class AutoPluginException private(val message: String, val origin: Option[LogicException]) extends RuntimeException(message) {
+/**
+ * An error that occurs when auto-plugins aren't configured properly.
+ * It translates the error from the underlying logic system to be targeted at end users.
+ */
+final class AutoPluginException private (val message: String, val origin: Option[LogicException])
+    extends RuntimeException(message) {
+
   /** Prepends `p` to the error message derived from `origin`. */
   def withPrefix(p: String) = new AutoPluginException(p + message, origin)
 }
 object AutoPluginException {
   def apply(msg: String): AutoPluginException = new AutoPluginException(msg, None)
-  def apply(origin: LogicException): AutoPluginException = new AutoPluginException(Plugins.translateMessage(origin), Some(origin))
+  def apply(origin: LogicException): AutoPluginException =
+    new AutoPluginException(Plugins.translateMessage(origin), Some(origin))
 }
 
-sealed trait PluginTrigger
-case object AllRequirements extends PluginTrigger
-case object NoTrigger extends PluginTrigger
-
 /** An expression that matches `AutoPlugin`s. */
 sealed trait Plugins {
-  def && (o: Basic): Plugins
+  def &&(o: Basic): Plugins
 }
 
-
 sealed trait PluginsFunctions {
+
   /** [[Plugins]] instance that doesn't require any [[Plugins]]s. */
   def empty: Plugins = Plugins.Empty
 
   /** This plugin is activated when all required plugins are present. */
   def allRequirements: PluginTrigger = AllRequirements
+
   /** This plugin is activated only when it is manually activated. */
   def noTrigger: PluginTrigger = NoTrigger
 }
 
 object Plugins extends PluginsFunctions {
-  /** Given the available auto plugins `defined`, returns a function that selects [[AutoPlugin]]s for the provided [[AutoPlugin]]s.
-  * The [[AutoPlugin]]s are topologically sorted so that a required [[AutoPlugin]] comes before its requiring [[AutoPlugin]].*/
+
+  /**
+   * Given the available auto plugins `defined`, returns a function that selects [[AutoPlugin]]s for the provided [[AutoPlugin]]s.
+   * The [[AutoPlugin]]s are topologically sorted so that a required [[AutoPlugin]] comes before its requiring [[AutoPlugin]].
+   */
   def deducer(defined0: List[AutoPlugin]): (Plugins, Logger) => Seq[AutoPlugin] =
-    if(defined0.isEmpty) (_, _) => Nil
+    if (defined0.isEmpty)(_, _) => Nil
     else {
       // TODO: defined should return all the plugins
       val allReqs = (defined0 flatMap { asRequirements }).toSet
       val diff = allReqs diff defined0.toSet
-      val defined = if (diff.nonEmpty) diff.toList ::: defined0
-              else defined0
+      val defined =
+        if (diff.nonEmpty) diff.toList ::: defined0
+        else defined0
 
-      val byAtom = defined map { x => (Atom(x.label), x) }
+      val byAtom = defined map { x =>
+        (Atom(x.label), x)
+      }
       val byAtomMap = byAtom.toMap
-      if(byAtom.size != byAtomMap.size) duplicateProvidesError(byAtom)
+      if (byAtom.size != byAtomMap.size) duplicateProvidesError(byAtom)
       // Ignore clauses for plugins that does not require anything else.
       // Avoids the requirement for pure Nature strings *and* possible
       // circular dependencies in the logic.
-      val allRequirementsClause = defined.filterNot(_.isRoot).flatMap(d => asRequirementsClauses(d))
+      val allRequirementsClause =
+        defined.filterNot(_.isRoot).flatMap(d => asRequirementsClauses(d))
       val allEnabledByClause = defined.filterNot(_.isRoot).flatMap(d => asEnabledByClauses(d))
 
       // Note: Here is where the function begins.  We're given a list of plugins now.
       (requestedPlugins, log) => {
-        def explicitlyDisabled(p: AutoPlugin): Boolean = hasExclude(requestedPlugins, p)
-        val alwaysEnabled: List[AutoPlugin] = defined.filter(_.isAlwaysEnabled).filterNot(explicitlyDisabled)
-        val knowlege0: Set[Atom] = ((flatten(requestedPlugins) ++ alwaysEnabled) collect {
-          case x: AutoPlugin => Atom(x.label)
-        }).toSet
-        val clauses = Clauses((allRequirementsClause ::: allEnabledByClause) filterNot { _.head subsetOf knowlege0 })
-        log.debug(s"deducing auto plugins based on known facts ${knowlege0.toString} and clauses ${clauses.toString}")
-        Logic.reduce(clauses, (flattenConvert(requestedPlugins) ++ convertAll(alwaysEnabled)).toSet) match {
-          case Left(problem) => throw AutoPluginException(problem)
-          case Right(results) =>
-            log.debug(s"  :: deduced result: ${results}")
-            val selectedAtoms: List[Atom] = results.ordered
-            val selectedPlugins = selectedAtoms map { a =>
-              byAtomMap.getOrElse(a, throw AutoPluginException(s"${a} was not found in atom map."))
-            }
-            val forbidden: Set[AutoPlugin] = (selectedPlugins flatMap { Plugins.asExclusions }).toSet
-            val c = selectedPlugins.toSet & forbidden
-            if (c.nonEmpty) {
-              exlusionConflictError(requestedPlugins, selectedPlugins, c.toSeq sortBy {_.label})
-            }
-            val retval = topologicalSort(selectedPlugins, log)
-            log.debug(s"  :: sorted deduced result: ${retval.toString}")
-            retval
+        timed("Plugins.deducer#function", log) {
+          def explicitlyDisabled(p: AutoPlugin): Boolean = hasExclude(requestedPlugins, p)
+          val alwaysEnabled: List[AutoPlugin] =
+            defined.filter(_.isAlwaysEnabled).filterNot(explicitlyDisabled)
+          val knowledge0: Set[Atom] = ((flatten(requestedPlugins) ++ alwaysEnabled) collect {
+            case x: AutoPlugin => Atom(x.label)
+          }).toSet
+          val clauses = Clauses((allRequirementsClause ::: allEnabledByClause) filterNot {
+            _.head subsetOf knowledge0
+          })
+          // println(s"allRequirementsClause = $allRequirementsClause")
+          // println(s"allEnabledByClause = $allEnabledByClause")
+          // println(s"clauses = $clauses")
+          // println("")
+          log.debug(
+            s"deducing auto plugins based on known facts ${knowledge0.toString} and clauses ${clauses.toString}"
+          )
+          Logic.reduce(
+            clauses,
+            (flattenConvert(requestedPlugins) ++ convertAll(alwaysEnabled)).toSet
+          ) match {
+            case Left(problem) => throw AutoPluginException(problem)
+            case Right(results) =>
+              log.debug(s"  :: deduced result: ${results}")
+              val selectedAtoms: List[Atom] = results.ordered
+              val selectedPlugins = selectedAtoms map { a =>
+                byAtomMap.getOrElse(
+                  a,
+                  throw AutoPluginException(s"${a} was not found in atom map.")
+                )
+              }
+              val forbidden: Set[AutoPlugin] =
+                (selectedPlugins flatMap { Plugins.asExclusions }).toSet
+              val c = selectedPlugins.toSet & forbidden
+              if (c.nonEmpty) {
+                exclusionConflictError(requestedPlugins, selectedPlugins, c.toSeq sortBy {
+                  _.label
+                })
+              }
+              val retval = topologicalSort(selectedPlugins)
+              // log.debug(s"  :: sorted deduced result: ${retval.toString}")
+              retval
+          }
         }
       }
     }
-  private[sbt] def topologicalSort(ns: List[AutoPlugin], log: Logger): List[AutoPlugin] = {
-    log.debug(s"sorting: ns: ${ns.toString}")
-    @tailrec def doSort(found0: List[AutoPlugin], notFound0: List[AutoPlugin], limit0: Int): List[AutoPlugin] = {
-      log.debug(s"  :: sorting:: found: ${found0.toString} not found ${notFound0.toString}")
+
+  private[sbt] def topologicalSort(ns: List[AutoPlugin]): List[AutoPlugin] = {
+    @tailrec
+    def doSort(
+        found0: List[AutoPlugin],
+        notFound0: List[AutoPlugin],
+        limit0: Int
+    ): List[AutoPlugin] = {
       if (limit0 < 0) throw AutoPluginException(s"Failed to sort ${ns} topologically")
       else if (notFound0.isEmpty) found0
       else {
-        val (found1, notFound1) = notFound0 partition { n => asRequirements(n).toSet subsetOf found0.toSet }
+        val (found1, notFound1) = notFound0 partition { n =>
+          asRequirements(n).toSet subsetOf found0.toSet
+        }
         doSort(found0 ::: found1, notFound1, limit0 - 1)
       }
     }
     val (roots, nonRoots) = ns partition (_.isRoot)
     doSort(roots, nonRoots, ns.size * ns.size + 1)
   }
+
   private[sbt] def translateMessage(e: LogicException) = e match {
-    case ic: InitialContradictions => s"Contradiction in selected plugins.  These plugins were both included and excluded: ${literalsString(ic.literals.toSeq)}"
-    case io: InitialOverlap => s"Cannot directly enable plugins.  Plugins are enabled when their required plugins are satisifed.  The directly selected plugins were: ${literalsString(io.literals.toSeq)}"
-    case cn: CyclicNegation => s"Cycles in plugin requirements cannot involve excludes.  The problematic cycle is: ${literalsString(cn.cycle)}"
+    case ic: InitialContradictions =>
+      s"Contradiction in selected plugins.  These plugins were both included and excluded: ${literalsString(ic.literals.toSeq)}"
+    case io: InitialOverlap =>
+      s"Cannot directly enable plugins.  Plugins are enabled when their required plugins are satisfied.  The directly selected plugins were: ${literalsString(io.literals.toSeq)}"
+    case cn: CyclicNegation =>
+      s"Cycles in plugin requirements cannot involve excludes.  The problematic cycle is: ${literalsString(cn.cycle)}"
   }
+
   private[this] def literalsString(lits: Seq[Literal]): String =
-    lits map { case Atom(l) => l; case Negated(Atom(l)) => l } mkString(", ")
+    lits map { case Atom(l) => l; case Negated(Atom(l)) => l } mkString (", ")
 
   private[this] def duplicateProvidesError(byAtom: Seq[(Atom, AutoPlugin)]): Unit = {
-    val dupsByAtom = byAtom.groupBy(_._1).mapValues(_.map(_._2))
-    val dupStrings = for( (atom, dups) <- dupsByAtom if dups.size > 1 ) yield
-      s"${atom.label} by ${dups.mkString(", ")}"
-    val (ns, nl) = if(dupStrings.size > 1) ("s", "\n\t") else ("", " ")
+    val dupsByAtom = Map(byAtom.groupBy(_._1).toSeq.map {
+      case (k, v) =>
+        k -> v.map(_._2)
+    }: _*)
+    val dupStrings =
+      for ((atom, dups) <- dupsByAtom if dups.size > 1)
+        yield s"${atom.label} by ${dups.mkString(", ")}"
+    val (ns, nl) = if (dupStrings.size > 1) ("s", "\n\t") else ("", " ")
     val message = s"Plugin$ns provided by multiple AutoPlugins:$nl${dupStrings.mkString(nl)}"
     throw AutoPluginException(message)
   }
-  private[this] def exlusionConflictError(requested: Plugins, selected: Seq[AutoPlugin], conflicting: Seq[AutoPlugin]): Unit = {
-    def listConflicts(ns: Seq[AutoPlugin]) = (ns map { c =>
-      val reasons = (if (flatten(requested) contains c) List("requested")
-              else Nil) ++
-        (if (c.requires != empty && c.trigger == allRequirements) List(s"enabled by ${c.requires.toString}")
-          else Nil) ++
-        {
-          val reqs = selected filter { x => asRequirements(x) contains c }
+
+  private[this] def exclusionConflictError(
+      requested: Plugins,
+      selected: Seq[AutoPlugin],
+      conflicting: Seq[AutoPlugin]
+  ): Unit = {
+    def listConflicts(ns: Seq[AutoPlugin]) =
+      (ns map { c =>
+        val reasons = (if (flatten(requested) contains c) List("requested")
+                       else Nil) ++
+          (if (c.requires != empty && c.trigger == allRequirements)
+             List(s"enabled by ${c.requires.toString}")
+           else Nil) ++ {
+          val reqs = selected filter { x =>
+            asRequirements(x) contains c
+          }
           if (reqs.nonEmpty) List(s"""required by ${reqs.mkString(", ")}""")
           else Nil
-        } ++
-        {
-          val exs = selected filter { x => asExclusions(x) contains c }
+        } ++ {
+          val exs = selected filter { x =>
+            asExclusions(x) contains c
+          }
           if (exs.nonEmpty) List(s"""excluded by ${exs.mkString(", ")}""")
           else Nil
         }
-      s"""  - conflict: ${c.label} is ${reasons.mkString("; ")}"""
-    }).mkString("\n")
+        s"""  - conflict: ${c.label} is ${reasons.mkString("; ")}"""
+      }).mkString("\n")
     throw AutoPluginException(s"""Contradiction in enabled plugins:
   - requested: ${requested.toString}
   - enabled: ${selected.mkString(", ")}
@@ -258,7 +324,7 @@ ${listConflicts(conflicting)}""")
   sealed abstract class Basic extends Plugins {
     def &&(o: Basic): Plugins = And(this :: o :: Nil)
   }
-  private[sbt] final case class Exclude(n: AutoPlugin) extends Basic  {
+  private[sbt] final case class Exclude(n: AutoPlugin) extends Basic {
     override def toString = s"!$n"
   }
   private[sbt] final case class And(plugins: List[Basic]) extends Plugins {
@@ -266,92 +332,124 @@ ${listConflicts(conflicting)}""")
     override def toString = plugins.mkString(" && ")
   }
   private[sbt] def and(a: Plugins, b: Plugins) = b match {
-    case Empty => a
-    case And(ns) => (a /: ns)(_ && _)
+    case Empty    => a
+    case And(ns)  => ns.foldLeft(a)(_ && _)
     case b: Basic => a && b
   }
   private[sbt] def remove(a: Plugins, del: Set[Basic]): Plugins = a match {
-    case b: Basic => if(del(b)) Empty else b
-    case Empty => Empty
+    case b: Basic => if (del(b)) Empty else b
+    case Empty    => Empty
     case And(ns) =>
       val removed = ns.filterNot(del)
-      if(removed.isEmpty) Empty else And(removed)
+      if (removed.isEmpty) Empty else And(removed)
   }
 
   /** Defines enabled-by clauses for `ap`. */
   private[sbt] def asEnabledByClauses(ap: AutoPlugin): List[Clause] =
     // `ap` is the head and the required plugins for `ap` is the body.
-    if (ap.trigger == AllRequirements) Clause( convert(ap.requires), Set(Atom(ap.label)) ) :: Nil
+    if (ap.trigger == AllRequirements) Clause(convert(ap.requires), Set(Atom(ap.label))) :: Nil
     else Nil
+
   /** Defines requirements clauses for `ap`. */
   private[sbt] def asRequirementsClauses(ap: AutoPlugin): List[Clause] =
     // required plugin is the head and `ap` is the body.
-    asRequirements(ap) map { x => Clause( convert(ap), Set(Atom(x.label)) ) }
-  private[sbt] def asRequirements(ap: AutoPlugin): List[AutoPlugin] = flatten(ap.requires).toList collect {
-    case x: AutoPlugin => x
-  }
-  private[sbt] def asExclusions(ap: AutoPlugin): List[AutoPlugin] = flatten(ap.requires).toList collect {
-    case Exclude(x) => x
-  }
+    asRequirements(ap) map { x =>
+      Clause(convert(ap), Set(Atom(x.label)))
+    }
+  private[sbt] def asRequirements(ap: AutoPlugin): List[AutoPlugin] =
+    flatten(ap.requires).toList collect {
+      case x: AutoPlugin => x
+    }
+  private[sbt] def asExclusions(ap: AutoPlugin): List[AutoPlugin] =
+    flatten(ap.requires).toList collect {
+      case Exclude(x) => x
+    }
   // TODO - This doesn't handle nested AND boolean logic...
   private[sbt] def hasExclude(n: Plugins, p: AutoPlugin): Boolean = n match {
-    case `p` => false
+    case `p`          => false
     case Exclude(`p`) => true
     // TODO - This is stupidly advanced.  We do a nested check through possible and-ed
     // lists of plugins exclusions to see if the plugin ever winds up in an excluded=true case.
     // This would handle things like !!p or !(p && z)
     case Exclude(n) => hasInclude(n, p)
-    case And(ns) => ns.forall(n => hasExclude(n, p))
-    case b: Basic => false
-    case Empty => false
+    case And(ns)    => ns.forall(n => hasExclude(n, p))
+    case _: Basic   => false
+    case Empty      => false
   }
   private[sbt] def hasInclude(n: Plugins, p: AutoPlugin): Boolean = n match {
-    case `p` => true
+    case `p`        => true
     case Exclude(n) => hasExclude(n, p)
-    case And(ns) => ns.forall(n => hasInclude(n, p))
-    case b: Basic => false
-    case Empty => false
+    case And(ns)    => ns.forall(n => hasInclude(n, p))
+    case _: Basic   => false
+    case Empty      => false
   }
   private[this] def flattenConvert(n: Plugins): Seq[Literal] = n match {
-    case And(ns) => convertAll(ns)
+    case And(ns)  => convertAll(ns)
     case b: Basic => convertBasic(b) :: Nil
-    case Empty => Nil
+    case Empty    => Nil
   }
   private[sbt] def flatten(n: Plugins): Seq[Basic] = n match {
-    case And(ns) => ns
+    case And(ns)  => ns
     case b: Basic => b :: Nil
-    case Empty => Nil
+    case Empty    => Nil
   }
 
   private[this] def convert(n: Plugins): Formula = n match {
-    case And(ns) => convertAll(ns).reduce[Formula](_ && _)
+    case And(ns)  => convertAll(ns).reduce[Formula](_ && _)
     case b: Basic => convertBasic(b)
-    case Empty => Formula.True
+    case Empty    => Formula.True
   }
   private[this] def convertBasic(b: Basic): Literal = b match {
-    case Exclude(n) => !convertBasic(n)
+    case Exclude(n)    => !convertBasic(n)
     case a: AutoPlugin => Atom(a.label)
   }
   private[this] def convertAll(ns: Seq[Basic]): Seq[Literal] = ns map convertBasic
 
-  /** True if the trigger clause `n` is satisifed by `model`. */
+  /** True if the trigger clause `n` is satisfied by `model`. */
   def satisfied(n: Plugins, model: Set[AutoPlugin]): Boolean =
     flatten(n) forall {
-      case Exclude(a) => !model(a)
+      case Exclude(a)     => !model(a)
       case ap: AutoPlugin => model(ap)
     }
 
+  private val autoImport = "autoImport"
+
+  /** Determines whether a plugin has a stable autoImport member by:
+   *
+   * 1. Checking whether there exists a public field.
+   * 2. Checking whether there exists a public object.
+   *
+   * The above checks work for inherited members too.
+   *
+   * @param ap The found plugin.
+   * @param loader The plugin loader.
+   * @return True if plugin has a stable member `autoImport`, otherwise false.
+   */
   private[sbt] def hasAutoImportGetter(ap: AutoPlugin, loader: ClassLoader): Boolean = {
-    import reflect.runtime.{universe => ru}
+    import java.lang.reflect.Field
     import scala.util.control.Exception.catching
-    val m = ru.runtimeMirror(loader)
-    val im = m.reflect(ap)
-    val hasGetterOpt = catching(classOf[ScalaReflectionException]) opt {
-      im.symbol.asType.toType.decl(ru.TermName("autoImport")) match {
-        case ru.NoSymbol => false
-        case sym => sym.asTerm.isGetter || sym.asTerm.isModule
-      }
+    // Make sure that we don't detect user-defined methods called autoImport
+    def existsAutoImportVal(clazz: Class[_]): Option[Field] = {
+      catching(classOf[NoSuchFieldException])
+        .opt(clazz.getDeclaredField(autoImport))
+        .orElse(Option(clazz.getSuperclass).flatMap(existsAutoImportVal))
     }
-    hasGetterOpt getOrElse false
+
+    val pluginClazz = ap.getClass
+    existsAutoImportVal(pluginClazz)
+      .orElse(
+        catching(classOf[ClassNotFoundException])
+          .opt(Class.forName(s"${pluginClazz.getName}$autoImport$$", false, loader))
+      )
+      .isDefined
+  }
+
+  /** Debugging method to time how long it takes to run various compilation tasks. */
+  private[this] def timed[T](label: String, log: Logger)(t: => T): T = {
+    val start = System.nanoTime
+    val result = t
+    val elapsed = System.nanoTime - start
+    log.debug(label + " took " + (elapsed / 1e6) + " ms")
+    result
   }
 }
diff --git a/main/src/main/scala/sbt/Project.scala b/main/src/main/scala/sbt/Project.scala
index 497d5cf70..5fd822f01 100755
--- a/main/src/main/scala/sbt/Project.scala
+++ b/main/src/main/scala/sbt/Project.scala
@@ -1,24 +1,66 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
 import java.net.URI
 import java.util.Locale
 import Project._
-import Keys.{ appConfiguration, stateBuildStructure, commands, configuration, historyPath, projectCommand, sessionSettings, shellPrompt, serverPort, thisProject, thisProjectRef, watch }
-import Scope.{ GlobalScope, ThisScope }
+import BasicKeys.serverLogLevel
+import Keys.{
+  stateBuildStructure,
+  bspEnabled,
+  colorShellPrompt,
+  commands,
+  configuration,
+  historyPath,
+  projectCommand,
+  sessionSettings,
+  shellPrompt,
+  templateResolverInfos,
+  autoStartServer,
+  serverHost,
+  serverIdleTimeout,
+  serverLog,
+  serverPort,
+  serverUseJni,
+  serverAuthentication,
+  serverConnectionType,
+  fullServerHandlers,
+  logLevel,
+  windowsServerSecurityLevel,
+}
+import Scope.{ Global, ThisScope }
+import sbt.SlashSyntax0._
 import Def.{ Flattened, Initialize, ScopedKey, Setting }
-import sbt.internal.{ Load, BuildStructure, LoadedBuild, LoadedBuildUnit, SettingGraph, SettingCompletions, AddSettings, SessionSettings }
-import sbt.internal.util.{ AttributeKey, AttributeMap, Dag, Eval, Relation, Settings, Show, ~> }
+import sbt.internal.{
+  Load,
+  BuildStructure,
+  LoadedBuild,
+  LoadedBuildUnit,
+  SettingGraph,
+  SettingCompletions,
+  SessionSettings
+}
+import sbt.internal.util.{ AttributeKey, AttributeMap, Dag, Relation, Settings, ~> }
 import sbt.internal.util.Types.{ const, idFun }
 import sbt.internal.util.complete.DefaultParsers
+import sbt.internal.server.ServerHandler
 import sbt.librarymanagement.Configuration
+import sbt.util.{ Show, Level }
+import sjsonnew.JsonFormat
 
 import language.experimental.macros
+import scala.concurrent.TimeoutException
+import scala.concurrent.duration.FiniteDuration
 
 sealed trait ProjectDefinition[PR <: ProjectReference] {
+
   /**
    * The project ID is used to uniquely identify a project within a build.
    * It is used to refer to a project from the command line and in the scope of keys.
@@ -47,18 +89,12 @@ sealed trait ProjectDefinition[PR <: ProjectReference] {
    */
   def aggregate: Seq[PR]
 
-  @deprecated("Delegation between projects should be replaced by directly sharing settings.", "0.13.0")
-  def delegates: Seq[PR]
-
   /** The references to projects that are classpath dependencies of this project. */
   def dependencies: Seq[ClasspathDep[PR]]
 
   /** The references to projects that are aggregate and classpath dependencies of this project. */
   def uses: Seq[PR] = aggregate ++ dependencies.map(_.project)
-  def referenced: Seq[PR] = delegates ++ uses
-
-  /** Configures the sources of automatically appended settings.*/
-  def auto: AddSettings
+  def referenced: Seq[PR] = uses
 
   /**
    * The defined [[Plugins]] associated with this project.
@@ -73,68 +109,122 @@ sealed trait ProjectDefinition[PR <: ProjectReference] {
   private[sbt] def autoPlugins: Seq[AutoPlugin]
 
   override final def hashCode: Int = id.hashCode ^ base.hashCode ^ getClass.hashCode
+
   override final def equals(o: Any) = o match {
     case p: ProjectDefinition[_] => p.getClass == this.getClass && p.id == id && p.base == base
     case _                       => false
   }
-  override def toString =
-    {
-      val agg = ifNonEmpty("aggregate", aggregate)
-      val dep = ifNonEmpty("dependencies", dependencies)
-      val conf = ifNonEmpty("configurations", configurations)
-      val autos = ifNonEmpty("autoPlugins", autoPlugins.map(_.label))
-      val fields = s"id $id" :: s"base: $base" :: agg ::: dep ::: conf ::: (s"plugins: List($plugins)" :: autos)
-      s"Project(${fields.mkString(", ")})"
-    }
-  private[this] def ifNonEmpty[T](label: String, ts: Iterable[T]): List[String] = if (ts.isEmpty) Nil else s"$label: $ts" :: Nil
+
+  override def toString = {
+    val agg = ifNonEmpty("aggregate", aggregate)
+    val dep = ifNonEmpty("dependencies", dependencies)
+    val conf = ifNonEmpty("configurations", configurations)
+    val autos = ifNonEmpty("autoPlugins", autoPlugins.map(_.label))
+    val fields = s"id $id" :: s"base: $base" :: agg ::: dep ::: conf ::: (s"plugins: List($plugins)" :: autos)
+    s"Project(${fields.mkString(", ")})"
+  }
+
+  private[this] def ifNonEmpty[T](label: String, ts: Iterable[T]): List[String] =
+    if (ts.isEmpty) Nil else s"$label: $ts" :: Nil
 }
-sealed trait Project extends ProjectDefinition[ProjectReference] {
-  private[sbt] def settingsEval: Eval[Seq[Def.Setting[_]]]
-  private[sbt] def aggregateEval: Eval[Seq[ProjectReference]]
-  private[sbt] def delegatesEval: Eval[Seq[ProjectReference]]
-  private[sbt] def dependenciesEval: Eval[Seq[ClasspathDep[ProjectReference]]]
 
+trait CompositeProject {
+  def componentProjects: Seq[Project]
+}
 
-  // TODO: add parameters for plugins in 0.14.0 (not reasonable to do in a binary compatible way in 0.13)
-  private[sbt] def copy(id: String = id,
-    base: File = base,
-    aggregateEval: Eval[Seq[ProjectReference]] = aggregateEval,
-    dependenciesEval: Eval[Seq[ClasspathDep[ProjectReference]]] = dependenciesEval,
-    delegatesEval: Eval[Seq[ProjectReference]] = delegatesEval,
-    settingsEval: Eval[Seq[Setting[_]]] = settingsEval,
-    configurations: Seq[Configuration] = configurations,
-    auto: AddSettings = auto): Project =
-    unresolved(id, base,
-      aggregateEval = aggregateEval,
-      dependenciesEval = dependenciesEval,
-      delegatesEval = delegatesEval,
-      settingsEval = settingsEval,
-      configurations, auto, plugins, autoPlugins, projectOrigin)
+private[sbt] object CompositeProject {
 
-  def resolve(resolveRef: ProjectReference => ProjectRef): ResolvedProject =
-    {
-      def resolveRefs(prs: Seq[ProjectReference]) = prs map resolveRef
-      def resolveDeps(ds: Seq[ClasspathDep[ProjectReference]]) = ds map resolveDep
-      def resolveDep(d: ClasspathDep[ProjectReference]) = ResolvedClasspathDependency(resolveRef(d.project), d.configuration)
-      resolved(id, base,
-        aggregateEval = aggregateEval map resolveRefs,
-        dependenciesEval = dependenciesEval map resolveDeps,
-        delegatesEval = delegatesEval map resolveRefs,
-        settingsEval,
-        configurations, auto, plugins, autoPlugins, projectOrigin)
-    }
-  def resolveBuild(resolveRef: ProjectReference => ProjectReference): Project =
-    {
-      def resolveRefs(prs: Seq[ProjectReference]) = prs map resolveRef
-      def resolveDeps(ds: Seq[ClasspathDep[ProjectReference]]) = ds map resolveDep
-      def resolveDep(d: ClasspathDep[ProjectReference]) = ClasspathDependency(resolveRef(d.project), d.configuration)
-      unresolved(id, base,
-        aggregateEval = aggregateEval map resolveRefs,
-        dependenciesEval = dependenciesEval map resolveDeps,
-        delegatesEval = delegatesEval map resolveRefs,
-        settingsEval,
-        configurations, auto, plugins, autoPlugins, projectOrigin)
+  /**
+   *  Expand user defined projects with the component projects of `compositeProjects`.
+   *
+   *  If two projects with the same id appear in the user defined projects and
+   *  in `compositeProjects.componentProjects`, the user defined project wins.
+   *  This is necessary for backward compatibility with the idioms:
+   *  {{{
+   *    lazy val foo = crossProject
+   *    lazy val fooJS = foo.js.settings(...)
+   *    lazy val fooJVM = foo.jvm.settings(...)
+   *  }}}
+   *  and the rarer:
+   *  {{{
+   *    lazy val fooJS = foo.js.settings(...)
+   *    lazy val foo = crossProject
+   *    lazy val fooJVM = foo.jvm.settings(...)
+   *  }}}
+   */
+  def expand(compositeProjects: Seq[CompositeProject]): Seq[Project] = {
+    val userProjects = compositeProjects.collect { case p: Project => p }
+    for (p <- compositeProjects.flatMap(_.componentProjects)) yield {
+      userProjects.find(_.id == p.id) match {
+        case Some(userProject) => userProject
+        case None              => p
+      }
     }
+  }.distinct
+
+}
+
+sealed trait Project extends ProjectDefinition[ProjectReference] with CompositeProject {
+  def componentProjects: Seq[Project] = this :: Nil
+
+  private[sbt] def copy(
+      id: String = id,
+      base: File = base,
+      aggregate: Seq[ProjectReference] = aggregate,
+      dependencies: Seq[ClasspathDep[ProjectReference]] = dependencies,
+      settings: Seq[Setting[_]] = settings,
+      configurations: Seq[Configuration] = configurations
+  ): Project =
+    copy2(id, base, aggregate, dependencies, settings, configurations)
+
+  private[this] def copy2(
+      id: String = id,
+      base: File = base,
+      aggregate: Seq[ProjectReference] = aggregate,
+      dependencies: Seq[ClasspathDep[ProjectReference]] = dependencies,
+      settings: Seq[Setting[_]] = settings,
+      configurations: Seq[Configuration] = configurations,
+      plugins: Plugins = plugins,
+      autoPlugins: Seq[AutoPlugin] = autoPlugins,
+      projectOrigin: ProjectOrigin = projectOrigin,
+  ): Project =
+    unresolved(
+      id,
+      base,
+      aggregate = aggregate,
+      dependencies = dependencies,
+      settings = settings,
+      configurations,
+      plugins,
+      autoPlugins,
+      projectOrigin
+    )
+
+  def resolve(resolveRef: ProjectReference => ProjectRef): ResolvedProject = {
+    def resolveRefs(prs: Seq[ProjectReference]) = prs map resolveRef
+    def resolveDeps(ds: Seq[ClasspathDep[ProjectReference]]) = ds map resolveDep
+    def resolveDep(d: ClasspathDep[ProjectReference]) =
+      ResolvedClasspathDependency(resolveRef(d.project), d.configuration)
+    resolved(
+      id,
+      base,
+      aggregate = resolveRefs(aggregate),
+      dependencies = resolveDeps(dependencies),
+      settings,
+      configurations,
+      plugins,
+      autoPlugins,
+      projectOrigin
+    )
+  }
+
+  def resolveBuild(resolveRef: ProjectReference => ProjectReference): Project = {
+    def resolveRefs(prs: Seq[ProjectReference]) = prs map resolveRef
+    def resolveDeps(ds: Seq[ClasspathDep[ProjectReference]]) = ds map resolveDep
+    def resolveDep(d: ClasspathDep[ProjectReference]) =
+      ClasspathDependency(resolveRef(d.project), d.configuration)
+    copy2(aggregate = resolveRefs(aggregate), dependencies = resolveDeps(dependencies))
+  }
 
   /**
    * Applies the given functions to this Project.
@@ -143,81 +233,39 @@ sealed trait Project extends ProjectDefinition[ProjectReference] {
    */
   def configure(transforms: (Project => Project)*): Project = Function.chain(transforms)(this)
 
+  def withId(id: String) = copy(id = id)
+
   /** Sets the base directory for this project.*/
   def in(dir: File): Project = copy(base = dir)
 
   /** Adds configurations to this project.  Added configurations replace existing configurations with the same name.*/
-  def overrideConfigs(cs: Configuration*): Project = copy(configurations = Defaults.overrideConfigs(cs: _*)(configurations))
+  def overrideConfigs(cs: Configuration*): Project =
+    copy(configurations = Defaults.overrideConfigs(cs: _*)(configurations))
 
   /**
    * Adds configuration at the *start* of the configuration list for this project.  Previous configurations replace this prefix
    * list with the same name.
    */
-  private[sbt] def prefixConfigs(cs: Configuration*): Project = copy(configurations = Defaults.overrideConfigs(configurations: _*)(cs))
+  private[sbt] def prefixConfigs(cs: Configuration*): Project =
+    copy(configurations = Defaults.overrideConfigs(configurations: _*)(cs))
 
   /** Adds new configurations directly to this project.  To override an existing configuration, use `overrideConfigs`. */
   def configs(cs: Configuration*): Project = copy(configurations = configurations ++ cs)
 
   /** Adds classpath dependencies on internal or external projects. */
-  def dependsOn(deps: Eval[ClasspathDep[ProjectReference]]*): Project =
-    copy(dependenciesEval = dependenciesEval flatMap { ds0 =>
-      sequenceEval(deps.toSeq) map { ds1 => ds0 ++ ds1 }
-    })
-
-  /** Adds classpath dependencies on internal or external projects. */
-  def dependsOnSeq(deps: => Seq[ClasspathDep[ProjectReference]]): Project =
-    copy(dependenciesEval = dependenciesEval flatMap { ds0 =>
-      Eval.later { deps } map { ds1 => ds0 ++ ds1 }
-    })
-
-  // @deprecated("Delegation between projects should be replaced by directly sharing settings.", "0.13.0")
-  // def delegateTo(from: ProjectReference*): Project = copy(delegates = delegates ++ from)
+  def dependsOn(deps: ClasspathDep[ProjectReference]*): Project =
+    copy(dependencies = dependencies ++ deps)
 
   /**
    * Adds projects to be aggregated.  When a user requests a task to run on this project from the command line,
    * the task will also be run in aggregated projects.
    */
-  def aggregate(refs: Eval[ProjectReference]*): Project =
-    copy(aggregateEval = aggregateEval flatMap { as0 =>
-      sequenceEval(refs.toSeq) map { as1 => as0 ++ as1 }
-    })
-
-  /**
-   * Adds projects to be aggregated.  When a user requests a task to run on this project from the command line,
-   * the task will also be run in aggregated projects.
-   */
-  def aggregateSeq(refs: => Seq[ProjectReference]): Project =
-    copy(aggregateEval = aggregateEval flatMap { as0 =>
-      // sequenceEval(refs.toSeq) map { as1 => as0 ++ as1 }
-      Eval.later { refs } map { as1 => as0 ++ as1 }
-    })
+  def aggregate(refs: ProjectReference*): Project =
+    copy(aggregate = (aggregate: Seq[ProjectReference]) ++ refs)
 
   /** Appends settings to the current settings sequence for this project. */
   def settings(ss: Def.SettingsDefinition*): Project =
-    copy(settingsEval = settingsEval map { ss0 =>
-      (ss0: Seq[Def.Setting[_]]) ++ Def.settings(ss: _*)
-    })
-
-  /** Appends settings to the current settings sequence for this project. */
-  def settingsLazy(ss: Eval[Def.SettingsDefinition]*): Project =
-    copy(settingsEval = settingsEval flatMap { ss0 =>
-      sequenceEval(ss.toSeq) map { ss1 => (ss0: Seq[Def.Setting[_]]) ++ Def.settings(ss1: _*) }
-    })
-
-  /** Configures how settings from other sources, such as .sbt files, are appended to the explicitly specified settings for this project. */
-  def settingSets(select: AddSettings*): Project = copy(auto = AddSettings.seq(select: _*))
-
-  /**
-   * Adds a list of .sbt files whose settings will be appended to the settings of this project.
-   * They will be appended after the explicit settings and already defined automatic settings sources.
-   */
-  def addSbtFiles(files: File*): Project = copy(auto = AddSettings.append(auto, AddSettings.sbtFiles(files: _*)))
-
-  /**
-   * Sets the list of .sbt files to parse for settings to be appended to this project's settings.
-   * Any configured .sbt files are removed from this project's list.
-   */
-  def setSbtFiles(files: File*): Project = copy(auto = AddSettings.append(AddSettings.clearSbtFiles(auto), AddSettings.sbtFiles(files: _*)))
+    copy(settings = (settings: Seq[Def.Setting[_]]) ++ Def.settings(ss: _*))
 
   /**
    * Sets the [[AutoPlugin]]s of this project.
@@ -229,119 +277,114 @@ sealed trait Project extends ProjectDefinition[ProjectReference] {
   def disablePlugins(ps: AutoPlugin*): Project =
     setPlugins(Plugins.and(plugins, Plugins.And(ps.map(p => Plugins.Exclude(p)).toList)))
 
-  private[this] def setPlugins(ns: Plugins): Project = {
-    // TODO: for 0.14.0, use copy when it has the additional `plugins` parameter
-    unresolved(id, base, aggregateEval = aggregateEval, dependenciesEval = dependenciesEval, delegatesEval = delegatesEval, settingsEval, configurations, auto, ns, autoPlugins, projectOrigin)
-  }
+  private[sbt] def setPlugins(ns: Plugins): Project = copy2(plugins = ns)
 
   /** Definitively set the [[AutoPlugin]]s for this project. */
-  private[sbt] def setAutoPlugins(autos: Seq[AutoPlugin]): Project = {
-    // TODO: for 0.14.0, use copy when it has the additional `autoPlugins` parameter
-    unresolved(id, base, aggregateEval = aggregateEval, dependenciesEval = dependenciesEval, delegatesEval = delegatesEval, settingsEval, configurations, auto, plugins, autos, projectOrigin)
-  }
+  private[sbt] def setAutoPlugins(autos: Seq[AutoPlugin]): Project = copy2(autoPlugins = autos)
 
   /** Definitively set the [[ProjectOrigin]] for this project. */
-  private[sbt] def setProjectOrigin(origin: ProjectOrigin): Project = {
-    // TODO: for 1.0.x, use withProjectOrigin.
-    unresolved(id, base, aggregateEval = aggregateEval, dependenciesEval = dependenciesEval, delegatesEval = delegatesEval, settingsEval, configurations, auto, plugins, autoPlugins, origin)
-  }
+  private[sbt] def setProjectOrigin(origin: ProjectOrigin): Project = copy2(projectOrigin = origin)
 }
+
 sealed trait ResolvedProject extends ProjectDefinition[ProjectRef] {
+
   /** The [[AutoPlugin]]s enabled for this project as computed from [[plugins]].*/
   def autoPlugins: Seq[AutoPlugin]
+
 }
 
-sealed trait ClasspathDep[PR <: ProjectReference] { def project: PR; def configuration: Option[String] }
-final case class ResolvedClasspathDependency(project: ProjectRef, configuration: Option[String]) extends ClasspathDep[ProjectRef]
-final case class ClasspathDependency(project: ProjectReference, configuration: Option[String]) extends ClasspathDep[ProjectReference]
-
-/**
- * Indicate whether the project was created organically, synthesized by a plugin,
- * or is a "generic root" project supplied by sbt when a project doesn't exist for `file(".")`.
- */
-sealed trait ProjectOrigin
-object ProjectOrigin {
-  case object Organic        extends ProjectOrigin
-  case object ExtraProject   extends ProjectOrigin
-  case object DerivedProject extends ProjectOrigin
-  case object GenericRoot    extends ProjectOrigin
+sealed trait ClasspathDep[PR <: ProjectReference] {
+  def project: PR; def configuration: Option[String]
 }
 
+final case class ResolvedClasspathDependency(project: ProjectRef, configuration: Option[String])
+    extends ClasspathDep[ProjectRef]
+
+final case class ClasspathDependency(project: ProjectReference, configuration: Option[String])
+    extends ClasspathDep[ProjectReference]
+
 object Project extends ProjectExtra {
 
   private abstract class ProjectDef[PR <: ProjectReference](
       val id: String,
       val base: File,
-      val aggregateEval: Eval[Seq[PR]],
-      val dependenciesEval: Eval[Seq[ClasspathDep[PR]]],
-      val delegatesEval: Eval[Seq[PR]],
-      val settingsEval: Eval[Seq[Def.Setting[_]]],
+      val aggregate: Seq[PR],
+      val dependencies: Seq[ClasspathDep[PR]],
+      val settings: Seq[Def.Setting[_]],
       val configurations: Seq[Configuration],
-      val auto: AddSettings,
       val plugins: Plugins,
       val autoPlugins: Seq[AutoPlugin],
-      val projectOrigin: ProjectOrigin) extends ProjectDefinition[PR] {
-    def aggregate: Seq[PR] = aggregateEval.get
-    def dependencies: Seq[ClasspathDep[PR]] = dependenciesEval.get
-    def delegates: Seq[PR] = delegatesEval.get
-    def settings: Seq[Def.Setting[_]] = settingsEval.get
-
-    Dag.topologicalSort(configurations)(_.extendsConfigs) // checks for cyclic references here instead of having to do it in Scope.delegates
+      val projectOrigin: ProjectOrigin
+  ) extends ProjectDefinition[PR] {
+    // checks for cyclic references here instead of having to do it in Scope.delegates
+    Dag.topologicalSort(configurations)(_.extendsConfigs)
   }
 
-  private def evalNil[A]: Eval[Seq[A]] = Eval.now(Vector())
-  // hardcoded version of sequence for flipping Eval and Seq
-  def sequenceEval[A](es: Seq[Eval[A]]): Eval[Seq[A]] =
-    (evalNil[A] /: es) { (acc0, x0) =>
-      acc0 flatMap { acc =>
-        x0 map { x => acc :+ x }
-      }
-    }
-
   def apply(id: String, base: File): Project =
-    unresolved(id, base, evalNil, evalNil, evalNil, evalNil, Nil, AddSettings.allDefaults, Plugins.empty, Nil, ProjectOrigin.Organic)
-
-  // TODO: add parameter for plugins and projectOrigin in 1.0
-  // TODO: Modify default settings to be the core settings, and automatically add the IvyModule + JvmPlugins.
-  // def apply(id: String, base: File, aggregate: => Seq[ProjectReference] = Nil, dependencies: => Seq[ClasspathDep[ProjectReference]] = Nil,
-  //  delegates: => Seq[ProjectReference] = Nil, settings: => Seq[Def.Setting[_]] = Nil, configurations: Seq[Configuration] = Nil,
-  //  auto: AddSettings = AddSettings.allDefaults): Project =
-  //  unresolved(id, base, aggregate, dependencies, delegates, settings, configurations, auto, Plugins.empty, Nil) // Note: JvmModule/IvyModule auto included...
+    unresolved(id, base, Nil, Nil, Nil, Nil, Plugins.empty, Nil, ProjectOrigin.Organic)
 
   def showContextKey(state: State): Show[ScopedKey[_]] =
     showContextKey(state, None)
 
   def showContextKey(state: State, keyNameColor: Option[String]): Show[ScopedKey[_]] =
-    if (isProjectLoaded(state)) showContextKey(session(state), structure(state), keyNameColor) else Def.showFullKey
+    if (isProjectLoaded(state)) showContextKey2(session(state), keyNameColor)
+    else Def.showFullKey
 
-  def showContextKey(session: SessionSettings, structure: BuildStructure, keyNameColor: Option[String] = None): Show[ScopedKey[_]] =
-    Def.showRelativeKey(session.current, structure.allProjects.size > 1, keyNameColor)
+  @deprecated("Use showContextKey2 which doesn't take the unused structure param", "1.1.1")
+  def showContextKey(
+      session: SessionSettings,
+      structure: BuildStructure,
+      keyNameColor: Option[String] = None
+  ): Show[ScopedKey[_]] =
+    showContextKey2(session, keyNameColor)
 
-  def showLoadingKey(loaded: LoadedBuild, keyNameColor: Option[String] = None): Show[ScopedKey[_]] =
-    Def.showRelativeKey(ProjectRef(loaded.root, loaded.units(loaded.root).rootProjects.head), loaded.allProjectRefs.size > 1, keyNameColor)
+  def showContextKey2(
+      session: SessionSettings,
+      keyNameColor: Option[String] = None
+  ): Show[ScopedKey[_]] =
+    Def.showRelativeKey2(session.current, keyNameColor)
+
+  def showLoadingKey(
+      loaded: LoadedBuild,
+      keyNameColor: Option[String] = None
+  ): Show[ScopedKey[_]] =
+    Def.showRelativeKey2(
+      ProjectRef(loaded.root, loaded.units(loaded.root).rootProjects.head),
+      keyNameColor
+    )
 
   /** This is a variation of def apply that mixes in GeneratedRootProject. */
-  private[sbt] def mkGeneratedRoot(id: String, base: File, aggregate: Eval[Seq[ProjectReference]]): Project =
-    {
-      validProjectID(id).foreach(errMsg => sys.error("Invalid project ID: " + errMsg))
-      new ProjectDef[ProjectReference](id, base, aggregate, evalNil, evalNil, evalNil, Nil, AddSettings.allDefaults, Plugins.empty, Nil, ProjectOrigin.GenericRoot) with Project with GeneratedRootProject
-    }
+  private[sbt] def mkGeneratedRoot(
+      id: String,
+      base: File,
+      aggregate: Seq[ProjectReference]
+  ): Project = {
+    validProjectID(id).foreach(errMsg => sys.error(s"Invalid project ID: $errMsg"))
+    val plugins = Plugins.empty
+    val origin = ProjectOrigin.GenericRoot
+    new ProjectDef(id, base, aggregate, Nil, Nil, Nil, plugins, Nil, origin)
+      with Project
+      with GeneratedRootProject
+  }
 
   /** Returns None if `id` is a valid Project ID or Some containing the parser error message if it is not.*/
-  def validProjectID(id: String): Option[String] = DefaultParsers.parse(id, DefaultParsers.ID).left.toOption
-  private[this] def validProjectIDStart(id: String): Boolean = DefaultParsers.parse(id, DefaultParsers.IDStart).isRight
+  def validProjectID(id: String): Option[String] =
+    DefaultParsers.parse(id, DefaultParsers.ID).left.toOption
+
+  private[this] def validProjectIDStart(id: String): Boolean =
+    DefaultParsers.parse(id, DefaultParsers.IDStart).isRight
 
   /** Constructs a valid Project ID based on `id` and returns it in Right or returns the error message in Left if one cannot be constructed.*/
-  def normalizeProjectID(id: String): Either[String, String] =
-    {
-      val attempt = normalizeBase(id)
-      val refined =
-        if (attempt.length < 1) "root"
-        else if (!validProjectIDStart(attempt.substring(0, 1))) "root-" + attempt
-        else attempt
-      validProjectID(refined).toLeft(refined)
-    }
-  private[this] def normalizeBase(s: String) = s.toLowerCase(Locale.ENGLISH).replaceAll("""\W+""", "-")
+  def normalizeProjectID(id: String): Either[String, String] = {
+    val attempt = normalizeBase(id)
+    val refined =
+      if (attempt.length < 1) "root"
+      else if (!validProjectIDStart(attempt.substring(0, 1))) "root-" + attempt
+      else attempt
+    validProjectID(refined).toLeft(refined)
+  }
+  private[this] def normalizeBase(s: String) =
+    s.toLowerCase(Locale.ENGLISH).replaceAll("""\W+""", "-")
 
   /**
    * Normalize a String so that it is suitable for use as a dependency management module identifier.
@@ -349,106 +392,209 @@ object Project extends ProjectExtra {
    */
   def normalizeModuleID(id: String): String = normalizeBase(id)
 
-  private def resolved(id: String, base: File, aggregateEval: Eval[Seq[ProjectRef]], dependenciesEval: Eval[Seq[ClasspathDep[ProjectRef]]],
-    delegatesEval: Eval[Seq[ProjectRef]], settingsEval: Eval[Seq[Def.Setting[_]]], configurations: Seq[Configuration], auto: AddSettings,
-    plugins: Plugins, autoPlugins: Seq[AutoPlugin], origin: ProjectOrigin): ResolvedProject =
-    new ProjectDef[ProjectRef](id, base, aggregateEval, dependenciesEval, delegatesEval, settingsEval, configurations, auto, plugins, autoPlugins, origin) with ResolvedProject
+  private def resolved(
+      id: String,
+      base: File,
+      aggregate: Seq[ProjectRef],
+      dependencies: Seq[ClasspathDep[ProjectRef]],
+      settings: Seq[Def.Setting[_]],
+      configurations: Seq[Configuration],
+      plugins: Plugins,
+      autoPlugins: Seq[AutoPlugin],
+      origin: ProjectOrigin
+  ): ResolvedProject =
+    new ProjectDef[ProjectRef](
+      id,
+      base,
+      aggregate,
+      dependencies,
+      settings,
+      configurations,
+      plugins,
+      autoPlugins,
+      origin
+    ) with ResolvedProject
 
-  private def unresolved(id: String, base: File, aggregateEval: Eval[Seq[ProjectReference]], dependenciesEval: Eval[Seq[ClasspathDep[ProjectReference]]],
-    delegatesEval: Eval[Seq[ProjectReference]], settingsEval: Eval[Seq[Def.Setting[_]]], configurations: Seq[Configuration], auto: AddSettings,
-    plugins: Plugins, autoPlugins: Seq[AutoPlugin], origin: ProjectOrigin): Project =
-    {
-      validProjectID(id).foreach(errMsg => sys.error("Invalid project ID: " + errMsg))
-      new ProjectDef[ProjectReference](id, base, aggregateEval, dependenciesEval, delegatesEval, settingsEval, configurations, auto, plugins, autoPlugins, origin) with Project
-    }
+  private def unresolved(
+      id: String,
+      base: File,
+      aggregate: Seq[ProjectReference],
+      dependencies: Seq[ClasspathDep[ProjectReference]],
+      settings: Seq[Def.Setting[_]],
+      configurations: Seq[Configuration],
+      plugins: Plugins,
+      autoPlugins: Seq[AutoPlugin],
+      origin: ProjectOrigin
+  ): Project = {
+    validProjectID(id).foreach(errMsg => sys.error("Invalid project ID: " + errMsg))
+    new ProjectDef[ProjectReference](
+      id,
+      base,
+      aggregate,
+      dependencies,
+      settings,
+      configurations,
+      plugins,
+      autoPlugins,
+      origin
+    ) with Project
+  }
 
   final class Constructor(p: ProjectReference) {
     def %(conf: Configuration): ClasspathDependency = %(conf.name)
 
-    def %(conf: String): ClasspathDependency = new ClasspathDependency(p, Some(conf))
+    def %(conf: String): ClasspathDependency = ClasspathDependency(p, Some(conf))
   }
 
-  def getOrError[T](state: State, key: AttributeKey[T], msg: String): T = state get key getOrElse sys.error(msg)
-  def structure(state: State): BuildStructure = getOrError(state, stateBuildStructure, "No build loaded.")
-  def session(state: State): SessionSettings = getOrError(state, sessionSettings, "Session not initialized.")
-  def isProjectLoaded(state: State): Boolean = (state has sessionSettings) && (state has stateBuildStructure)
+  def getOrError[T](state: State, key: AttributeKey[T], msg: String): T =
+    state get key getOrElse sys.error(msg)
+
+  def structure(state: State): BuildStructure =
+    getOrError(state, stateBuildStructure, "No build loaded.")
+
+  def session(state: State): SessionSettings =
+    getOrError(state, sessionSettings, "Session not initialized.")
+
+  def isProjectLoaded(state: State): Boolean =
+    (state has sessionSettings) && (state has stateBuildStructure)
 
   def extract(state: State): Extracted = extract(session(state), structure(state))
-  private[sbt] def extract(se: SessionSettings, st: BuildStructure): Extracted = Extracted(st, se, se.current)(showContextKey(se, st))
+
+  private[sbt] def extract(se: SessionSettings, st: BuildStructure): Extracted =
+    Extracted(st, se, se.current)(showContextKey2(se))
 
   def getProjectForReference(ref: Reference, structure: BuildStructure): Option[ResolvedProject] =
     ref match { case pr: ProjectRef => getProject(pr, structure); case _ => None }
-  def getProject(ref: ProjectRef, structure: BuildStructure): Option[ResolvedProject] = getProject(ref, structure.units)
-  def getProject(ref: ProjectRef, structure: LoadedBuild): Option[ResolvedProject] = getProject(ref, structure.units)
+
+  def getProject(ref: ProjectRef, structure: BuildStructure): Option[ResolvedProject] =
+    getProject(ref, structure.units)
+
+  def getProject(ref: ProjectRef, structure: LoadedBuild): Option[ResolvedProject] =
+    getProject(ref, structure.units)
+
   def getProject(ref: ProjectRef, units: Map[URI, LoadedBuildUnit]): Option[ResolvedProject] =
     (units get ref.build).flatMap(_.defined get ref.project)
 
-  def runUnloadHooks(s: State): State =
-    {
-      val previousOnUnload = orIdentity(s get Keys.onUnload.key)
-      previousOnUnload(s.runExitHooks())
-    }
+  def runUnloadHooks(s: State): State = {
+    val previousOnUnload = orIdentity(s get Keys.onUnload.key)
+    previousOnUnload(s.runExitHooks())
+  }
+
   def setProject(session: SessionSettings, structure: BuildStructure, s: State): State =
-    {
-      val unloaded = runUnloadHooks(s)
-      val (onLoad, onUnload) = getHooks(structure.data)
-      val newAttrs = unloaded.attributes.put(stateBuildStructure, structure).put(sessionSettings, session).put(Keys.onUnload.key, onUnload)
-      val newState = unloaded.copy(attributes = newAttrs)
-      onLoad(LogManager.setGlobalLogLevels(updateCurrent(newState), structure.data))
-    }
+    setProject(session, structure, s, identity)
+
+  def setProject(
+      session: SessionSettings,
+      structure: BuildStructure,
+      s: State,
+      preOnLoad: State => State
+  ): State = {
+    val unloaded = runUnloadHooks(s)
+    val (onLoad, onUnload) = getHooks(structure.data)
+    val newAttrs = unloaded.attributes
+      .put(stateBuildStructure, structure)
+      .put(sessionSettings, session)
+      .put(Keys.onUnload.key, onUnload)
+    val newState = unloaded.copy(attributes = newAttrs)
+    // TODO: Fix this
+    onLoad(
+      preOnLoad(updateCurrent(newState)) /*LogManager.setGlobalLogLevels(updateCurrent(newState), structure.data)*/
+    )
+  }
 
   def orIdentity[T](opt: Option[T => T]): T => T = opt getOrElse idFun
-  def getHook[T](key: SettingKey[T => T], data: Settings[Scope]): T => T = orIdentity(key in GlobalScope get data)
-  def getHooks(data: Settings[Scope]): (State => State, State => State) = (getHook(Keys.onLoad, data), getHook(Keys.onUnload, data))
+
+  def getHook[T](key: SettingKey[T => T], data: Settings[Scope]): T => T =
+    orIdentity((Global / key) get data)
+
+  def getHooks(data: Settings[Scope]): (State => State, State => State) =
+    (getHook(Keys.onLoad, data), getHook(Keys.onUnload, data))
 
   def current(state: State): ProjectRef = session(state).current
-  def updateCurrent(s: State): State =
-    {
-      val structure = Project.structure(s)
-      val ref = Project.current(s)
-      Load.getProject(structure.units, ref.build, ref.project)
-      val msg = Keys.onLoadMessage in ref get structure.data getOrElse ""
-      if (!msg.isEmpty) s.log.info(msg)
-      def get[T](k: SettingKey[T]): Option[T] = k in ref get structure.data
-      def commandsIn(axis: ResolvedReference) = commands in axis get structure.data toList
 
-      val allCommands = commandsIn(ref) ++ commandsIn(BuildRef(ref.build)) ++ (commands in Global get structure.data toList)
-      val history = get(historyPath) flatMap idFun
-      val prompt = get(shellPrompt)
-      val watched = get(watch)
-      val port: Option[Int] = get(serverPort)
-      val commandDefs = allCommands.distinct.flatten[Command].map(_ tag (projectCommand, true))
-      val newDefinedCommands = commandDefs ++ BasicCommands.removeTagged(s.definedCommands, projectCommand)
-      val newAttrs0 = setCond(Watched.Configuration, watched, s.attributes).put(historyPath.key, history)
-      val newAttrs = setCond(serverPort.key, port, newAttrs0)
-      s.copy(attributes = setCond(shellPrompt.key, prompt, newAttrs), definedCommands = newDefinedCommands)
-    }
+  def updateCurrent(s: State): State = {
+    val structure = Project.structure(s)
+    val ref = Project.current(s)
+    Load.getProject(structure.units, ref.build, ref.project)
+    val msg = (ref / Keys.onLoadMessage) get structure.data getOrElse ""
+    if (!msg.isEmpty) s.log.info(msg)
+    def get[T](k: SettingKey[T]): Option[T] = (ref / k) get structure.data
+    def commandsIn(axis: ResolvedReference) = (axis / commands) get structure.data toList
+
+    val allCommands = commandsIn(ref) ++ commandsIn(BuildRef(ref.build)) ++ ((Global / commands) get structure.data toList)
+    val history = get(historyPath) flatMap idFun
+    val prompt = get(shellPrompt)
+    val newPrompt = get(colorShellPrompt)
+    val trs = ((Global / templateResolverInfos) get structure.data).toList.flatten
+    val startSvr: Option[Boolean] = get(autoStartServer)
+    val host: Option[String] = get(serverHost)
+    val port: Option[Int] = get(serverPort)
+    val enabledBsp: Option[Boolean] = get(bspEnabled)
+    val timeout: Option[Option[FiniteDuration]] = get(serverIdleTimeout)
+    val authentication: Option[Set[ServerAuthentication]] = get(serverAuthentication)
+    val connectionType: Option[ConnectionType] = get(serverConnectionType)
+    val srvLogLevel: Option[Level.Value] = (ref / serverLog / logLevel).get(structure.data)
+    val hs: Option[Seq[ServerHandler]] = get(ThisBuild / fullServerHandlers)
+    val commandDefs = allCommands.distinct.flatten[Command].map(_ tag (projectCommand, true))
+    val newDefinedCommands = commandDefs ++ BasicCommands.removeTagged(
+      s.definedCommands,
+      projectCommand
+    )
+    val winSecurityLevel = get(windowsServerSecurityLevel).getOrElse(2)
+    val useJni = get(serverUseJni).getOrElse(false)
+    val newAttrs =
+      s.attributes
+        .put(historyPath.key, history)
+        .put(windowsServerSecurityLevel.key, winSecurityLevel)
+        .put(serverUseJni.key, useJni)
+        .setCond(bspEnabled.key, enabledBsp)
+        .setCond(autoStartServer.key, startSvr)
+        .setCond(serverPort.key, port)
+        .setCond(serverHost.key, host)
+        .setCond(serverAuthentication.key, authentication)
+        .setCond(serverConnectionType.key, connectionType)
+        .setCond(serverIdleTimeout.key, timeout)
+        .put(historyPath.key, history)
+        .put(templateResolverInfos.key, trs)
+        .setCond(shellPrompt.key, prompt)
+        .setCond(colorShellPrompt.key, newPrompt)
+        .setCond(serverLogLevel, srvLogLevel)
+        .setCond(fullServerHandlers.key, hs)
+    s.copy(
+      attributes = newAttrs,
+      definedCommands = newDefinedCommands
+    )
+  }
+
   def setCond[T](key: AttributeKey[T], vopt: Option[T], attributes: AttributeMap): AttributeMap =
-    vopt match { case Some(v) => attributes.put(key, v); case None => attributes.remove(key) }
+    attributes.setCond(key, vopt)
 
-  private[sbt] def checkTargets(data: Settings[Scope]): Option[String] =
-    {
-      val dups = overlappingTargets(allTargets(data))
-      if (dups.isEmpty)
-        None
-      else {
-        val dupStrs = dups map {
-          case (dir, scopes) =>
-            s"${dir.getAbsolutePath}:\n\t${scopes.mkString("\n\t")}"
-        }
-        Some(s"Overlapping output directories:${dupStrs.mkString}")
+  private[sbt] def checkTargets(data: Settings[Scope]): Option[String] = {
+    val dups = overlappingTargets(allTargets(data))
+    if (dups.isEmpty)
+      None
+    else {
+      val dupStrs = dups map {
+        case (dir, scopes) =>
+          s"${dir.getAbsolutePath}:\n\t${scopes.mkString("\n\t")}"
       }
+      Some(s"Overlapping output directories:${dupStrs.mkString}")
     }
-  private[this] def overlappingTargets(targets: Seq[(ProjectRef, File)]): Map[File, Seq[ProjectRef]] =
-    targets.groupBy(_._2).filter(_._2.size > 1).mapValues(_.map(_._1))
+  }
+  private[this] def overlappingTargets(
+      targets: Seq[(ProjectRef, File)]
+  ): Map[File, Seq[ProjectRef]] =
+    targets.groupBy(_._2).filter(_._2.size > 1).mapValues(_.map(_._1)).toMap
 
-  private[this] def allTargets(data: Settings[Scope]): Seq[(ProjectRef, File)] =
-    {
-      import ScopeFilter._
-      val allProjects = ScopeFilter(Make.inAnyProject)
-      val targetAndRef = Def.setting { (Keys.thisProjectRef.value, Keys.target.value) }
-      new SettingKeyAll(Def.optional(targetAndRef)(idFun)).all(allProjects).evaluate(data).flatMap(x => x)
-    }
+  private[this] def allTargets(data: Settings[Scope]): Seq[(ProjectRef, File)] = {
+    import ScopeFilter._
+    val allProjects = ScopeFilter(Make.inAnyProject)
+    val targetAndRef = Def.setting { (Keys.thisProjectRef.value, Keys.target.value) }
+    new SettingKeyAll(Def.optional(targetAndRef)(idFun))
+      .all(allProjects)
+      .evaluate(data)
+      .flatMap(x => x)
+  }
 
   def equal(a: ScopedKey[_], b: ScopedKey[_], mask: ScopeMask): Boolean =
     a.key == b.key && Scope.equal(a.scope, b.scope, mask)
@@ -456,10 +602,7 @@ object Project extends ProjectExtra {
   def fillTaskAxis(scoped: ScopedKey[_]): ScopedKey[_] =
     ScopedKey(Scope.fillTaskAxis(scoped.scope, scoped.key), scoped.key)
 
-  def mapScope(f: Scope => Scope) = new (ScopedKey ~> ScopedKey) {
-    def apply[T](key: ScopedKey[T]) =
-      ScopedKey(f(key.scope), key.key)
-  }
+  def mapScope(f: Scope => Scope) = λ[ScopedKey ~> ScopedKey](k => ScopedKey(f(k.scope), k.key))
 
   def transform(g: Scope => Scope, ss: Seq[Def.Setting[_]]): Seq[Def.Setting[_]] = {
     val f = mapScope(g)
@@ -473,109 +616,193 @@ object Project extends ProjectExtra {
   def delegates(structure: BuildStructure, scope: Scope, key: AttributeKey[_]): Seq[ScopedKey[_]] =
     structure.delegates(scope).map(d => ScopedKey(d, key))
 
-  def scopedKeyData(structure: BuildStructure, scope: Scope, key: AttributeKey[_]): Option[ScopedKeyData[_]] =
-    structure.data.get(scope, key) map { v => ScopedKeyData(ScopedKey(scope, key), v) }
-
-  def details(structure: BuildStructure, actual: Boolean, scope: Scope, key: AttributeKey[_])(implicit display: Show[ScopedKey[_]]): String =
-    {
-      val scoped = ScopedKey(scope, key)
-
-      val data = scopedKeyData(structure, scope, key) map { _.description } getOrElse { "No entry for key." }
-      val description = key.description match { case Some(desc) => "Description:\n\t" + desc + "\n"; case None => "" }
-
-      val definingScope = structure.data.definingScope(scope, key)
-      val providedBy = definingScope match {
-        case Some(sc) => "Provided by:\n\t" + Scope.display(sc, key.label) + "\n"
-        case None     => ""
-      }
-      val definingScoped = definingScope match { case Some(sc) => ScopedKey(sc, key); case None => scoped }
-      val comp = Def.compiled(structure.settings, actual)(structure.delegates, structure.scopeLocal, display)
-      val definedAt = comp get definingScoped map { c => Def.definedAtString(c.settings).capitalize } getOrElse ""
-
-      val cMap = Def.flattenLocals(comp)
-      val related = cMap.keys.filter(k => k.key == key && k.scope != scope)
-      def derivedDependencies(c: ScopedKey[_]): List[ScopedKey[_]] =
-        comp.get(c).map(_.settings.flatMap(s => if (s.isDerived) s.dependencies else Nil)).toList.flatten
-
-      val depends = cMap.get(scoped) match { case Some(c) => c.dependencies.toSet; case None => Set.empty }
-      val derivedDepends: Set[ScopedKey[_]] = derivedDependencies(definingScoped).toSet
-
-      val reverse = reverseDependencies(cMap, scoped)
-      val derivedReverse = reverse.filter(r => derivedDependencies(r).contains(definingScoped)).toSet
-
-      def printDepScopes(baseLabel: String, derivedLabel: String, scopes: Iterable[ScopedKey[_]], derived: Set[ScopedKey[_]]): String =
-        {
-          val label = s"$baseLabel${if (derived.isEmpty) "" else s" (D=$derivedLabel)"}"
-          val prefix: ScopedKey[_] => String = if (derived.isEmpty) const("") else sk => if (derived(sk)) "D " else "  "
-          printScopes(label, scopes, prefix = prefix)
-        }
-
-      def printScopes(label: String, scopes: Iterable[ScopedKey[_]], max: Int = Int.MaxValue, prefix: ScopedKey[_] => String = const("")) =
-        if (scopes.isEmpty) ""
-        else {
-          val (limited, more) = if (scopes.size <= max) (scopes, "\n") else (scopes.take(max), "\n...\n")
-          limited.map(sk => prefix(sk) + display(sk)).mkString(label + ":\n\t", "\n\t", more)
-        }
-
-      data + "\n" +
-        description +
-        providedBy +
-        definedAt +
-        printDepScopes("Dependencies", "derived from", depends, derivedDepends) +
-        printDepScopes("Reverse dependencies", "derives", reverse, derivedReverse) +
-        printScopes("Delegates", delegates(structure, scope, key)) +
-        printScopes("Related", related, 10)
+  def scopedKeyData(
+      structure: BuildStructure,
+      scope: Scope,
+      key: AttributeKey[_]
+  ): Option[ScopedKeyData[_]] =
+    structure.data.get(scope, key) map { v =>
+      ScopedKeyData(ScopedKey(scope, key), v)
     }
-  def settingGraph(structure: BuildStructure, basedir: File, scoped: ScopedKey[_])(implicit display: Show[ScopedKey[_]]): SettingGraph =
+
+  def details(structure: BuildStructure, actual: Boolean, scope: Scope, key: AttributeKey[_])(
+      implicit display: Show[ScopedKey[_]]
+  ): String = {
+    val scoped = ScopedKey(scope, key)
+
+    val data = scopedKeyData(structure, scope, key) map { _.description } getOrElse {
+      "No entry for key."
+    }
+    val description = key.description match {
+      case Some(desc) => "Description:\n\t" + desc + "\n"; case None => ""
+    }
+
+    val definingScope = structure.data.definingScope(scope, key)
+    val providedBy = definingScope match {
+      case Some(sc) => "Provided by:\n\t" + Scope.display(sc, key.label) + "\n"
+      case None     => ""
+    }
+    val definingScoped = definingScope match {
+      case Some(sc) => ScopedKey(sc, key); case None => scoped
+    }
+    val comp =
+      Def.compiled(structure.settings, actual)(structure.delegates, structure.scopeLocal, display)
+    val definedAt = comp get definingScoped map { c =>
+      Def.definedAtString(c.settings).capitalize
+    } getOrElse ""
+
+    val cMap = Def.flattenLocals(comp)
+    val related = cMap.keys.filter(k => k.key == key && k.scope != scope)
+    def derivedDependencies(c: ScopedKey[_]): List[ScopedKey[_]] =
+      comp
+        .get(c)
+        .map(_.settings.flatMap(s => if (s.isDerived) s.dependencies else Nil))
+        .toList
+        .flatten
+
+    val depends = cMap.get(scoped) match {
+      case Some(c) => c.dependencies.toSet; case None => Set.empty
+    }
+    val derivedDepends: Set[ScopedKey[_]] = derivedDependencies(definingScoped).toSet
+
+    val reverse = reverseDependencies(cMap, scoped)
+    val derivedReverse = reverse.filter(r => derivedDependencies(r).contains(definingScoped)).toSet
+
+    def printDepScopes(
+        baseLabel: String,
+        derivedLabel: String,
+        scopes: Iterable[ScopedKey[_]],
+        derived: Set[ScopedKey[_]]
+    ): String = {
+      val label = s"$baseLabel${if (derived.isEmpty) "" else s" (D=$derivedLabel)"}"
+      val prefix: ScopedKey[_] => String =
+        if (derived.isEmpty) const("") else sk => if (derived(sk)) "D " else "  "
+      printScopes(label, scopes, prefix = prefix)
+    }
+
+    def printScopes(
+        label: String,
+        scopes: Iterable[ScopedKey[_]],
+        max: Int = Int.MaxValue,
+        prefix: ScopedKey[_] => String = const("")
+    ) =
+      if (scopes.isEmpty) ""
+      else {
+        val (limited, more) =
+          if (scopes.size <= max) (scopes, "\n") else (scopes.take(max), "\n...\n")
+        limited.map(sk => prefix(sk) + display.show(sk)).mkString(label + ":\n\t", "\n\t", more)
+      }
+
+    data + "\n" +
+      description +
+      providedBy +
+      definedAt +
+      printDepScopes("Dependencies", "derived from", depends, derivedDepends) +
+      printDepScopes("Reverse dependencies", "derives", reverse, derivedReverse) +
+      printScopes("Delegates", delegates(structure, scope, key)) +
+      printScopes("Related", related, 10)
+  }
+  def settingGraph(structure: BuildStructure, basedir: File, scoped: ScopedKey[_])(
+      implicit display: Show[ScopedKey[_]]
+  ): SettingGraph =
     SettingGraph(structure, basedir, scoped, 0)
-  def graphSettings(structure: BuildStructure, basedir: File)(implicit display: Show[ScopedKey[_]]): Unit = {
-    def graph(actual: Boolean, name: String) = graphSettings(structure, actual, name, new File(basedir, name + ".dot"))
+  def graphSettings(structure: BuildStructure, basedir: File)(
+      implicit display: Show[ScopedKey[_]]
+  ): Unit = {
+    def graph(actual: Boolean, name: String) =
+      graphSettings(structure, actual, name, new File(basedir, name + ".dot"))
     graph(true, "actual_dependencies")
     graph(false, "declared_dependencies")
   }
-  def graphSettings(structure: BuildStructure, actual: Boolean, graphName: String, file: File)(implicit display: Show[ScopedKey[_]]): Unit = {
+  def graphSettings(structure: BuildStructure, actual: Boolean, graphName: String, file: File)(
+      implicit display: Show[ScopedKey[_]]
+  ): Unit = {
     val rel = relation(structure, actual)
-    val keyToString = display.apply _
+    val keyToString = display.show _
     DotGraph.generateGraph(file, graphName, rel, keyToString, keyToString)
   }
-  def relation(structure: BuildStructure, actual: Boolean)(implicit display: Show[ScopedKey[_]]): Relation[ScopedKey[_], ScopedKey[_]] =
+  def relation(structure: BuildStructure, actual: Boolean)(
+      implicit display: Show[ScopedKey[_]]
+  ): Relation[ScopedKey[_], ScopedKey[_]] =
     relation(structure.settings, actual)(structure.delegates, structure.scopeLocal, display)
 
-  private[sbt] def relation(settings: Seq[Def.Setting[_]], actual: Boolean)(implicit delegates: Scope => Seq[Scope], scopeLocal: Def.ScopeLocal, display: Show[ScopedKey[_]]): Relation[ScopedKey[_], ScopedKey[_]] =
-    {
-      type Rel = Relation[ScopedKey[_], ScopedKey[_]]
-      val cMap = Def.flattenLocals(Def.compiled(settings, actual))
-      ((Relation.empty: Rel) /: cMap) {
-        case (r, (key, value)) =>
-          r + (key, value.dependencies)
-      }
-    }
+  private[sbt] def relation(settings: Seq[Def.Setting[_]], actual: Boolean)(
+      implicit delegates: Scope => Seq[Scope],
+      scopeLocal: Def.ScopeLocal,
+      display: Show[ScopedKey[_]]
+  ): Relation[ScopedKey[_], ScopedKey[_]] = {
+    val cMap = Def.flattenLocals(Def.compiled(settings, actual))
+    val emptyRelation = Relation.empty[ScopedKey[_], ScopedKey[_]]
+    cMap.foldLeft(emptyRelation) { case (r, (key, value)) => r + (key, value.dependencies) }
+  }
 
-  def showDefinitions(key: AttributeKey[_], defs: Seq[Scope])(implicit display: Show[ScopedKey[_]]): String =
+  def showDefinitions(key: AttributeKey[_], defs: Seq[Scope])(
+      implicit display: Show[ScopedKey[_]]
+  ): String =
     showKeys(defs.map(scope => ScopedKey(scope, key)))
+
   def showUses(defs: Seq[ScopedKey[_]])(implicit display: Show[ScopedKey[_]]): String =
     showKeys(defs)
-  private[this] def showKeys(s: Seq[ScopedKey[_]])(implicit display: Show[ScopedKey[_]]): String =
-    s.map(display.apply).sorted.mkString("\n\t", "\n\t", "\n\n")
 
-  def definitions(structure: BuildStructure, actual: Boolean, key: AttributeKey[_])(implicit display: Show[ScopedKey[_]]): Seq[Scope] =
-    relation(structure, actual)(display)._1s.toSeq flatMap { sk => if (sk.key == key) sk.scope :: Nil else Nil }
-  def usedBy(structure: BuildStructure, actual: Boolean, key: AttributeKey[_])(implicit display: Show[ScopedKey[_]]): Seq[ScopedKey[_]] =
-    relation(structure, actual)(display).all.toSeq flatMap { case (a, b) => if (b.key == key) List[ScopedKey[_]](a) else Nil }
-  def reverseDependencies(cMap: Map[ScopedKey[_], Flattened], scoped: ScopedKey[_]): Iterable[ScopedKey[_]] =
+  private[this] def showKeys(s: Seq[ScopedKey[_]])(implicit display: Show[ScopedKey[_]]): String =
+    s.map(display.show).sorted.mkString("\n\t", "\n\t", "\n\n")
+
+  def definitions(structure: BuildStructure, actual: Boolean, key: AttributeKey[_])(
+      implicit display: Show[ScopedKey[_]]
+  ): Seq[Scope] =
+    relation(structure, actual)(display)._1s.toSeq flatMap { sk =>
+      if (sk.key == key) sk.scope :: Nil else Nil
+    }
+  def usedBy(structure: BuildStructure, actual: Boolean, key: AttributeKey[_])(
+      implicit display: Show[ScopedKey[_]]
+  ): Seq[ScopedKey[_]] =
+    relation(structure, actual)(display).all.toSeq flatMap {
+      case (a, b) => if (b.key == key) List[ScopedKey[_]](a) else Nil
+    }
+  def reverseDependencies(
+      cMap: Map[ScopedKey[_], Flattened],
+      scoped: ScopedKey[_]
+  ): Iterable[ScopedKey[_]] =
     for ((key, compiled) <- cMap; dep <- compiled.dependencies if dep == scoped) yield key
 
-  //@deprecated("Use SettingCompletions.setAll when available.", "0.13.0")
   def setAll(extracted: Extracted, settings: Seq[Def.Setting[_]]): SessionSettings =
     SettingCompletions.setAll(extracted, settings).session
 
-  val ExtraBuilds = AttributeKey[List[URI]]("extra-builds", "Extra build URIs to load in addition to the ones defined by the project.")
+  val ExtraBuilds = AttributeKey[List[URI]](
+    "extra-builds",
+    "Extra build URIs to load in addition to the ones defined by the project."
+  )
   def extraBuilds(s: State): List[URI] = getOrNil(s, ExtraBuilds)
   def getOrNil[T](s: State, key: AttributeKey[List[T]]): List[T] = s get key getOrElse Nil
   def setExtraBuilds(s: State, extra: List[URI]): State = s.put(ExtraBuilds, extra)
-  def addExtraBuilds(s: State, extra: List[URI]): State = setExtraBuilds(s, extra ::: extraBuilds(s))
-  def removeExtraBuilds(s: State, remove: List[URI]): State = updateExtraBuilds(s, _.filterNot(remove.toSet))
-  def updateExtraBuilds(s: State, f: List[URI] => List[URI]): State = setExtraBuilds(s, f(extraBuilds(s)))
+  def addExtraBuilds(s: State, extra: List[URI]): State =
+    setExtraBuilds(s, extra ::: extraBuilds(s))
+  def removeExtraBuilds(s: State, remove: List[URI]): State =
+    updateExtraBuilds(s, _.filterNot(remove.toSet))
+  def updateExtraBuilds(s: State, f: List[URI] => List[URI]): State =
+    setExtraBuilds(s, f(extraBuilds(s)))
+
+  // used by Coursier integration
+  private[sbt] def transitiveInterDependencies(
+      state: State,
+      projectRef: ProjectRef
+  ): Seq[ProjectRef] = {
+    def dependencies(map: Map[ProjectRef, Seq[ProjectRef]], id: ProjectRef): Set[ProjectRef] = {
+      def helper(map: Map[ProjectRef, Seq[ProjectRef]], acc: Set[ProjectRef]): Set[ProjectRef] =
+        if (acc.exists(map.contains)) {
+          val (kept, rem) = map.partition { case (k, _) => acc(k) }
+          helper(rem, acc ++ kept.valuesIterator.flatten)
+        } else
+          acc
+      helper(map - id, map.getOrElse(id, Nil).toSet)
+    }
+    val allProjectsDeps: Map[ProjectRef, Seq[ProjectRef]] =
+      (for {
+        (p, ref) <- Project.structure(state).allProjectPairs
+      } yield ref -> p.dependencies.map(_.project)).toMap
+    val deps = dependencies(allProjectsDeps.toMap, projectRef)
+    Project.structure(state).allProjectRefs.filter(p => deps(p))
+  }
 
   object LoadAction extends Enumeration {
     val Return, Current, Plugins = Value
@@ -585,110 +812,183 @@ object Project extends ProjectExtra {
 
   val loadActionParser = token(Space ~> ("plugins" ^^^ Plugins | "return" ^^^ Return)) ?? Current
 
-  val ProjectReturn = AttributeKey[List[File]]("project-return", "Maintains a stack of builds visited using reload.")
+  val ProjectReturn =
+    AttributeKey[List[File]]("project-return", "Maintains a stack of builds visited using reload.")
   def projectReturn(s: State): List[File] = getOrNil(s, ProjectReturn)
   def inPluginProject(s: State): Boolean = projectReturn(s).length > 1
-  def setProjectReturn(s: State, pr: List[File]): State = s.copy(attributes = s.attributes.put(ProjectReturn, pr))
-  def loadAction(s: State, action: LoadAction.Value) = action match {
+  def setProjectReturn(s: State, pr: List[File]): State =
+    s.copy(attributes = s.attributes.put(ProjectReturn, pr))
+
+  def loadAction(s: State, action: LoadAction.Value): (State, File) = action match {
     case Return =>
       projectReturn(s) match {
-        case current :: returnTo :: rest => (setProjectReturn(s, returnTo :: rest), returnTo)
-        case _                           => sys.error("Not currently in a plugin definition")
+        case _ /* current */ :: returnTo :: rest =>
+          (setProjectReturn(s, returnTo :: rest), returnTo)
+        case _ => sys.error("Not currently in a plugin definition")
       }
+
     case Current =>
       val base = s.configuration.baseDirectory
-      projectReturn(s) match { case Nil => (setProjectReturn(s, base :: Nil), base); case x :: xs => (s, x) }
+      projectReturn(s) match {
+        case Nil => (setProjectReturn(s, base :: Nil), base); case x :: _ => (s, x)
+      }
+
     case Plugins =>
-      val (newBase, oldStack) = if (Project.isProjectLoaded(s))
-        (Project.extract(s).currentUnit.unit.plugins.base, projectReturn(s))
-      else // support changing to the definition project if it fails to load
-        (BuildPaths.projectStandard(s.baseDir), s.baseDir :: Nil)
+      val (newBase, oldStack) =
+        if (Project.isProjectLoaded(s))
+          (Project.extract(s).currentUnit.unit.plugins.base, projectReturn(s))
+        else // support changing to the definition project if it fails to load
+          (BuildPaths.projectStandard(s.baseDir), s.baseDir :: Nil)
       val newS = setProjectReturn(s, newBase :: oldStack)
       (newS, newBase)
   }
 
-  def runTask[T](taskKey: ScopedKey[Task[T]], state: State, checkCycles: Boolean = false): Option[(State, Result[T])] =
-    {
-      val extracted = Project.extract(state)
-      val ch = EvaluateTask.cancelStrategy(extracted, extracted.structure, state)
-      val p = EvaluateTask.executeProgress(extracted, extracted.structure, state)
-      val r = EvaluateTask.restrictions(state)
-      val fgc = EvaluateTask.forcegc(extracted, extracted.structure)
-      val mfi = EvaluateTask.minForcegcInterval(extracted, extracted.structure)
-      runTask(taskKey, state, EvaluateTaskConfig(r, checkCycles, p, ch, fgc, mfi))
-    }
-  def runTask[T](taskKey: ScopedKey[Task[T]], state: State, config: EvaluateTaskConfig): Option[(State, Result[T])] = {
+  def runTask[T](
+      taskKey: ScopedKey[Task[T]],
+      state: State,
+      checkCycles: Boolean = false
+  ): Option[(State, Result[T])] = {
+    val extracted = Project.extract(state)
+    val ch = EvaluateTask.cancelStrategy(extracted, extracted.structure, state)
+    val p = EvaluateTask.executeProgress(extracted, extracted.structure, state)
+    val r = EvaluateTask.restrictions(state)
+    val fgc = EvaluateTask.forcegc(extracted, extracted.structure)
+    val mfi = EvaluateTask.minForcegcInterval(extracted, extracted.structure)
+    runTask(taskKey, state, EvaluateTaskConfig(r, checkCycles, p, ch, fgc, mfi))
+  }
+
+  def runTask[T](
+      taskKey: ScopedKey[Task[T]],
+      state: State,
+      config: EvaluateTaskConfig
+  ): Option[(State, Result[T])] = {
     val extracted = Project.extract(state)
     EvaluateTask(extracted.structure, taskKey, state, extracted.currentRef, config)
   }
 
-  implicit def projectToRef(p: Project): ProjectReference = LocalProject(p.id)
+  def projectToRef(p: Project): ProjectReference = LocalProject(p.id)
+
+  implicit def projectToLocalProject(p: Project): LocalProject = LocalProject(p.id)
 
   final class RichTaskSessionVar[S](i: Def.Initialize[Task[S]]) {
     import SessionVar.{ persistAndSet, resolveContext, set, transform => tx }
 
     def updateState(f: (State, S) => State): Def.Initialize[Task[S]] = i(t => tx(t, f))
-    def storeAs(key: TaskKey[S])(implicit f: sbinary.Format[S]): Def.Initialize[Task[S]] = (Keys.resolvedScoped, i) { (scoped, task) =>
-      tx(task, (state, value) => persistAndSet(resolveContext(key, scoped.scope, state), state, value)(f))
+
+    def storeAs(key: TaskKey[S])(implicit f: JsonFormat[S]): Def.Initialize[Task[S]] = {
+      Keys.resolvedScoped.zipWith(i) { (scoped, task) =>
+        tx(
+          task,
+          (state, value) => persistAndSet(resolveContext(key, scoped.scope, state), state, value)(f)
+        )
+      }
+    }
+
+    def keepAs(key: TaskKey[S]): Def.Initialize[Task[S]] = {
+      i.zipWith(Keys.resolvedScoped) { (t, scoped) =>
+        tx(t, (state, value) => set(resolveContext(key, scoped.scope, state), state, value))
+      }
     }
-    def keepAs(key: TaskKey[S]): Def.Initialize[Task[S]] =
-      (i, Keys.resolvedScoped)((t, scoped) => tx(t, (state, value) => set(resolveContext(key, scoped.scope, state), state, value)))
   }
 
-  import reflect.macros._
+  /** implicitly injected to tasks that return PromiseWrap.
+   */
+  final class RichTaskPromise[A](i: Def.Initialize[Task[PromiseWrap[A]]]) {
+    import scala.concurrent.Await
+    import scala.concurrent.duration._
 
-  def projectMacroImpl(c: blackbox.Context): c.Expr[Project] =
-    {
-      import c.universe._
-      val enclosingValName = std.KeyMacro.definingValName(c, methodName => s"""$methodName must be directly assigned to a val, such as `val x = $methodName`. Alternatively, you can use `sbt.Project.apply`""")
-      val name = c.Expr[String](Literal(Constant(enclosingValName)))
-      reify { Project(name.splice, new File(name.splice)) }
-    }
+    def await: Def.Initialize[Task[A]] = await(Duration.Inf)
+
+    def await(atMost: Duration): Def.Initialize[Task[A]] =
+      (Def
+        .task {
+          val p = i.value
+          var result: Option[A] = None
+          if (atMost == Duration.Inf) {
+            while (result.isEmpty) {
+              try {
+                result = Some(Await.result(p.underlying.future, Duration("1s")))
+                Thread.sleep(10)
+              } catch {
+                case _: TimeoutException => ()
+              }
+            }
+          } else {
+            result = Some(Await.result(p.underlying.future, atMost))
+          }
+          result.get
+        })
+        .tag(Tags.Sentinel)
+  }
+
+  import scala.reflect.macros._
+
+  def projectMacroImpl(c: blackbox.Context): c.Expr[Project] = {
+    import c.universe._
+    val enclosingValName = std.KeyMacro.definingValName(
+      c,
+      methodName =>
+        s"""$methodName must be directly assigned to a val, such as `val x = $methodName`. Alternatively, you can use `sbt.Project.apply`"""
+    )
+    val name = c.Expr[String](Literal(Constant(enclosingValName)))
+    reify { Project(name.splice, new File(name.splice)) }
+  }
 }
 
 private[sbt] trait GeneratedRootProject
 
-trait ProjectExtra0 {
-   implicit def wrapProjectReferenceSeqEval[T](rs: => Seq[T])(implicit ev: T => ProjectReference): Seq[Eval[ProjectReference]] =
-    rs map { r => Eval.later(r: ProjectReference) }
-}
-
-trait ProjectExtra extends ProjectExtra0 {
-  implicit def classpathDependencyEval[T](p: => T)(implicit ev: T => ClasspathDep[ProjectReference]): Eval[ClasspathDep[ProjectReference]] =
-    Eval.later(p: ClasspathDep[ProjectReference])
-  implicit def wrapProjectReferenceEval[T](ref: => T)(implicit ev: T => ProjectReference): Eval[ProjectReference] =
-    Eval.later(ref: ProjectReference)
-
-  implicit def wrapSettingDefinitionEval[T](d: => T)(implicit ev: T => Def.SettingsDefinition): Eval[Def.SettingsDefinition] = Eval.later(d)
-  implicit def wrapSettingSeqEval(ss: => Seq[Setting[_]]): Eval[Def.SettingsDefinition] = Eval.later(new Def.SettingList(ss))
-
-  implicit def configDependencyConstructor[T](p: T)(implicit ev: T => ProjectReference): Constructor = new Constructor(p)
-  implicit def classpathDependency[T](p: T)(implicit ev: T => ProjectReference): ClasspathDep[ProjectReference] = new ClasspathDependency(p, None)
+trait ProjectExtra {
+  implicit def configDependencyConstructor[T](
+      p: T
+  )(implicit ev: T => ProjectReference): Constructor =
+    new Constructor(p)
 
+  implicit def classpathDependency[T](
+      p: T
+  )(implicit ev: T => ProjectReference): ClasspathDependency = ClasspathDependency(p, None)
 
   // These used to be in Project so that they didn't need to get imported (due to Initialize being nested in Project).
   // Moving Initialize and other settings types to Def and decoupling Project, Def, and Structure means these go here for now
-  implicit def richInitializeTask[T](init: Initialize[Task[T]]): Scoped.RichInitializeTask[T] = new Scoped.RichInitializeTask(init)
-  implicit def richInitializeInputTask[T](init: Initialize[InputTask[T]]): Scoped.RichInitializeInputTask[T] = new Scoped.RichInitializeInputTask(init)
-  implicit def richInitialize[T](i: Initialize[T]): Scoped.RichInitialize[T] = new Scoped.RichInitialize[T](i)
+  implicit def richInitializeTask[T](init: Initialize[Task[T]]): Scoped.RichInitializeTask[T] =
+    new Scoped.RichInitializeTask(init)
 
-  implicit def richTaskSessionVar[T](init: Initialize[Task[T]]): Project.RichTaskSessionVar[T] = new Project.RichTaskSessionVar(init)
+  implicit def richInitializeInputTask[T](
+      init: Initialize[InputTask[T]]
+  ): Scoped.RichInitializeInputTask[T] =
+    new Scoped.RichInitializeInputTask(init)
+
+  implicit def richInitialize[T](i: Initialize[T]): Scoped.RichInitialize[T] =
+    new Scoped.RichInitialize[T](i)
+
+  implicit def richTaskSessionVar[T](init: Initialize[Task[T]]): Project.RichTaskSessionVar[T] =
+    new Project.RichTaskSessionVar(init)
+
+  implicit def sbtRichTaskPromise[A](
+      i: Initialize[Task[PromiseWrap[A]]]
+  ): Project.RichTaskPromise[A] =
+    new Project.RichTaskPromise(i)
 
   def inThisBuild(ss: Seq[Setting[_]]): Seq[Setting[_]] =
     inScope(ThisScope.copy(project = Select(ThisBuild)))(ss)
+
   def inConfig(conf: Configuration)(ss: Seq[Setting[_]]): Seq[Setting[_]] =
     inScope(ThisScope.copy(config = Select(conf)))((configuration :== conf) +: ss)
+
   def inTask(t: Scoped)(ss: Seq[Setting[_]]): Seq[Setting[_]] =
     inScope(ThisScope.copy(task = Select(t.key)))(ss)
+
   def inScope(scope: Scope)(ss: Seq[Setting[_]]): Seq[Setting[_]] =
     Project.transform(Scope.replaceThis(scope), ss)
 
   private[sbt] def inThisBuild[T](i: Initialize[T]): Initialize[T] =
     inScope(ThisScope.copy(project = Select(ThisBuild)), i)
+
   private[sbt] def inConfig[T](conf: Configuration, i: Initialize[T]): Initialize[T] =
     inScope(ThisScope.copy(config = Select(conf)), i)
+
   private[sbt] def inTask[T](t: Scoped, i: Initialize[T]): Initialize[T] =
     inScope(ThisScope.copy(task = Select(t.key)), i)
+
   private[sbt] def inScope[T](scope: Scope, i: Initialize[T]): Initialize[T] =
     i mapReferenced Project.mapScope(Scope.replaceThis(scope))
 
diff --git a/main/src/main/scala/sbt/Resolvers.scala b/main/src/main/scala/sbt/Resolvers.scala
index 806e160d0..d28d8a026 100644
--- a/main/src/main/scala/sbt/Resolvers.scala
+++ b/main/src/main/scala/sbt/Resolvers.scala
@@ -1,5 +1,8 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Sanjin Sehic
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
 
 package sbt
@@ -17,6 +20,7 @@ import java.util.Locale
 
 import scala.sys.process.Process
 import scala.util.control.NonFatal
+import sbt.internal.util.Util
 
 object Resolvers {
   type Resolver = BuildLoader.Resolver
@@ -26,15 +30,18 @@ object Resolvers {
     val from = new File(uri)
     val to = uniqueSubdirectoryFor(uri, in = info.staging)
 
-    if (from.isDirectory) Some { () => if (from.canWrite) from else creates(to) { IO.copyDirectory(from, to) } }
-    else None
+    if (from.isDirectory) Some { () =>
+      if (from.canWrite) from else creates(to) { IO.copyDirectory(from, to) }
+    } else None
   }
 
   val remote: Resolver = (info: ResolveInfo) => {
     val url = info.uri.toURL
     val to = uniqueSubdirectoryFor(info.uri, in = info.staging)
 
-    Some { () => creates(to) { IO.unzipURL(url, to) } }
+    Some { () =>
+      creates(to) { IO.unzipURL(url, to); () }
+    }
   }
 
   val subversion: Resolver = (info: ResolveInfo) => {
@@ -47,18 +54,16 @@ object Resolvers {
 
     if (uri.hasFragment) {
       val revision = uri.getFragment
-      Some {
-        () =>
-          creates(localCopy) {
-            run("svn", "checkout", "-q", "-r", revision, from, to)
-          }
+      Some { () =>
+        creates(localCopy) {
+          run("svn", "checkout", "-q", "-r", revision, from, to)
+        }
       }
     } else
-      Some {
-        () =>
-          creates(localCopy) {
-            run("svn", "checkout", "-q", from, to)
-          }
+      Some { () =>
+        creates(localCopy) {
+          run("svn", "checkout", "-q", from, to)
+        }
       }
   }
 
@@ -87,11 +92,12 @@ object Resolvers {
           run(Some(localCopy), "git", "checkout", "-q", branch)
         }
       }
-    } else Some { () =>
-      creates(localCopy) {
-        run("git", "clone", "--depth", "1", from, localCopy.getAbsolutePath)
+    } else
+      Some { () =>
+        creates(localCopy) {
+          run("git", "clone", "--depth", "1", from, localCopy.getAbsolutePath)
+        }
       }
-    }
   }
 
   abstract class DistributedVCS {
@@ -108,32 +114,27 @@ object Resolvers {
 
       if (uri.hasFragment) {
         val branch = uri.getFragment
-        Some {
-          () =>
-            creates(localCopy) {
-              clone(from, to = localCopy)
-              checkout(branch, in = localCopy)
-            }
+        Some { () =>
+          creates(localCopy) {
+            clone(from, to = localCopy)
+            checkout(branch, in = localCopy)
+          }
+        }
+      } else
+        Some { () =>
+          creates(localCopy) { clone(from, to = localCopy) }
         }
-      } else Some { () => creates(localCopy) { clone(from, to = localCopy) } }
     }
 
     private def normalized(uri: URI) = uri.copy(scheme = scheme)
   }
 
-  private lazy val onWindows = {
-    val os = System.getenv("OSTYPE")
-    val isCygwin = (os != null) && os.toLowerCase(Locale.ENGLISH).contains("cygwin")
-    val isWindows = System.getProperty("os.name", "").toLowerCase(Locale.ENGLISH).contains("windows")
-    isWindows && !isCygwin
-  }
-
   def run(command: String*): Unit =
     run(None, command: _*)
 
   def run(cwd: Option[File], command: String*): Unit = {
     val result = Process(
-      if (onWindows) "cmd" +: "/c" +: command
+      if (Util.isNonCygwinWindows) "cmd" +: "/c" +: command
       else command,
       cwd
     ) !;
@@ -141,23 +142,24 @@ object Resolvers {
       sys.error("Nonzero exit code (" + result + "): " + command.mkString(" "))
   }
 
-  def creates(file: File)(f: => Unit) =
-    {
-      if (!file.exists)
-        try {
-          f
-        } catch {
-          case NonFatal(e) =>
-            IO.delete(file)
-            throw e
-        }
-      file
-    }
+  def creates(file: File)(f: => Unit) = {
+    if (!file.exists)
+      try {
+        f
+      } catch {
+        case NonFatal(e) =>
+          IO.delete(file)
+          throw e
+      }
+    file
+  }
 
   def uniqueSubdirectoryFor(uri: URI, in: File) = {
     in.mkdirs()
     val base = new File(in, Hash.halfHashString(uri.normalize.toASCIIString))
-    val last = shortName(uri) match { case Some(n) => normalizeDirectoryName(n); case None => "root" }
+    val last = shortName(uri) match {
+      case Some(n) => normalizeDirectoryName(n); case None => "root"
+    }
     new File(base, last)
   }
 
diff --git a/main/src/main/scala/sbt/RichURI.scala b/main/src/main/scala/sbt/RichURI.scala
index 46a1c3729..bf8954f9d 100644
--- a/main/src/main/scala/sbt/RichURI.scala
+++ b/main/src/main/scala/sbt/RichURI.scala
@@ -1,5 +1,8 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Sanjin Sehic
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
 
 package sbt
@@ -8,14 +11,21 @@ import java.net.URI
 
 /** Extends `URI` with additional convenience methods. */
 class RichURI(uri: URI) {
+
   /**
    * Provides a case-class-like `copy` method for URI.
    * Note that this method simply passes the individual components of this URI to the URI constructor
    * that accepts each component individually.  It is thus limited by the implementation restrictions of the relevant methods.
    */
-  def copy(scheme: String = uri.getScheme, userInfo: String = uri.getUserInfo,
-    host: String = uri.getHost, port: Int = uri.getPort, path: String = uri.getPath,
-    query: String = uri.getQuery, fragment: String = uri.getFragment) =
+  def copy(
+      scheme: String = uri.getScheme,
+      userInfo: String = uri.getUserInfo,
+      host: String = uri.getHost,
+      port: Int = uri.getPort,
+      path: String = uri.getPath,
+      query: String = uri.getQuery,
+      fragment: String = uri.getFragment
+  ) =
     new URI(scheme, userInfo, host, port, path, query, fragment)
 
   /** Returns `true` if the fragment of the URI is defined. */
@@ -36,19 +46,19 @@ class RichURI(uri: URI) {
    * If the URI has a fragment, the fragment is transferred to the wrapped URI.
    * If this URI does not have a marker scheme, it is returned unchanged.
    */
-  def withoutMarkerScheme =
-    {
-      if (hasMarkerScheme)
-        if (hasFragment)
-          new URI(uri.getRawSchemeSpecificPart + "#" + uri.getRawFragment)
-        else
-          new URI(uri.getRawSchemeSpecificPart)
+  def withoutMarkerScheme = {
+    if (hasMarkerScheme)
+      if (hasFragment)
+        new URI(uri.getRawSchemeSpecificPart + "#" + uri.getRawFragment)
       else
-        uri
-    }
+        new URI(uri.getRawSchemeSpecificPart)
+    else
+      uri
+  }
 }
 
 object RichURI {
+
   /** Provides additional convenience methods for `uri`. */
   implicit def fromURI(uri: URI): RichURI = new RichURI(uri)
 }
diff --git a/main/src/main/scala/sbt/ScopeFilter.scala b/main/src/main/scala/sbt/ScopeFilter.scala
index 706053ca2..f279afb9a 100644
--- a/main/src/main/scala/sbt/ScopeFilter.scala
+++ b/main/src/main/scala/sbt/ScopeFilter.scala
@@ -1,10 +1,15 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import sbt.internal.{ Load, LoadedBuildUnit }
 import sbt.internal.util.{ AttributeKey, Dag, Types }
-
-import sbt.librarymanagement.Configuration
-
+import sbt.librarymanagement.{ ConfigRef, Configuration }
 import Types.const
 import Def.Initialize
 import java.net.URI
@@ -16,6 +21,16 @@ object ScopeFilter {
   type ConfigurationFilter = AxisFilter[ConfigKey]
   type TaskFilter = AxisFilter[AttributeKey[_]]
 
+  /**
+   * Construct a Scope filter from a sequence of individual scopes.
+   */
+  def in(scopes: Seq[Scope]): ScopeFilter = {
+    val scopeSet = scopes.toSet
+    new ScopeFilter {
+      override private[ScopeFilter] def apply(data: Data): Scope => Boolean = scopeSet.contains
+    }
+  }
+
   /**
    * Constructs a Scope filter from filters for the individual axes.
    * If a project filter is not supplied, the enclosing project is selected.
@@ -23,31 +38,34 @@ object ScopeFilter {
    * If a task filter is not supplied, global is selected.
    * Generally, always specify the project axis.
    */
-  def apply(projects: ProjectFilter = inProjects(ThisProject), configurations: ConfigurationFilter = globalAxis, tasks: TaskFilter = globalAxis): ScopeFilter =
+  def apply(
+      projects: ProjectFilter = inProjects(ThisProject),
+      configurations: ConfigurationFilter = zeroAxis,
+      tasks: TaskFilter = zeroAxis
+  ): ScopeFilter =
     new ScopeFilter {
-      private[sbt] def apply(data: Data): Scope => Boolean =
-        {
-          val pf = projects(data)
-          val cf = configurations(data)
-          val tf = tasks(data)
-          s => pf(s.project) && cf(s.config) && tf(s.task)
-        }
+      private[sbt] def apply(data: Data): Scope => Boolean = {
+        val pf = projects(data)
+        val cf = configurations(data)
+        val tf = tasks(data)
+        s => pf(s.project) && cf(s.config) && tf(s.task)
+      }
     }
 
   def debug(delegate: ScopeFilter): ScopeFilter =
     new ScopeFilter {
-      private[sbt] def apply(data: Data): Scope => Boolean =
-        {
-          val d = delegate(data)
-          scope => {
-            val accept = d(scope)
-            println((if (accept) "ACCEPT " else "reject ") + scope)
-            accept
-          }
+      private[sbt] def apply(data: Data): Scope => Boolean = {
+        val d = delegate(data)
+        scope => {
+          val accept = d(scope)
+          println((if (accept) "ACCEPT " else "reject ") + scope)
+          accept
         }
+      }
     }
 
   final class SettingKeyAll[T] private[sbt] (i: Initialize[T]) {
+
     /**
      * Evaluates the initialization in all scopes selected by the filter.  These are dynamic dependencies, so
      * static inspections will not show them.
@@ -57,6 +75,7 @@ object ScopeFilter {
     }
   }
   final class TaskKeyAll[T] private[sbt] (i: Initialize[Task[T]]) {
+
     /**
      * Evaluates the task in all scopes selected by the filter.  These are dynamic dependencies, so
      * static inspections will not show them.
@@ -69,39 +88,75 @@ object ScopeFilter {
 
   private[sbt] val Make = new Make {}
   trait Make {
+
     /** Selects the Scopes used in `<key>.all(<ScopeFilter>)`.*/
     type ScopeFilter = Base[Scope]
 
-    /** Selects Scopes with a global task axis. */
-    def inGlobalTask: TaskFilter = globalAxis[AttributeKey[_]]
-    /** Selects Scopes with a global project axis. */
-    def inGlobalProject: ProjectFilter = globalAxis[Reference]
-    /** Selects Scopes with a global configuration axis. */
-    def inGlobalConfiguration: ConfigurationFilter = globalAxis[ConfigKey]
+    /** Selects Scopes with a Zero task axis. */
+    def inZeroTask: TaskFilter = zeroAxis[AttributeKey[_]]
 
-    /** Selects all scopes that apply to a single project.  Global and build-level scopes are excluded. */
-    def inAnyProject: ProjectFilter = selectAxis(const { case p: ProjectRef => true; case _ => false })
-    /** Accepts all values for the task axis except Global. */
+    @deprecated("Use inZeroTask", "1.0.0")
+    def inGlobalTask: TaskFilter = inZeroTask
+
+    /** Selects Scopes with a Zero project axis. */
+    def inZeroProject: ProjectFilter = zeroAxis[Reference]
+
+    @deprecated("Use inZeroProject", "1.0.0")
+    def inGlobalProject: ProjectFilter = inZeroProject
+
+    /** Selects Scopes with a Zero configuration axis. */
+    def inZeroConfiguration: ConfigurationFilter = zeroAxis[ConfigKey]
+
+    @deprecated("Use inZeroConfiguration", "1.0.0")
+    def inGlobalConfiguration: ConfigurationFilter = inZeroConfiguration
+
+    /** Selects all scopes that apply to a single project. Zero and build-level scopes are excluded. */
+    def inAnyProject: ProjectFilter =
+      selectAxis(const { case _: ProjectRef => true; case _ => false })
+
+    /** Accepts all values for the task axis except Zero. */
     def inAnyTask: TaskFilter = selectAny[AttributeKey[_]]
-    /** Accepts all values for the configuration axis except Global. */
+
+    /** Accepts all values for the configuration axis except Zero. */
     def inAnyConfiguration: ConfigurationFilter = selectAny[ConfigKey]
 
     /**
      * Selects Scopes that have a project axis that is aggregated by `ref`, transitively if `transitive` is true.
      * If `includeRoot` is true, Scopes with `ref` itself as the project axis value are also selected.
      */
-    def inAggregates(ref: ProjectReference, transitive: Boolean = true, includeRoot: Boolean = true): ProjectFilter =
-      byDeps(ref, transitive = transitive, includeRoot = includeRoot, aggregate = true, classpath = false)
+    def inAggregates(
+        ref: ProjectReference,
+        transitive: Boolean = true,
+        includeRoot: Boolean = true
+    ): ProjectFilter =
+      byDeps(
+        ref,
+        transitive = transitive,
+        includeRoot = includeRoot,
+        aggregate = true,
+        classpath = false
+      )
 
     /**
      * Selects Scopes that have a project axis that is a dependency of `ref`, transitively if `transitive` is true.
      * If `includeRoot` is true, Scopes with `ref` itself as the project axis value are also selected.
      */
-    def inDependencies(ref: ProjectReference, transitive: Boolean = true, includeRoot: Boolean = true): ProjectFilter =
-      byDeps(ref, transitive = transitive, includeRoot = includeRoot, aggregate = false, classpath = true)
+    def inDependencies(
+        ref: ProjectReference,
+        transitive: Boolean = true,
+        includeRoot: Boolean = true
+    ): ProjectFilter =
+      byDeps(
+        ref,
+        transitive = transitive,
+        includeRoot = includeRoot,
+        aggregate = false,
+        classpath = true
+      )
 
     /** Selects Scopes that have a project axis with one of the provided values.*/
-    def inProjects(projects: ProjectReference*): ProjectFilter = ScopeFilter.inProjects(projects: _*)
+    def inProjects(projects: ProjectReference*): ProjectFilter =
+      ScopeFilter.inProjects(projects: _*)
 
     /** Selects Scopes that have a task axis with one of the provided values.*/
     def inTasks(tasks: Scoped*): TaskFilter = {
@@ -115,6 +170,16 @@ object ScopeFilter {
       selectAxis[ConfigKey](const(c => cs(c.name)))
     }
 
+    def inConfigurationsByKeys(keys: ConfigKey*): ConfigurationFilter = {
+      val cs = keys.toSet
+      selectAxis[ConfigKey](const(cs))
+    }
+
+    def inConfigurationsByRefs(refs: ConfigRef*): ConfigurationFilter = {
+      val cs = refs.map(r => ConfigKey(r.name)).toSet
+      selectAxis[ConfigKey](const(cs))
+    }
+
     implicit def settingKeyAll[T](key: Initialize[T]): SettingKeyAll[T] = new SettingKeyAll[T](key)
     implicit def taskKeyAll[T](key: Initialize[Task[T]]): TaskKeyAll[T] = new TaskKeyAll[T](key)
   }
@@ -123,7 +188,11 @@ object ScopeFilter {
    * Information provided to Scope filters.  These provide project relationships,
    * project reference resolution, and the list of all static Scopes.
    */
-  private final class Data(val units: Map[URI, LoadedBuildUnit], val resolve: ProjectReference => ProjectRef, val allScopes: Set[Scope])
+  private final class Data(
+      val units: Map[URI, LoadedBuildUnit],
+      val resolve: ProjectReference => ProjectRef,
+      val allScopes: Set[Scope]
+  )
 
   /** Constructs a Data instance from the list of static scopes and the project relationships.*/
   private[this] val getData: Initialize[Data] =
@@ -136,20 +205,32 @@ object ScopeFilter {
         case None                     => build.root
       }
       val rootProject = Load.getRootProject(build.units)
-      val resolve: ProjectReference => ProjectRef = p => (p, thisRef) match {
-        case (ThisProject, Some(pref)) => pref
-        case _                         => Scope.resolveProjectRef(current, rootProject, p)
-      }
+      val resolve: ProjectReference => ProjectRef = p =>
+        (p, thisRef) match {
+          case (ThisProject, Some(pref)) => pref
+          case _                         => Scope.resolveProjectRef(current, rootProject, p)
+        }
       new Data(build.units, resolve, scopes)
     }
 
-  private[this] def getDependencies(structure: Map[URI, LoadedBuildUnit], classpath: Boolean, aggregate: Boolean): ProjectRef => Seq[ProjectRef] =
-    ref => Project.getProject(ref, structure).toList flatMap { p =>
-      (if (classpath) p.dependencies.map(_.project) else Nil) ++
-        (if (aggregate) p.aggregate else Nil)
-    }
+  private[this] def getDependencies(
+      structure: Map[URI, LoadedBuildUnit],
+      classpath: Boolean,
+      aggregate: Boolean
+  ): ProjectRef => Seq[ProjectRef] =
+    ref =>
+      Project.getProject(ref, structure).toList flatMap { p =>
+        (if (classpath) p.dependencies.map(_.project) else Nil) ++
+          (if (aggregate) p.aggregate else Nil)
+      }
 
-  private[this] def byDeps(ref: ProjectReference, transitive: Boolean, includeRoot: Boolean, aggregate: Boolean, classpath: Boolean): ProjectFilter =
+  private[this] def byDeps(
+      ref: ProjectReference,
+      transitive: Boolean,
+      includeRoot: Boolean,
+      aggregate: Boolean,
+      classpath: Boolean
+  ): ProjectFilter =
     inResolvedProjects { data =>
       val resolvedRef = data.resolve(ref)
       val direct = getDependencies(data.units, classpath = classpath, aggregate = aggregate)
@@ -168,23 +249,25 @@ object ScopeFilter {
   private[this] def inResolvedProjects(projects: Data => Seq[ProjectRef]): ProjectFilter =
     selectAxis(data => projects(data).toSet)
 
-  private[this] def globalAxis[T]: AxisFilter[T] = new AxisFilter[T] {
+  private[this] def zeroAxis[T]: AxisFilter[T] = new AxisFilter[T] {
     private[sbt] def apply(data: Data): ScopeAxis[T] => Boolean =
-      _ == Global
+      _ == Zero
   }
   private[this] def selectAny[T]: AxisFilter[T] = selectAxis(const(const(true)))
   private[this] def selectAxis[T](f: Data => T => Boolean): AxisFilter[T] = new AxisFilter[T] {
     private[sbt] def apply(data: Data): ScopeAxis[T] => Boolean = {
       val g = f(data)
-      s => s match {
-        case Select(t) => g(t)
-        case _         => false
-      }
+      s =>
+        s match {
+          case Select(t) => g(t)
+          case _         => false
+        }
     }
   }
 
   /** Base functionality for filters on values of type `In` that need access to build data.*/
   sealed abstract class Base[In] { self =>
+
     /** Implements this filter. */
     private[ScopeFilter] def apply(data: Data): In => Boolean
 
@@ -208,6 +291,7 @@ object ScopeFilter {
         s => a(s) || b(s)
       }
     }
+
     /** Constructs a filter that selects values that do not match this filter.*/
     def unary_- : Base[In] = new Base[In] {
       private[sbt] def apply(data: Data): In => Boolean = {
diff --git a/main/src/main/scala/sbt/ScopedKeyData.scala b/main/src/main/scala/sbt/ScopedKeyData.scala
index 0fcc0ebc8..f09a935a4 100644
--- a/main/src/main/scala/sbt/ScopedKeyData.scala
+++ b/main/src/main/scala/sbt/ScopedKeyData.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import Def.ScopedKey
@@ -8,8 +15,12 @@ final case class ScopedKeyData[A](scoped: ScopedKey[A], value: Any) {
   val scope = scoped.scope
   def typeName: String = fold(fmtMf("Task[%s]"), fmtMf("InputTask[%s]"), key.manifest.toString)
   def settingValue: Option[Any] = fold(const(None), const(None), Some(value))
-  def description: String = fold(fmtMf("Task: %s"), fmtMf("Input task: %s"),
-    "Setting: %s = %s" format (key.manifest.toString, value.toString))
+  def description: String =
+    fold(
+      fmtMf("Task: %s"),
+      fmtMf("Input task: %s"),
+      "Setting: %s = %s" format (key.manifest.toString, value.toString)
+    )
   def fold[T](targ: OptManifest[_] => T, itarg: OptManifest[_] => T, s: => T): T =
     key.manifest.runtimeClass match {
       case TaskClass      => targ(key.manifest.typeArguments.head)
diff --git a/main/src/main/scala/sbt/ScriptedPlugin.scala b/main/src/main/scala/sbt/ScriptedPlugin.scala
new file mode 100644
index 000000000..f4822c3fb
--- /dev/null
+++ b/main/src/main/scala/sbt/ScriptedPlugin.scala
@@ -0,0 +1,214 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.io.File
+import java.lang.reflect.Method
+
+import sbt.Def._
+import sbt.Keys._
+import sbt.nio.Keys._
+import sbt.Project._
+import sbt.ScopeFilter.Make._
+import sbt.SlashSyntax0._
+import sbt.internal.inc.ModuleUtilities
+import sbt.internal.inc.classpath.ClasspathUtil
+import sbt.internal.librarymanagement.cross.CrossVersionUtil
+import sbt.internal.util.complete.{ DefaultParsers, Parser }
+import sbt.io._
+import sbt.io.syntax._
+import sbt.librarymanagement._
+import sbt.librarymanagement.syntax._
+import sbt.nio.file.{ Glob, RecursiveGlob }
+import scala.util.Try
+
+object ScriptedPlugin extends AutoPlugin {
+
+  // Force Log4J to not use a thread context classloader otherwise it throws a CCE
+  sys.props(org.apache.logging.log4j.util.LoaderUtil.IGNORE_TCCL_PROPERTY) = "true"
+
+  object autoImport {
+    val ScriptedConf = Configurations.config("scripted-sbt") hide
+    val ScriptedLaunchConf = Configurations.config("scripted-sbt-launch") hide
+
+    val scriptedSbt = settingKey[String]("")
+    val sbtLauncher = taskKey[File]("")
+    val sbtTestDirectory = settingKey[File]("")
+    val scriptedBufferLog = settingKey[Boolean]("")
+    val scriptedClasspath = taskKey[PathFinder]("")
+    val scriptedTests = taskKey[AnyRef]("")
+    val scriptedBatchExecution =
+      settingKey[Boolean]("Enables or disables batch execution for scripted.")
+    val scriptedParallelInstances = settingKey[Int](
+      "Configures the number of scripted instances for parallel testing, only used in batch mode."
+    )
+    val scriptedRun = taskKey[Method]("")
+    val scriptedLaunchOpts =
+      settingKey[Seq[String]]("options to pass to jvm launching scripted tasks")
+    val scriptedDependencies = taskKey[Unit]("")
+    val scripted = inputKey[Unit]("")
+  }
+  import autoImport._
+
+  override lazy val globalSettings: Seq[Setting[_]] = Seq(
+    scriptedBufferLog := true,
+    scriptedLaunchOpts := Seq(),
+  )
+
+  override lazy val projectSettings: Seq[Setting[_]] = Seq(
+    ivyConfigurations ++= Seq(ScriptedConf, ScriptedLaunchConf),
+    scriptedSbt := (pluginCrossBuild / sbtVersion).value,
+    sbtLauncher := getJars(ScriptedLaunchConf).map(_.get.head).value,
+    sbtTestDirectory := sourceDirectory.value / "sbt-test",
+    libraryDependencies ++= (CrossVersion.partialVersion(scriptedSbt.value) match {
+      case Some((0, 13)) =>
+        Seq(
+          "org.scala-sbt" % "scripted-sbt" % scriptedSbt.value % ScriptedConf,
+          "org.scala-sbt" % "sbt-launch" % scriptedSbt.value % ScriptedLaunchConf
+        )
+      case Some((1, _)) =>
+        Seq(
+          "org.scala-sbt" %% "scripted-sbt" % scriptedSbt.value % ScriptedConf,
+          "org.scala-sbt" % "sbt-launch" % scriptedSbt.value % ScriptedLaunchConf
+        )
+      case Some((x, y)) => sys error s"Unknown sbt version ${scriptedSbt.value} ($x.$y)"
+      case None         => sys error s"Unknown sbt version ${scriptedSbt.value}"
+    }),
+    scriptedClasspath := getJars(ScriptedConf).value,
+    scriptedTests := scriptedTestsTask.value,
+    scriptedParallelInstances := 1,
+    scriptedBatchExecution := {
+      val binVersion = CrossVersionUtil.binarySbtVersion(scriptedSbt.value)
+      val versionParts =
+        binVersion.split("\\.").flatMap(p => Try(p.takeWhile(_.isDigit).toInt).toOption).take(2)
+      versionParts match {
+        case Array(major, minor) => major > 1 || (major == 1 && minor >= 4)
+        case _                   => false
+      }
+    },
+    scriptedRun := scriptedRunTask.value,
+    scriptedDependencies := {
+      def use[A](@deprecated("unused", "") x: A*): Unit = () // avoid unused warnings
+      val analysis = (Test / Keys.compile).value
+      val pub = publishLocal.all(ScopeFilter(projects = inDependencies(ThisProject))).value
+      use(analysis, pub)
+    },
+    scripted := scriptedTask.evaluated,
+    scripted / watchTriggers += Glob(sbtTestDirectory.value, RecursiveGlob)
+  )
+
+  private[sbt] def scriptedTestsTask: Initialize[Task[AnyRef]] =
+    Def.task {
+      val cp = scriptedClasspath.value.get.map(_.toPath)
+      val loader = ClasspathUtil.toLoader(cp, scalaInstance.value.loader)
+      try {
+        ModuleUtilities.getObject("sbt.scriptedtest.ScriptedTests", loader)
+      } catch {
+        case _: ClassNotFoundException =>
+          ModuleUtilities.getObject("sbt.test.ScriptedTests", loader)
+      }
+    }
+
+  private[sbt] def scriptedRunTask: Initialize[Task[Method]] = Def.taskDyn {
+    val fCls = classOf[File]
+    val bCls = classOf[Boolean]
+    val asCls = classOf[Array[String]]
+    val lfCls = classOf[java.util.List[File]]
+    val iCls = classOf[Int]
+
+    val clazz = scriptedTests.value.getClass
+    val method =
+      if (scriptedBatchExecution.value)
+        clazz.getMethod("runInParallel", fCls, bCls, asCls, fCls, asCls, lfCls, iCls)
+      else
+        clazz.getMethod("run", fCls, bCls, asCls, fCls, asCls, lfCls)
+
+    Def.task(method)
+  }
+
+  private[sbt] final case class ScriptedTestPage(page: Int, total: Int)
+
+  private[sbt] def scriptedParser(scriptedBase: File): Parser[Seq[String]] = {
+    import DefaultParsers._
+
+    val scriptedFiles
+        : NameFilter = ("test": NameFilter) | "test.script" | "pending" | "pending.script"
+    val pairs = (scriptedBase * AllPassFilter * AllPassFilter * scriptedFiles).get map {
+      (f: File) =>
+        val p = f.getParentFile
+        (p.getParentFile.getName, p.getName)
+    }
+    val pairMap = pairs.groupBy(_._1).mapValues(_.map(_._2).toSet)
+
+    val id = charClass(c => !c.isWhitespace && c != '/', "not whitespace and not '/'").+.string
+    val groupP = token(id.examples(pairMap.keySet.toSet)) <~ token('/')
+
+    // A parser for page definitions
+    val pageNumber = (NatBasic & not('0', "zero page number")).flatMap { i =>
+      if (i <= pairs.size) Parser.success(i)
+      else Parser.failure(s"$i exceeds the number of tests (${pairs.size})")
+    }
+    val pageP: Parser[ScriptedTestPage] = ("*" ~> pageNumber ~ ("of" ~> pageNumber)) flatMap {
+      case (page, total) if page <= total => success(ScriptedTestPage(page, total))
+      case (page, total)                  => failure(s"Page $page was greater than $total")
+    }
+
+    // Grabs the filenames from a given test group in the current page definition.
+    def pagedFilenames(group: String, page: ScriptedTestPage): Seq[String] = {
+      val files = pairMap.get(group).toSeq.flatten.sortBy(_.toLowerCase)
+      val pageSize = files.size / page.total
+      // The last page may loose some values, so we explicitly keep them
+      val dropped = files.drop(pageSize * (page.page - 1))
+      if (page.page == page.total) dropped
+      else dropped.take(pageSize)
+    }
+
+    def nameP(group: String) = {
+      token("*".id | id.examples(pairMap.getOrElse(group, Set.empty[String])))
+    }
+
+    val PagedIds: Parser[Seq[String]] =
+      for {
+        group <- groupP
+        page <- pageP
+        files = pagedFilenames(group, page)
+        // TODO -  Fail the parser if we don't have enough files for the given page size
+        //if !files.isEmpty
+      } yield files map (f => s"$group/$f")
+
+    val testID = (for (group <- groupP; name <- nameP(group)) yield (group, name))
+    val testIdAsGroup = matched(testID) map (test => Seq(test))
+
+    //(token(Space) ~> matched(testID)).*
+    (token(Space) ~> (PagedIds | testIdAsGroup)).* map (_.flatten)
+  }
+
+  private[sbt] def scriptedTask: Initialize[InputTask[Unit]] = Def.inputTask {
+    val args = scriptedParser(sbtTestDirectory.value).parsed
+    Def.unit(scriptedDependencies.value)
+    try {
+      val method = scriptedRun.value
+      val scriptedInstance = scriptedTests.value
+      val dir = sbtTestDirectory.value
+      val log = Boolean box scriptedBufferLog.value
+      val launcher = sbtLauncher.value
+      val opts = scriptedLaunchOpts.value.toArray
+      val empty = new java.util.ArrayList[File]()
+      val instances = Int box scriptedParallelInstances.value
+
+      if (scriptedBatchExecution.value)
+        method.invoke(scriptedInstance, dir, log, args.toArray, launcher, opts, empty, instances)
+      else method.invoke(scriptedInstance, dir, log, args.toArray, launcher, opts, empty)
+      ()
+    } catch { case e: java.lang.reflect.InvocationTargetException => throw e.getCause }
+  }
+
+  private[this] def getJars(config: Configuration): Initialize[Task[PathFinder]] = Def.task {
+    PathFinder(Classpaths.managedJars(config, classpathTypes.value, Keys.update.value).map(_.data))
+  }
+}
diff --git a/main/src/main/scala/sbt/SessionVar.scala b/main/src/main/scala/sbt/SessionVar.scala
index 078b947d2..a9a04607a 100644
--- a/main/src/main/scala/sbt/SessionVar.scala
+++ b/main/src/main/scala/sbt/SessionVar.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import scala.util.control.NonFatal
@@ -7,7 +14,7 @@ import sbt.internal.util.{ AttributeMap, IMap, Types }
 import Def.ScopedKey
 import Types.Id
 import Keys.sessionVars
-import sbinary.{ Format, Operations }
+import sjsonnew.JsonFormat
 
 object SessionVar {
   val DefaultDataID = "data"
@@ -20,55 +27,63 @@ object SessionVar {
   }
   def emptyMap = Map(IMap.empty)
 
-  def persistAndSet[T](key: ScopedKey[Task[T]], state: State, value: T)(implicit f: sbinary.Format[T]): State =
-    {
-      persist(key, state, value)(f)
-      set(key, state, value)
-    }
+  def persistAndSet[T](key: ScopedKey[Task[T]], state: State, value: T)(
+      implicit f: JsonFormat[T]
+  ): State = {
+    persist(key, state, value)(f)
+    set(key, state, value)
+  }
 
-  def persist[T](key: ScopedKey[Task[T]], state: State, value: T)(implicit f: sbinary.Format[T]): Unit =
-    Project.structure(state).streams(state).use(key)(s =>
-      Operations.write(s.binary(DefaultDataID), value)(f)
-    )
+  def persist[T](key: ScopedKey[Task[T]], state: State, value: T)(implicit f: JsonFormat[T]): Unit =
+    Project.structure(state).streams(state).use(key)(s => s.getOutput(DefaultDataID).write(value))
 
   def clear(s: State): State = s.put(sessionVars, SessionVar.emptyMap)
 
-  def get[T](key: ScopedKey[Task[T]], state: State): Option[T] = orEmpty(state get sessionVars) get key
+  def get[T](key: ScopedKey[Task[T]], state: State): Option[T] =
+    orEmpty(state get sessionVars) get key
 
-  def set[T](key: ScopedKey[Task[T]], state: State, value: T): State = state.update(sessionVars)(om => orEmpty(om) put (key, value))
+  def set[T](key: ScopedKey[Task[T]], state: State, value: T): State =
+    state.update(sessionVars)(om => orEmpty(om) put (key, value))
 
   def orEmpty(opt: Option[Map]) = opt getOrElse emptyMap
 
-  def transform[S](task: Task[S], f: (State, S) => State): Task[S] =
-    {
-      val g = (s: S, map: AttributeMap) => map.put(Keys.transformState, (state: State) => f(state, s))
-      task.copy(info = task.info.postTransform(g))
-    }
+  def transform[S](task: Task[S], f: (State, S) => State): Task[S] = {
+    val g = (s: S, map: AttributeMap) => map.put(Keys.transformState, (state: State) => f(state, s))
+    task.copy(info = task.info.postTransform(g))
+  }
 
-  def resolveContext[T](key: ScopedKey[Task[T]], context: Scope, state: State): ScopedKey[Task[T]] =
-    {
-      val subScope = Scope.replaceThis(context)(key.scope)
-      val scope = Project.structure(state).data.definingScope(subScope, key.key) getOrElse subScope
-      ScopedKey(scope, key.key)
-    }
+  def resolveContext[T](
+      key: ScopedKey[Task[T]],
+      context: Scope,
+      state: State
+  ): ScopedKey[Task[T]] = {
+    val subScope = Scope.replaceThis(context)(key.scope)
+    val scope = Project.structure(state).data.definingScope(subScope, key.key) getOrElse subScope
+    ScopedKey(scope, key.key)
+  }
 
-  def read[T](key: ScopedKey[Task[T]], state: State)(implicit f: Format[T]): Option[T] =
+  def read[T](key: ScopedKey[Task[T]], state: State)(implicit f: JsonFormat[T]): Option[T] =
     Project.structure(state).streams(state).use(key) { s =>
-      try { Some(Operations.read(s.readBinary(key, DefaultDataID))) }
-      catch { case NonFatal(e) => None }
+      try {
+        Some(s.getInput(key, DefaultDataID).read[T])
+      } catch { case NonFatal(_) => None }
     }
 
-  def load[T](key: ScopedKey[Task[T]], state: State)(implicit f: Format[T]): Option[T] =
+  def load[T](key: ScopedKey[Task[T]], state: State)(implicit f: JsonFormat[T]): Option[T] =
     get(key, state) orElse read(key, state)(f)
 
-  def loadAndSet[T](key: ScopedKey[Task[T]], state: State, setIfUnset: Boolean = true)(implicit f: Format[T]): (State, Option[T]) =
+  def loadAndSet[T](key: ScopedKey[Task[T]], state: State, setIfUnset: Boolean = true)(
+      implicit f: JsonFormat[T]
+  ): (State, Option[T]) =
     get(key, state) match {
       case s: Some[T] => (state, s)
-      case None => read(key, state)(f) match {
-        case s @ Some(t) =>
-          val newState = if (setIfUnset && get(key, state).isDefined) state else set(key, state, t)
-          (newState, s)
-        case None => (state, None)
-      }
+      case None =>
+        read(key, state)(f) match {
+          case s @ Some(t) =>
+            val newState =
+              if (setIfUnset && get(key, state).isDefined) state else set(key, state, t)
+            (newState, s)
+          case None => (state, None)
+        }
     }
 }
diff --git a/main/src/main/scala/sbt/StateTransform.scala b/main/src/main/scala/sbt/StateTransform.scala
new file mode 100644
index 000000000..66d5d9165
--- /dev/null
+++ b/main/src/main/scala/sbt/StateTransform.scala
@@ -0,0 +1,49 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+/**
+ * Provides a mechanism for a task to transform the state based on the result of the task. For
+ * example:
+ * {{{
+ *   val foo = AttributeKey[String]("foo")
+ *   val setFoo = taskKey[StateTransform]("")
+ *   setFoo := {
+ *     state.value.get(foo) match {
+ *       case None => StateTransform(_.put(foo, "foo"))
+ *       case _ => StateTransform(identity)
+ *     }
+ *   }
+ *   val getFoo = taskKey[Option[String]]
+ *   getFoo := state.value.get(foo)
+ * }}}
+ * Prior to a call to `setFoo`, `getFoo` will return `None`. After a call to `setFoo`, `getFoo` will
+ * return `Some("foo")`.
+ */
+final class StateTransform private (val transform: State => State, stateProxy: () => State) {
+  @deprecated("Exists only for binary compatibility with 1.3.x.", "1.4.0")
+  private[sbt] def state: State = stateProxy()
+  @deprecated("1.4.0", "Use the constructor that takes a transform function.")
+  private[sbt] def this(state: State) = this((_: State) => state, () => state)
+}
+
+object StateTransform {
+  @deprecated("Exists only for binary compatibility with 1.3.x", "1.4.0")
+  def apply(state: State): State = state
+
+  /**
+   * Create an instance of [[StateTransform]].
+   * @param transform the transformation to apply after task evaluation has completed
+   * @return the [[StateTransform]].
+   */
+  def apply(transform: State => State) =
+    new StateTransform(
+      transform,
+      () => throw new IllegalStateException("No state was added to the StateTransform.")
+    )
+}
diff --git a/main/src/main/scala/sbt/Tags.scala b/main/src/main/scala/sbt/Tags.scala
index 4ab6b5fe0..ec37b8807 100644
--- a/main/src/main/scala/sbt/Tags.scala
+++ b/main/src/main/scala/sbt/Tags.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import annotation.tailrec
@@ -13,6 +20,9 @@ object Tags {
   val Test = Tag("test")
   val Update = Tag("update")
   val Publish = Tag("publish")
+  val Clean = Tag("clean")
+  // special tag for waiting on a promise
+  val Sentinel = Tag("sentinel")
 
   val CPU = Tag("cpu")
   val Network = Tag("network")
@@ -24,7 +34,7 @@ object Tags {
    * Describes a restriction on concurrently executing tasks.
    * A Rule is constructed using one of the Tags.limit* methods.
    */
-  sealed trait Rule { // TODO: make this an abstract class for 0.14
+  abstract class Rule {
     def apply(m: TagMap): Boolean
     def ||(r: Rule): Rule = new Or(this, r)
     def &&(r: Rule): Rule = new And(this, r)
@@ -40,7 +50,7 @@ object Tags {
   }
   private[this] final class Sum(tags: Seq[Tag], max: Int) extends Rule {
     checkMax(max)
-    def apply(m: TagMap) = (0 /: tags)((sum, t) => sum + getInt(m, t)) <= max
+    def apply(m: TagMap) = tags.foldLeft(0)((sum, t) => sum + getInt(m, t)) <= max
     override def toString = tags.mkString("Limit sum of ", ", ", " to " + max)
   }
   private[this] final class Or(a: Rule, b: Rule) extends Rule {
@@ -82,16 +92,17 @@ object Tags {
   /** Returns a Rule that limits the maximum number of concurrently executing tasks without a tag to `max`.  */
   def limitUntagged(max: Int): Rule = limit(Untagged, max)
 
-  /** Returns a Rule that limits the maximum number of concurrent executings tasks tagged with `tag` to `max`.*/
+  /** Returns a Rule that limits the maximum number of concurrent executing tasks tagged with `tag` to `max`.*/
   def limit(tag: Tag, max: Int): Rule = new Single(tag, max)
 
   def limitSum(max: Int, tags: Tag*): Rule = new Sum(tags, max)
+
   /** Ensure that a task with the given tag always executes in isolation.*/
   def exclusive(exclusiveTag: Tag): Rule = customLimit { (tags: Map[Tag, Int]) =>
     // if there are no exclusive tasks in this group, this rule adds no restrictions
     tags.getOrElse(exclusiveTag, 0) == 0 ||
-      // If there is only one task, allow it to execute.
-      tags.getOrElse(Tags.All, 0) == 1
+    // If there is only one task, allow it to execute.
+    tags.getOrElse(Tags.All, 0) == 1
   }
 
   /** Ensure that a task with the given tag only executes with tasks also tagged with the given tag.*/
@@ -100,10 +111,10 @@ object Tags {
     val allCount = tags.getOrElse(Tags.All, 0)
     // If there are no exclusive tasks in this group, this rule adds no restrictions.
     exclusiveCount == 0 ||
-      // If all tasks have this tag, allow them to execute.
-      exclusiveCount == allCount ||
-      // Always allow a group containing only one task to execute (fallthrough case).
-      allCount == 1
+    // If all tasks have this tag, allow them to execute.
+    exclusiveCount == allCount ||
+    // Always allow a group containing only one task to execute (fallthrough case).
+    allCount == 1
   }
 
   /** A task tagged with one of `exclusiveTags` will not execute with another task with any of the other tags in `exclusiveTags`.*/
@@ -111,4 +122,4 @@ object Tags {
     val groups = exclusiveTags.count(tag => tags.getOrElse(tag, 0) > 0)
     groups <= 1
   }
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/TemplateCommandUtil.scala b/main/src/main/scala/sbt/TemplateCommandUtil.scala
new file mode 100644
index 000000000..34b1181ef
--- /dev/null
+++ b/main/src/main/scala/sbt/TemplateCommandUtil.scala
@@ -0,0 +1,157 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.lang.reflect.InvocationTargetException
+import java.nio.file.Path
+import java.io.File
+
+import sbt.BasicCommandStrings.TerminateAction
+import sbt.SlashSyntax0._
+import sbt.io._, syntax._
+import sbt.util._
+import sbt.internal.util.complete.{ DefaultParsers, Parser }, DefaultParsers._
+import xsbti.AppConfiguration
+import sbt.librarymanagement._
+import sbt.librarymanagement.ivy.{ IvyConfiguration, IvyDependencyResolution }
+import sbt.internal.inc.classpath.ClasspathUtil
+import BasicCommandStrings._, BasicKeys._
+
+private[sbt] object TemplateCommandUtil {
+  def templateCommand: Command =
+    Command(TemplateCommand, templateBrief, templateDetailed)(_ => templateCommandParser)(
+      runTemplate
+    )
+
+  private def templateCommandParser: Parser[Seq[String]] =
+    (token(Space) ~> repsep(StringBasic, token(Space))) | (token(EOF) map (_ => Nil))
+
+  private def runTemplate(s0: State, inputArg: Seq[String]): State = {
+    import BuildPaths._
+    val extracted0 = (Project extract s0)
+    val globalBase = getGlobalBase(s0)
+    val stagingDirectory = getStagingDirectory(s0, globalBase).getCanonicalFile
+    val templateStage = stagingDirectory / "new"
+    // This moves the target directory to a staging directory
+    // https://github.com/sbt/sbt/issues/2835
+    val state = extracted0.appendWithSession(
+      Seq(
+        Keys.target := templateStage
+      ),
+      s0
+    )
+    val infos = (state get templateResolverInfos getOrElse Nil).toList
+    val log = state.globalLogging.full
+    val extracted = (Project extract state)
+    val (s2, ivyConf) = extracted.runTask(Keys.ivyConfiguration, state)
+    val scalaModuleInfo = extracted.get(Keys.updateSbtClassifiers / Keys.scalaModuleInfo)
+    val arguments = inputArg.toList ++
+      (state.remainingCommands match {
+        case exec :: Nil if exec.commandLine == "shell" => Nil
+        case xs                                         => xs map (_.commandLine)
+      })
+    run(infos, arguments, state.configuration, ivyConf, globalBase, scalaModuleInfo, log)
+    TerminateAction :: s2.copy(remainingCommands = Nil)
+  }
+
+  private def run(
+      infos: List[TemplateResolverInfo],
+      arguments: List[String],
+      config: AppConfiguration,
+      ivyConf: IvyConfiguration,
+      globalBase: File,
+      scalaModuleInfo: Option[ScalaModuleInfo],
+      log: Logger
+  ): Unit =
+    infos find { info =>
+      val loader = infoLoader(info, config, ivyConf, globalBase, scalaModuleInfo, log)
+      val hit = tryTemplate(info, arguments, loader)
+      if (hit) {
+        runTemplate(info, arguments, loader)
+      }
+      hit
+    } match {
+      case Some(_) => // do nothing
+      case None    => System.err.println("Template not found for: " + arguments.mkString(" "))
+    }
+
+  private def tryTemplate(
+      info: TemplateResolverInfo,
+      arguments: List[String],
+      loader: ClassLoader
+  ): Boolean = {
+    val resultObj = call(info.implementationClass, "isDefined", loader)(
+      classOf[Array[String]]
+    )(arguments.toArray)
+    resultObj.asInstanceOf[Boolean]
+  }
+
+  private def runTemplate(
+      info: TemplateResolverInfo,
+      arguments: List[String],
+      loader: ClassLoader
+  ): Unit = {
+    call(info.implementationClass, "run", loader)(classOf[Array[String]])(arguments.toArray)
+    ()
+  }
+
+  private def infoLoader(
+      info: TemplateResolverInfo,
+      config: AppConfiguration,
+      ivyConf: IvyConfiguration,
+      globalBase: File,
+      scalaModuleInfo: Option[ScalaModuleInfo],
+      log: Logger
+  ): ClassLoader = {
+    val cp = classpathForInfo(info, ivyConf, globalBase, scalaModuleInfo, log)
+    ClasspathUtil.toLoader(cp, config.provider.loader)
+  }
+
+  private def call(
+      interfaceClassName: String,
+      methodName: String,
+      loader: ClassLoader
+  )(argTypes: Class[_]*)(args: AnyRef*): AnyRef = {
+    val interfaceClass = getInterfaceClass(interfaceClassName, loader)
+    val interface = interfaceClass.getDeclaredConstructor().newInstance().asInstanceOf[AnyRef]
+    val method = interfaceClass.getMethod(methodName, argTypes: _*)
+    try {
+      method.invoke(interface, args: _*)
+    } catch {
+      case e: InvocationTargetException => throw e.getCause
+    }
+  }
+
+  private def getInterfaceClass(name: String, loader: ClassLoader) =
+    Class.forName(name, true, loader)
+
+  // Cache files under ~/.sbt/0.13/templates/org_name_version
+  private def classpathForInfo(
+      info: TemplateResolverInfo,
+      ivyConf: IvyConfiguration,
+      globalBase: File,
+      scalaModuleInfo: Option[ScalaModuleInfo],
+      log: Logger
+  ): List[Path] = {
+    val lm = IvyDependencyResolution(ivyConf)
+    val templatesBaseDirectory = new File(globalBase, "templates")
+    val templateId = s"${info.module.organization}_${info.module.name}_${info.module.revision}"
+    val templateDirectory = new File(templatesBaseDirectory, templateId)
+    def jars = (templateDirectory ** -DirectoryFilter).get
+    if (!(info.module.revision endsWith "-SNAPSHOT") && jars.nonEmpty) jars.toList.map(_.toPath)
+    else {
+      IO.createDirectory(templateDirectory)
+      val m = lm.wrapDependencyInModule(info.module, scalaModuleInfo)
+      val xs = lm.retrieve(m, templateDirectory, log) match {
+        case Left(_)      => sys.error(s"Retrieval of ${info.module} failed.")
+        case Right(files) => files.toList
+      }
+      xs.map(_.toPath)
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/Terminal.scala b/main/src/main/scala/sbt/Terminal.scala
new file mode 100644
index 000000000..8d84cd167
--- /dev/null
+++ b/main/src/main/scala/sbt/Terminal.scala
@@ -0,0 +1,73 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.io.{ InputStream, PrintStream }
+import sbt.internal.util.{ JLine3, Terminal => ITerminal }
+
+/**
+ * A Terminal represents a ui connection to sbt. It may control the embedded console
+ * for an sbt server or it may control a remote client connected through sbtn. The
+ * Terminal is particularly useful whenever an sbt task needs to receive input from
+ * the user.
+ *
+ */
+trait Terminal {
+
+  /**
+   * Returns the width of the terminal.
+   *
+   * @return the width ot the terminal
+   */
+  def getWidth: Int
+
+  /**
+   * Returns the height of the terminal
+   *
+   * @return the height of the terminal
+   */
+  def getHeight: Int
+
+  /**
+   * An input stream associated with the terminal. Bytes inputted by the
+   * user may be read from this input stream.
+   *
+   * @return the terminal's input stream
+   */
+  def inputStream: InputStream
+
+  /**
+   * A print stream associated with the terminal. Writing to this output
+   * stream should display text on the terminal.
+   *
+   * @return the terminal's input stream
+   */
+  def printStream: PrintStream
+
+  /**
+   * Sets the mode of the terminal. By default,the terminal will be in canonical mode
+   * with echo enabled. This means that the terminal's inputStream will not return any
+   * bytes until a newline is received and that all of the characters inputed by the
+   * user will be echoed to the terminal's output stream.
+   *
+   * @param canonical toggles whether or not the terminal input stream is line buffered
+   * @param echo toggles whether or not to echo the characters received from the terminal input stream
+   */
+  def setMode(canonical: Boolean, echo: Boolean): Unit
+
+}
+private[sbt] object Terminal {
+  private[sbt] def apply(term: ITerminal): Terminal = new Terminal {
+    override def getHeight: Int = term.getHeight
+    override def getWidth: Int = term.getWidth
+    override def inputStream: InputStream = term.inputStream
+    override def printStream: PrintStream = term.printStream
+    override def setMode(canonical: Boolean, echo: Boolean): Unit =
+      JLine3.setMode(term, canonical, echo)
+  }
+}
diff --git a/main/src/main/scala/sbt/UpperStateOps.scala b/main/src/main/scala/sbt/UpperStateOps.scala
new file mode 100644
index 000000000..02c9ef0c3
--- /dev/null
+++ b/main/src/main/scala/sbt/UpperStateOps.scala
@@ -0,0 +1,160 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import sjsonnew.JsonFormat
+import Def.Setting
+import sbt.internal.{ BuildStructure, LoadedBuildUnit, SessionSettings }
+
+/**
+ * Extends State with setting-level knowledge.
+ */
+trait UpperStateOps extends Any {
+
+  /**
+   * ProjectRef to the current project of the state session that can be change using
+   * `project` commmand.
+   */
+  def currentRef: ProjectRef
+
+  /**
+   * Current project of the state session that can be change using `project` commmand.
+   */
+  def currentProject: ResolvedProject
+
+  private[sbt] def structure: BuildStructure
+
+  private[sbt] def session: SessionSettings
+
+  private[sbt] def currentUnit: LoadedBuildUnit
+
+  /**
+   * Gets the value assigned to `key` in the computed settings map.
+   * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
+   * Other axes are resolved to be `Zero` if they are not specified.
+   */
+  def getSetting[A](key: SettingKey[A]): Option[A]
+
+  /**
+   * Gets the value assigned to `key` in the computed settings map.
+   * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
+   * Other axes are resolved to be `Zero` if they are not specified.
+   */
+  def getTaskValue[A](key: TaskKey[A]): Option[Task[A]]
+
+  /**
+   * Gets the value assigned to `key` in the computed settings map.
+   * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
+   * Other axes are resolved to be `Zero` if they are not specified.
+   */
+  def setting[A](key: SettingKey[A]): A
+
+  /**
+   * Gets the value assigned to `key` in the computed settings map.
+   * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
+   * Other axes are resolved to be `Zero` if they are not specified.
+   */
+  def taskValue[A](key: TaskKey[A]): Task[A]
+
+  /**
+   * Runs the task specified by `key` and returns the transformed State and the resulting value of the task.
+   * If the project axis is not defined for the key, it is resolved to be the current project.
+   * Other axes are resolved to `Zero` if unspecified.
+   *
+   * This method requests execution of only the given task and does not aggregate execution.
+   * See `runAggregated` for that.
+   *
+   * To avoid race conditions, this should NOT be called from a task.
+   */
+  def unsafeRunTask[A](key: TaskKey[A]): (State, A)
+
+  /**
+   * Runs the input task specified by `key`, using the `input` as the input to it, and returns the transformed State
+   * and the resulting value of the input task.
+   *
+   * If the project axis is not defined for the key, it is resolved to be the current project.
+   * Other axes are resolved to `Zero` if unspecified.
+   *
+   * This method requests execution of only the given task and does not aggregate execution.
+   * To avoid race conditions, this should NOT be called from a task.
+   */
+  def unsafeRunInputTask[A](key: InputKey[A], input: String): (State, A)
+
+  /**
+   * Runs the tasks selected by aggregating `key` and returns the transformed State.
+   * If the project axis is not defined for the key, it is resolved to be the current project.
+   * The project axis is what determines where aggregation starts, so ensure this is set to what you want.
+   * Other axes are resolved to `Zero` if unspecified.
+   *
+   * To avoid race conditions, this should NOT be called from a task.
+   */
+  def unsafeRunAggregated[A](key: TaskKey[A]): State
+
+  /** Appends the given settings to all the build state settings, including session settings. */
+  def appendWithSession(settings: Seq[Setting[_]]): State
+
+  /**
+   * Appends the given settings to the original build state settings, discarding any settings
+   * appended to the session in the process.
+   */
+  def appendWithoutSession(settings: Seq[Setting[_]], state: State): State
+
+  def respondEvent[A: JsonFormat](event: A): Unit
+  def respondError(code: Long, message: String): Unit
+  def notifyEvent[A: JsonFormat](method: String, params: A): Unit
+}
+
+object UpperStateOps {
+  lazy val exchange = StandardMain.exchange
+
+  implicit class UpperStateOpsImpl(val s: State) extends AnyVal with UpperStateOps {
+    def extract: Extracted = Project.extract(s)
+
+    def currentRef = extract.currentRef
+
+    def currentProject: ResolvedProject = extract.currentProject
+
+    private[sbt] def structure: BuildStructure = Project.structure(s)
+
+    private[sbt] def currentUnit: LoadedBuildUnit = extract.currentUnit
+
+    private[sbt] def session: SessionSettings = Project.session(s)
+
+    def getSetting[A](key: SettingKey[A]): Option[A] = extract.getOpt(key)
+
+    def getTaskValue[A](key: TaskKey[A]): Option[Task[A]] = extract.getOpt(key)
+
+    def setting[A](key: SettingKey[A]): A = extract.get(key)
+
+    def taskValue[A](key: TaskKey[A]): Task[A] = extract.get(key)
+
+    def unsafeRunTask[A](key: TaskKey[A]): (State, A) = extract.runTask(key, s)
+
+    def unsafeRunInputTask[A](key: InputKey[A], input: String): (State, A) =
+      extract.runInputTask(key, input, s)
+
+    def unsafeRunAggregated[A](key: TaskKey[A]): State =
+      extract.runAggregated(key, s)
+
+    def appendWithSession(settings: Seq[Setting[_]]): State =
+      extract.appendWithSession(settings, s)
+
+    def appendWithoutSession(settings: Seq[Setting[_]], state: State): State =
+      extract.appendWithoutSession(settings, s)
+
+    def respondEvent[A: JsonFormat](event: A): Unit = {
+      exchange.respondEvent(event, s.currentCommand.flatMap(_.execId), s.source)
+    }
+    def respondError(code: Long, message: String): Unit = {
+      exchange.respondError(code, message, s.currentCommand.flatMap(_.execId), s.source)
+    }
+    def notifyEvent[A: JsonFormat](method: String, params: A): Unit = {
+      exchange.notifyEvent(method, params)
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/VersionScheme.scala b/main/src/main/scala/sbt/VersionScheme.scala
new file mode 100644
index 000000000..4427f7798
--- /dev/null
+++ b/main/src/main/scala/sbt/VersionScheme.scala
@@ -0,0 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import sbt.internal.librarymanagement.VersionSchemes
+
+object VersionScheme {
+  val Always = VersionSchemes.Always
+  val EarlySemVer = VersionSchemes.EarlySemVer
+  val PVP = VersionSchemes.PackVer
+  val SemVerSpec = VersionSchemes.SemVerSpec
+  val Strict = VersionSchemes.Strict
+}
diff --git a/main/src/main/scala/sbt/coursierint/CoursierArtifactsTasks.scala b/main/src/main/scala/sbt/coursierint/CoursierArtifactsTasks.scala
new file mode 100644
index 000000000..84f6776fb
--- /dev/null
+++ b/main/src/main/scala/sbt/coursierint/CoursierArtifactsTasks.scala
@@ -0,0 +1,138 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package coursierint
+
+import lmcoursier.definitions.{
+  Classifier => CClassifier,
+  Configuration => CConfiguration,
+  Extension => CExtension,
+  Publication => CPublication,
+  Type => CType
+}
+import sbt.librarymanagement._
+import sbt.Keys._
+import sbt.SlashSyntax0._
+
+object CoursierArtifactsTasks {
+  def coursierPublicationsTask(
+      configsMap: (sbt.librarymanagement.Configuration, CConfiguration)*
+  ): Def.Initialize[sbt.Task[Seq[(CConfiguration, CPublication)]]] =
+    Def.task {
+      val s = sbt.Keys.state.value
+      val projectRef = sbt.Keys.thisProjectRef.value
+      val projId = sbt.Keys.projectID.value
+      val sv = sbt.Keys.scalaVersion.value
+      val sbv = sbt.Keys.scalaBinaryVersion.value
+      val ivyConfs = sbt.Keys.ivyConfigurations.value
+      val extracted = Project.extract(s)
+      import extracted._
+
+      val sourcesConfigOpt =
+        if (ivyConfigurations.value.exists(_.name == "sources"))
+          Some(CConfiguration("sources"))
+        else
+          None
+
+      val docsConfigOpt =
+        if (ivyConfigurations.value.exists(_.name == "docs"))
+          Some(CConfiguration("docs"))
+        else
+          None
+
+      val sbtBinArtifacts =
+        for ((config, targetConfig) <- configsMap) yield {
+
+          val publish = getOpt(
+            projectRef / config / packageBin / publishArtifact
+          ).getOrElse(false)
+
+          if (publish)
+            getOpt(
+              projectRef / config / packageBin / artifact
+            ).map(targetConfig -> _)
+          else
+            None
+        }
+
+      val sbtSourceArtifacts =
+        for ((config, targetConfig) <- configsMap) yield {
+
+          val publish = getOpt(
+            projectRef / config / packageSrc / publishArtifact
+          ).getOrElse(false)
+
+          if (publish)
+            getOpt(
+              projectRef / config / packageSrc / artifact
+            ).map(sourcesConfigOpt.getOrElse(targetConfig) -> _)
+          else
+            None
+        }
+
+      val sbtDocArtifacts =
+        for ((config, targetConfig) <- configsMap) yield {
+
+          val publish =
+            getOpt(
+              projectRef / config / packageDoc / publishArtifact
+            ).getOrElse(false)
+
+          if (publish)
+            getOpt(
+              projectRef / config / packageDoc / artifact
+            ).map(docsConfigOpt.getOrElse(targetConfig) -> _)
+          else
+            None
+        }
+
+      val sbtArtifacts = sbtBinArtifacts ++ sbtSourceArtifacts ++ sbtDocArtifacts
+
+      def artifactPublication(artifact: Artifact) = {
+
+        val name = CrossVersion(projId.crossVersion, sv, sbv)
+          .fold(artifact.name)(_(artifact.name))
+
+        CPublication(
+          name,
+          CType(artifact.`type`),
+          CExtension(artifact.extension),
+          artifact.classifier.fold(CClassifier(""))(CClassifier(_))
+        )
+      }
+
+      val sbtArtifactsPublication = sbtArtifacts.collect {
+        case Some((config, artifact)) =>
+          config -> artifactPublication(artifact)
+      }
+
+      val stdArtifactsSet = sbtArtifacts.flatMap(_.map { case (_, a) => a }.toSeq).toSet
+
+      // Second-way of getting artifacts from sbt
+      // No obvious way of getting the corresponding  publishArtifact  value for the ones
+      // only here, it seems.
+      val extraSbtArtifacts = getOpt(
+        projectRef / sbt.Keys.artifacts
+      ).getOrElse(Nil)
+        .filterNot(stdArtifactsSet)
+
+      // Seems that sbt does that - if an artifact has no configs,
+      // it puts it in all of them. See for example what happens to
+      // the standalone JAR artifact of the coursier cli module.
+      def allConfigsIfEmpty(configs: Iterable[ConfigRef]): Iterable[ConfigRef] =
+        if (configs.isEmpty) ivyConfs.filter(_.isPublic).map(c => ConfigRef(c.name)) else configs
+
+      val extraSbtArtifactsPublication = for {
+        artifact <- extraSbtArtifacts
+        config <- allConfigsIfEmpty(artifact.configurations.map(x => ConfigRef(x.name)))
+        // FIXME If some configurations from artifact.configurations are not public, they may leak here :\
+      } yield CConfiguration(config.name) -> artifactPublication(artifact)
+
+      sbtArtifactsPublication ++ extraSbtArtifactsPublication
+    }
+}
diff --git a/main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala b/main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala
new file mode 100644
index 000000000..9059f36ef
--- /dev/null
+++ b/main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala
@@ -0,0 +1,256 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package coursierint
+
+import java.net.URL
+import sbt.librarymanagement._
+import sbt.util.Logger
+import sbt.Keys._
+import lmcoursier.definitions.{
+  Classifier => CClassifier,
+  Configuration => CConfiguration,
+  Dependency => CDependency,
+  Extension => CExtension,
+  Info => CInfo,
+  Module => CModule,
+  ModuleName => CModuleName,
+  Organization => COrganization,
+  Project => CProject,
+  Publication => CPublication,
+  Type => CType,
+  Strict => CStrict,
+}
+import lmcoursier.credentials.DirectCredentials
+import lmcoursier.{ FallbackDependency, FromSbt, Inputs }
+import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties
+import sbt.librarymanagement.ivy.{
+  FileCredentials,
+  Credentials,
+  DirectCredentials => IvyDirectCredentials
+}
+import sbt.ScopeFilter.Make._
+import scala.collection.JavaConverters._
+
+object CoursierInputsTasks {
+  private def coursierProject0(
+      projId: ModuleID,
+      dependencies: Seq[ModuleID],
+      configurations: Seq[sbt.librarymanagement.Configuration],
+      sv: String,
+      sbv: String,
+      auOpt: Option[URL],
+      description: String,
+      homepage: Option[URL],
+      vsOpt: Option[String],
+      log: Logger
+  ): CProject = {
+
+    val configMap = Inputs.configExtendsSeq(configurations).toMap
+
+    val proj0 = FromSbt.project(
+      projId,
+      dependencies,
+      configMap,
+      sv,
+      sbv
+    )
+    val proj1 = auOpt match {
+      case Some(au) =>
+        proj0.withProperties(proj0.properties :+ (SbtPomExtraProperties.POM_API_KEY -> au.toString))
+      case _ => proj0
+    }
+    val proj2 = vsOpt match {
+      case Some(vs) =>
+        proj1.withProperties(proj1.properties :+ (SbtPomExtraProperties.VERSION_SCHEME_KEY -> vs))
+      case _ => proj1
+    }
+    proj2.withInfo(
+      proj2.info.withDescription(description).withHomePage(homepage.fold("")(_.toString))
+    )
+  }
+
+  def coursierProjectTask: Def.Initialize[sbt.Task[CProject]] =
+    Def.task {
+      coursierProject0(
+        projectID.value,
+        allDependencies.value,
+        ivyConfigurations.value,
+        scalaVersion.value,
+        scalaBinaryVersion.value,
+        apiURL.value,
+        description.value,
+        homepage.value,
+        versionScheme.value,
+        streams.value.log
+      )
+    }
+
+  private def moduleFromIvy(id: org.apache.ivy.core.module.id.ModuleRevisionId): CModule =
+    CModule(
+      COrganization(id.getOrganisation),
+      CModuleName(id.getName),
+      id.getExtraAttributes.asScala.map {
+        case (k0, v0) => k0.asInstanceOf[String] -> v0.asInstanceOf[String]
+      }.toMap
+    )
+
+  private def dependencyFromIvy(
+      desc: org.apache.ivy.core.module.descriptor.DependencyDescriptor
+  ): Seq[(CConfiguration, CDependency)] = {
+
+    val id = desc.getDependencyRevisionId
+    val module = moduleFromIvy(id)
+    val exclusions = desc.getAllExcludeRules.map { rule =>
+      // we're ignoring rule.getConfigurations and rule.getMatcher here
+      val modId = rule.getId.getModuleId
+      // we're ignoring modId.getAttributes here
+      (COrganization(modId.getOrganisation), CModuleName(modId.getName))
+    }.toSet
+
+    val configurations = desc.getModuleConfigurations.toVector
+      .flatMap(Inputs.ivyXmlMappings)
+
+    def dependency(conf: CConfiguration, pub: CPublication) = CDependency(
+      module,
+      id.getRevision,
+      conf,
+      exclusions,
+      pub,
+      optional = false,
+      desc.isTransitive
+    )
+
+    val publications: CConfiguration => CPublication = {
+
+      val artifacts = desc.getAllDependencyArtifacts
+
+      val m = artifacts.toVector.flatMap { art =>
+        val pub =
+          CPublication(art.getName, CType(art.getType), CExtension(art.getExt()), CClassifier(""))
+        art.getConfigurations.map(CConfiguration(_)).toVector.map { conf =>
+          conf -> pub
+        }
+      }.toMap
+
+      c => m.getOrElse(c, CPublication("", CType(""), CExtension(""), CClassifier("")))
+    }
+
+    configurations.map {
+      case (from, to) =>
+        from -> dependency(to, publications(to))
+    }
+  }
+
+  private[sbt] def coursierInterProjectDependenciesTask: Def.Initialize[sbt.Task[Seq[CProject]]] =
+    Def.taskDyn {
+      val state = sbt.Keys.state.value
+      val projectRef = sbt.Keys.thisProjectRef.value
+      val projectRefs = Project.transitiveInterDependencies(state, projectRef)
+      Def.task {
+        csrProject.all(ScopeFilter(inProjects(projectRefs :+ projectRef: _*))).value
+      }
+    }
+
+  private[sbt] def coursierExtraProjectsTask: Def.Initialize[sbt.Task[Seq[CProject]]] = {
+    Def.task {
+      val projects = csrInterProjectDependencies.value
+      val projectModules = projects.map(_.module).toSet
+
+      // this includes org.scala-sbt:global-plugins referenced from meta-builds in particular
+      sbt.Keys.projectDescriptors.value
+        .map {
+          case (k, v) =>
+            moduleFromIvy(k) -> v
+        }
+        .filter {
+          case (module, _) =>
+            !projectModules(module)
+        }
+        .toVector
+        .map {
+          case (module, v) =>
+            val configurations = v.getConfigurations.map { c =>
+              CConfiguration(c.getName) -> c.getExtends.map(CConfiguration(_)).toSeq
+            }.toMap
+            val deps = v.getDependencies.flatMap(dependencyFromIvy)
+            CProject(
+              module,
+              v.getModuleRevisionId.getRevision,
+              deps,
+              configurations,
+              Nil,
+              None,
+              Nil,
+              CInfo("", "", Nil, Nil, None)
+            )
+        }
+    }
+  }
+
+  private[sbt] def coursierFallbackDependenciesTask
+      : Def.Initialize[sbt.Task[Seq[FallbackDependency]]] =
+    Def.taskDyn {
+      val s = state.value
+      val projectRef = thisProjectRef.value
+      val projects = Project.transitiveInterDependencies(s, projectRef)
+
+      Def.task {
+        val allDeps =
+          allDependencies.all(ScopeFilter(inProjects(projectRef +: projects: _*))).value.flatten
+
+        FromSbt.fallbackDependencies(
+          allDeps,
+          scalaVersion.value,
+          scalaBinaryVersion.value
+        )
+      }
+    }
+
+  val credentialsTask = Def.task {
+    val log = streams.value.log
+    val creds = sbt.Keys.allCredentials.value
+      .flatMap {
+        case dc: IvyDirectCredentials => List(dc)
+        case fc: FileCredentials =>
+          Credentials.loadCredentials(fc.path) match {
+            case Left(err) =>
+              log.warn(s"$err, ignoring it")
+              Nil
+            case Right(dc) => List(dc)
+          }
+      }
+      .map { c =>
+        DirectCredentials()
+          .withHost(c.host)
+          .withUsername(c.userName)
+          .withPassword(c.passwd)
+          .withRealm(Option(c.realm).filter(_.nonEmpty))
+          .withHttpsOnly(false)
+          .withMatchHost(true)
+      }
+    creds ++ csrExtraCredentials.value
+  }
+
+  val strictTask = Def.task {
+    val cm = conflictManager.value
+    val log = streams.value.log
+
+    cm.name match {
+      case ConflictManager.latestRevision.name =>
+        None
+      case ConflictManager.strict.name =>
+        val strict = CStrict()
+          .withInclude(Set((cm.organization, cm.module)))
+        Some(strict)
+      case other =>
+        log.warn(s"Unsupported conflict manager $other")
+        None
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/coursierint/CoursierRepositoriesTasks.scala b/main/src/main/scala/sbt/coursierint/CoursierRepositoriesTasks.scala
new file mode 100644
index 000000000..8bbdb8969
--- /dev/null
+++ b/main/src/main/scala/sbt/coursierint/CoursierRepositoriesTasks.scala
@@ -0,0 +1,145 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package coursierint
+
+import sbt.librarymanagement._
+import sbt.Keys._
+import sbt.ScopeFilter.Make._
+import sbt.SlashSyntax0._
+
+object CoursierRepositoriesTasks {
+  private object CResolvers {
+    private val slowReposBase = Seq(
+      "https://repo.typesafe.com/",
+      "https://repo.scala-sbt.org/",
+      "http://repo.typesafe.com/",
+      "http://repo.scala-sbt.org/"
+    )
+
+    private val fastReposBase = Seq(
+      "http://repo1.maven.org/",
+      "https://repo1.maven.org/"
+    )
+
+    private def url(res: Resolver): Option[String] =
+      res match {
+        case m: sbt.librarymanagement.MavenRepository =>
+          Some(m.root)
+        case u: URLRepository =>
+          u.patterns.artifactPatterns.headOption
+            .orElse(u.patterns.ivyPatterns.headOption)
+        case _ =>
+          None
+      }
+
+    private def fastRepo(res: Resolver): Boolean =
+      url(res).exists(u => fastReposBase.exists(u.startsWith))
+
+    private def slowRepo(res: Resolver): Boolean =
+      url(res).exists(u => slowReposBase.exists(u.startsWith))
+
+    def reorderResolvers(resolvers: Seq[Resolver]): Seq[Resolver] =
+      if (resolvers.exists(fastRepo) && resolvers.exists(slowRepo)) {
+        val (slow, other) = resolvers.partition(slowRepo)
+        other ++ slow
+      } else
+        resolvers
+  }
+
+  // local-preloaded-ivy contains dangling ivy.xml without JAR files
+  // https://github.com/sbt/sbt/issues/4661
+  private final val keepPreloaded = false // coursierKeepPreloaded.value
+
+  def coursierResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = Def.task {
+    val bootResOpt = bootResolvers.value
+    val overrideFlag = overrideBuildResolvers.value
+    val result0 = bootResOpt.filter(_ => overrideFlag) match {
+      case Some(r) => r
+      case None =>
+        val extRes = externalResolvers.value
+        val isSbtPlugin = sbtPlugin.value
+        if (isSbtPlugin) sbtResolvers.value ++ extRes
+        else extRes
+    }
+    val reorderResolvers = true // coursierReorderResolvers.value
+
+    val paths = ivyPaths.value
+    val result1 =
+      if (reorderResolvers) CResolvers.reorderResolvers(result0)
+      else result0
+    val result2 =
+      paths.ivyHome match {
+        case Some(ivyHome) =>
+          val ivyHomeUri = ivyHome.getPath
+          result1 map {
+            case r: FileRepository =>
+              val ivyPatterns = r.patterns.ivyPatterns map {
+                _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri)
+              }
+              val artifactPatterns = r.patterns.artifactPatterns map {
+                _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri)
+              }
+              val p =
+                r.patterns.withIvyPatterns(ivyPatterns).withArtifactPatterns(artifactPatterns)
+              r.withPatterns(p)
+            case r => r
+          }
+        case _ => result1
+      }
+
+    if (keepPreloaded)
+      result2
+    else
+      result2.filter { r =>
+        !r.name.startsWith("local-preloaded")
+      }
+  }
+
+  private val pluginIvySnapshotsBase = Resolver.SbtRepositoryRoot.stripSuffix("/") + "/ivy-snapshots"
+
+  def coursierSbtResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = Def.task {
+    val resolvers =
+      sbt.Classpaths
+        .bootRepositories(appConfiguration.value)
+        .toSeq
+        .flatten ++ // required because of the hack above it seems
+        (updateSbtClassifiers / externalResolvers).value
+
+    val pluginIvySnapshotsFound = resolvers.exists {
+      case repo: URLRepository =>
+        repo.patterns.artifactPatterns.headOption
+          .exists(_.startsWith(pluginIvySnapshotsBase))
+      case _ => false
+    }
+
+    val resolvers0 =
+      if (pluginIvySnapshotsFound && !resolvers.contains(Classpaths.sbtPluginReleases))
+        resolvers :+ Classpaths.sbtPluginReleases
+      else
+        resolvers
+    if (keepPreloaded)
+      resolvers0
+    else
+      resolvers0.filter { r =>
+        !r.name.startsWith("local-preloaded")
+      }
+  }
+
+  def coursierRecursiveResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] =
+    Def.taskDyn {
+      val s = state.value
+      val projectRef = thisProjectRef.value
+      val dependencyRefs = Project.transitiveInterDependencies(s, projectRef)
+      Def.task {
+        val resolvers = csrResolvers.all(ScopeFilter(inProjects(projectRef))).value ++
+          csrResolvers.all(ScopeFilter(inProjects(dependencyRefs: _*))).value
+        resolvers.flatten
+      }
+    }
+}
diff --git a/main/src/main/scala/sbt/coursierint/LMCoursier.scala b/main/src/main/scala/sbt/coursierint/LMCoursier.scala
new file mode 100644
index 000000000..36d7cf524
--- /dev/null
+++ b/main/src/main/scala/sbt/coursierint/LMCoursier.scala
@@ -0,0 +1,348 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package coursierint
+
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import lmcoursier.definitions.{
+  Classifier,
+  Configuration => CConfiguration,
+  CacheLogger,
+  Project => CProject,
+  ModuleMatchers,
+  Reconciliation,
+  Strict => CStrict,
+}
+import lmcoursier._
+import lmcoursier.credentials.Credentials
+import Keys._
+import sbt.internal.util.Util
+import sbt.librarymanagement._
+import sbt.librarymanagement.ivy.{
+  Credentials => IvyCredentials,
+  DirectCredentials,
+  FileCredentials
+}
+import sbt.util.Logger
+import sbt.io.syntax._
+import xsbti.AppConfiguration
+import sbt.SlashSyntax0._
+
+object LMCoursier {
+  private[this] val credentialRegistry: ConcurrentHashMap[(String, String), IvyCredentials] =
+    new ConcurrentHashMap
+
+  def defaultCacheLocation: File = {
+    def absoluteFile(path: String): File = new File(path).getAbsoluteFile()
+    def windowsCacheDirectory: File = {
+      // Per discussion in https://github.com/dirs-dev/directories-jvm/issues/43,
+      // LOCALAPPDATA environment variable may NOT represent the one-true
+      // Known Folders API (https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid)
+      // in case the user happened to have set the LOCALAPPDATA environmental variable.
+      // Given that there's no reliable way of accessing this API from JVM, I think it's actually
+      // better to use the LOCALAPPDATA as the first place to look.
+      // When it is not found, it will fall back to $HOME/AppData/Local.
+      // For the purpose of picking the Coursier cache directory, it's better to be
+      // fast, reliable, and predictable rather than strict adherence to Microsoft.
+      val base =
+        sys.env
+          .get("LOCALAPPDATA")
+          .map(absoluteFile)
+          .getOrElse(absoluteFile(sys.props("user.home")) / "AppData" / "Local")
+      base / "Coursier" / "Cache" / "v1"
+    }
+    sys.props
+      .get("sbt.coursier.home")
+      .map(home => absoluteFile(home) / "cache")
+      .orElse(sys.env.get("COURSIER_CACHE").map(absoluteFile))
+      .orElse(sys.props.get("coursier.cache").map(absoluteFile)) match {
+      case Some(dir) => dir
+      case _ =>
+        if (Util.isWindows) windowsCacheDirectory
+        else CoursierDependencyResolution.defaultCacheLocation
+    }
+  }
+
+  def relaxedForAllModules: Seq[(ModuleMatchers, Reconciliation)] =
+    Vector((ModuleMatchers.all, Reconciliation.Relaxed))
+
+  def coursierConfiguration(
+      rs: Seq[Resolver],
+      interProjectDependencies: Seq[CProject],
+      extraProjects: Seq[CProject],
+      fallbackDeps: Seq[FallbackDependency],
+      appConfig: AppConfiguration,
+      classifiers: Option[Seq[Classifier]],
+      profiles: Set[String],
+      scalaOrg: String,
+      scalaVer: String,
+      scalaBinaryVer: String,
+      autoScalaLib: Boolean,
+      scalaModInfo: Option[ScalaModuleInfo],
+      excludeDeps: Seq[InclExclRule],
+      credentials: Seq[Credentials],
+      createLogger: Option[CacheLogger],
+      cacheDirectory: File,
+      reconciliation: Seq[(ModuleMatchers, Reconciliation)],
+      ivyHome: Option[File],
+      strict: Option[CStrict],
+      depsOverrides: Seq[ModuleID],
+      log: Logger
+  ): CoursierConfiguration =
+    coursierConfiguration(
+      rs,
+      interProjectDependencies,
+      extraProjects,
+      fallbackDeps,
+      appConfig,
+      classifiers,
+      profiles,
+      scalaOrg,
+      scalaVer,
+      scalaBinaryVer,
+      autoScalaLib,
+      scalaModInfo,
+      excludeDeps,
+      credentials,
+      createLogger,
+      cacheDirectory,
+      reconciliation,
+      ivyHome,
+      strict,
+      depsOverrides,
+      None,
+      log
+    )
+
+  def coursierConfiguration(
+      rs: Seq[Resolver],
+      interProjectDependencies: Seq[CProject],
+      extraProjects: Seq[CProject],
+      fallbackDeps: Seq[FallbackDependency],
+      appConfig: AppConfiguration,
+      classifiers: Option[Seq[Classifier]],
+      profiles: Set[String],
+      scalaOrg: String,
+      scalaVer: String,
+      scalaBinaryVer: String,
+      autoScalaLib: Boolean,
+      scalaModInfo: Option[ScalaModuleInfo],
+      excludeDeps: Seq[InclExclRule],
+      credentials: Seq[Credentials],
+      createLogger: Option[CacheLogger],
+      cacheDirectory: File,
+      reconciliation: Seq[(ModuleMatchers, Reconciliation)],
+      ivyHome: Option[File],
+      strict: Option[CStrict],
+      depsOverrides: Seq[ModuleID],
+      updateConfig: Option[UpdateConfiguration],
+      log: Logger
+  ): CoursierConfiguration = {
+    val coursierExcludeDeps = Inputs
+      .exclusions(
+        excludeDeps,
+        scalaVer,
+        scalaBinaryVer,
+        log
+      )
+      .toVector
+      .map {
+        case (o, n) =>
+          (o.value, n.value)
+      }
+      .sorted
+    val autoScala = autoScalaLib && scalaModInfo.forall(
+      _.overrideScalaVersion
+    )
+    val internalSbtScalaProvider = appConfig.provider.scalaProvider
+    val sbtBootJars = internalSbtScalaProvider.jars()
+    val sbtScalaVersion = internalSbtScalaProvider.version()
+    val sbtScalaOrganization = "org.scala-lang" // always assuming sbt uses mainline scala
+    val userForceVersions = Inputs.forceVersions(depsOverrides, scalaVer, scalaBinaryVer)
+    Classpaths.warnResolversConflict(rs, log)
+    Classpaths.errorInsecureProtocol(rs, log)
+    val missingOk = updateConfig match {
+      case Some(uc) => uc.missingOk
+      case _        => false
+    }
+    CoursierConfiguration()
+      .withResolvers(rs.toVector)
+      .withInterProjectDependencies(interProjectDependencies.toVector)
+      .withExtraProjects(extraProjects.toVector)
+      .withFallbackDependencies(fallbackDeps.toVector)
+      .withExcludeDependencies(coursierExcludeDeps)
+      .withAutoScalaLibrary(autoScala)
+      .withSbtScalaJars(sbtBootJars.toVector)
+      .withSbtScalaVersion(sbtScalaVersion)
+      .withSbtScalaOrganization(sbtScalaOrganization)
+      .withClassifiers(classifiers.toVector.flatten.map(_.value))
+      .withHasClassifiers(classifiers.nonEmpty)
+      .withMavenProfiles(profiles.toVector.sorted)
+      .withScalaOrganization(scalaOrg)
+      .withScalaVersion(scalaVer)
+      .withCredentials(credentials)
+      .withLogger(createLogger)
+      .withCache(cacheDirectory)
+      .withReconciliation(reconciliation.toVector)
+      .withLog(log)
+      .withIvyHome(ivyHome)
+      .withStrict(strict)
+      .withForceVersions(userForceVersions.toVector)
+      .withMissingOk(missingOk)
+  }
+
+  def coursierConfigurationTask: Def.Initialize[Task[CoursierConfiguration]] = Def.task {
+    val sv = scalaVersion.value
+    coursierConfiguration(
+      csrRecursiveResolvers.value,
+      csrInterProjectDependencies.value.toVector,
+      csrExtraProjects.value.toVector,
+      csrFallbackDependencies.value,
+      appConfiguration.value,
+      None,
+      csrMavenProfiles.value,
+      scalaOrganization.value,
+      sv,
+      scalaBinaryVersion.value,
+      autoScalaLibrary.value && !ScalaArtifacts.isScala3(sv),
+      scalaModuleInfo.value,
+      allExcludeDependencies.value,
+      CoursierInputsTasks.credentialsTask.value,
+      csrLogger.value,
+      csrCacheDirectory.value,
+      csrReconciliations.value,
+      ivyPaths.value.ivyHome,
+      CoursierInputsTasks.strictTask.value,
+      dependencyOverrides.value,
+      Some(updateConfiguration.value),
+      streams.value.log
+    )
+  }
+
+  def updateClassifierConfigurationTask: Def.Initialize[Task[CoursierConfiguration]] = Def.task {
+    val sv = scalaVersion.value
+    coursierConfiguration(
+      csrRecursiveResolvers.value,
+      csrInterProjectDependencies.value.toVector,
+      csrExtraProjects.value.toVector,
+      csrFallbackDependencies.value,
+      appConfiguration.value,
+      Some(transitiveClassifiers.value.map(Classifier(_))),
+      csrMavenProfiles.value,
+      scalaOrganization.value,
+      sv,
+      scalaBinaryVersion.value,
+      autoScalaLibrary.value && !ScalaArtifacts.isScala3(sv),
+      scalaModuleInfo.value,
+      allExcludeDependencies.value,
+      CoursierInputsTasks.credentialsTask.value,
+      csrLogger.value,
+      csrCacheDirectory.value,
+      csrReconciliations.value,
+      ivyPaths.value.ivyHome,
+      CoursierInputsTasks.strictTask.value,
+      dependencyOverrides.value,
+      Some(updateConfiguration.value),
+      streams.value.log
+    )
+  }
+
+  def updateSbtClassifierConfigurationTask: Def.Initialize[Task[CoursierConfiguration]] = Def.task {
+    val sv = scalaVersion.value
+    coursierConfiguration(
+      csrSbtResolvers.value,
+      Vector(),
+      Vector(),
+      csrFallbackDependencies.value,
+      appConfiguration.value,
+      None,
+      csrMavenProfiles.value,
+      scalaOrganization.value,
+      sv,
+      scalaBinaryVersion.value,
+      autoScalaLibrary.value && !ScalaArtifacts.isScala3(sv),
+      scalaModuleInfo.value,
+      allExcludeDependencies.value,
+      CoursierInputsTasks.credentialsTask.value,
+      csrLogger.value,
+      csrCacheDirectory.value,
+      csrReconciliations.value,
+      ivyPaths.value.ivyHome,
+      CoursierInputsTasks.strictTask.value,
+      dependencyOverrides.value,
+      Some(updateConfiguration.value),
+      streams.value.log
+    )
+  }
+
+  def scalaCompilerBridgeConfigurationTask: Def.Initialize[Task[CoursierConfiguration]] = Def.task {
+    val sv = scalaVersion.value
+    coursierConfiguration(
+      csrResolvers.value,
+      Vector(),
+      Vector(),
+      csrFallbackDependencies.value,
+      appConfiguration.value,
+      None,
+      csrMavenProfiles.value,
+      scalaOrganization.value,
+      sv,
+      scalaBinaryVersion.value,
+      autoScalaLibrary.value && !ScalaArtifacts.isScala3(sv),
+      scalaModuleInfo.value,
+      allExcludeDependencies.value,
+      CoursierInputsTasks.credentialsTask.value,
+      csrLogger.value,
+      csrCacheDirectory.value,
+      csrReconciliations.value,
+      ivyPaths.value.ivyHome,
+      CoursierInputsTasks.strictTask.value,
+      dependencyOverrides.value,
+      Some(updateConfiguration.value),
+      streams.value.log
+    )
+  }
+
+  def coursierLoggerTask: Def.Initialize[Task[Option[CacheLogger]]] = Def.task {
+    val st = Keys.streams.value
+    val progress = (ThisBuild / useSuperShell).value
+    if (progress) None
+    else Some(new CoursierLogger(st.log))
+  }
+
+  class CoursierLogger(logger: Logger) extends CacheLogger {
+    override def downloadedArtifact(url: String, success: Boolean): Unit =
+      logger.debug(s"downloaded $url")
+  }
+
+  def publicationsSetting(packageConfigs: Seq[(Configuration, CConfiguration)]): Def.Setting[_] = {
+    csrPublications := CoursierArtifactsTasks.coursierPublicationsTask(packageConfigs: _*).value
+  }
+
+  // This emulates Ivy's credential registration which basically keeps mutating global registry
+  def allCredentialsTask: Def.Initialize[Task[Seq[IvyCredentials]]] = Def.task {
+    val st = streams.value
+    def registerCredentials(creds: IvyCredentials): Unit = {
+      (creds match {
+        case dc: DirectCredentials => Right[String, DirectCredentials](dc)
+        case fc: FileCredentials   => IvyCredentials.loadCredentials(fc.path)
+      }) match {
+        case Left(err) => st.log.warn(err)
+        case Right(d) =>
+          credentialRegistry.put((d.host, d.realm), d)
+          ()
+      }
+    }
+    import scala.collection.JavaConverters._
+    (ThisBuild / Keys.credentials).value foreach registerCredentials
+    (LocalRootProject / Keys.credentials).value foreach registerCredentials
+    Keys.credentials.value foreach registerCredentials
+    credentialRegistry.values.asScala.toVector
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/APIMappings.scala b/main/src/main/scala/sbt/internal/APIMappings.scala
index b9e4dfc7c..e07dda236 100644
--- a/main/src/main/scala/sbt/internal/APIMappings.scala
+++ b/main/src/main/scala/sbt/internal/APIMappings.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -17,7 +24,10 @@ private[sbt] object APIMappings {
   def extractFromEntry(entry: Attributed[File], log: Logger): Option[(File, URL)] =
     entry.get(Keys.entryApiURL) match {
       case Some(u) => Some((entry.data, u))
-      case None    => entry.get(Keys.moduleID.key).flatMap { mid => extractFromID(entry.data, mid, log) }
+      case None =>
+        entry.get(Keys.moduleID.key).flatMap { mid =>
+          extractFromID(entry.data, mid, log)
+        }
     }
 
   private[this] def extractFromID(entry: File, mid: ModuleID, log: Logger): Option[(File, URL)] =
@@ -27,7 +37,8 @@ private[sbt] object APIMappings {
     } yield (entry, u)
 
   private[this] def parseURL(s: String, forEntry: File, log: Logger): Option[URL] =
-    try Some(new URL(s)) catch {
+    try Some(new URL(s))
+    catch {
       case e: MalformedURLException =>
         log.warn(s"Invalid API base URL '$s' for classpath entry '$forEntry': ${e.toString}")
         None
diff --git a/main/src/main/scala/sbt/internal/AbstractTaskProgress.scala b/main/src/main/scala/sbt/internal/AbstractTaskProgress.scala
new file mode 100644
index 000000000..dfac9b2e5
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/AbstractTaskProgress.scala
@@ -0,0 +1,136 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicLong
+import scala.collection.JavaConverters._
+import scala.collection.mutable
+import scala.collection.immutable.VectorBuilder
+import scala.concurrent.duration._
+
+private[sbt] abstract class AbstractTaskExecuteProgress extends ExecuteProgress[Task] {
+  import AbstractTaskExecuteProgress.Timer
+
+  private[this] val showScopedKey = Def.showShortKey(None)
+  private[this] val anonOwners = new ConcurrentHashMap[Task[_], Task[_]]
+  private[this] val calledBy = new ConcurrentHashMap[Task[_], Task[_]]
+  private[this] val timings = new ConcurrentHashMap[Task[_], Timer]
+  private[sbt] def timingsByName: mutable.Map[String, AtomicLong] = {
+    val result = new ConcurrentHashMap[String, AtomicLong]
+    timings.forEach { (task, timing) =>
+      val duration = timing.durationNanos
+      result.putIfAbsent(taskName(task), new AtomicLong(duration)) match {
+        case null =>
+        case t    => t.getAndAdd(duration); ()
+      }
+    }
+    result.asScala
+  }
+  private[sbt] def anyTimings = !timings.isEmpty
+  def currentTimings: Iterator[(Task[_], Timer)] = timings.asScala.iterator
+
+  private[internal] def exceededThreshold(task: Task[_], threshold: FiniteDuration): Boolean =
+    timings.get(task) match {
+      case null => false
+      case t    => t.durationMicros > threshold.toMicros
+    }
+  private[internal] def timings(
+      tasks: java.util.Set[Task[_]],
+      thresholdMicros: Long
+  ): Vector[(Task[_], Long)] = {
+    val result = new VectorBuilder[(Task[_], Long)]
+    val now = System.nanoTime
+    tasks.forEach { t =>
+      timings.get(t) match {
+        case null =>
+        case timing =>
+          if (timing.isActive) {
+            val elapsed = (now - timing.startNanos) / 1000
+            if (elapsed > thresholdMicros) result += t -> elapsed
+          }
+      }
+    }
+    result.result()
+  }
+  def activeTasks(now: Long) = {
+    val result = new VectorBuilder[(Task[_], FiniteDuration)]
+    timings.forEach { (task, timing) =>
+      if (timing.isActive) result += task -> (now - timing.startNanos).nanos
+    }
+    result.result
+  }
+
+  override def afterRegistered(
+      task: Task[_],
+      allDeps: Iterable[Task[_]],
+      pendingDeps: Iterable[Task[_]]
+  ): Unit = {
+    // we need this to infer anonymous task names
+    pendingDeps foreach { t =>
+      if (TaskName.transformNode(t).isEmpty) {
+        anonOwners.put(t, task)
+      }
+    }
+  }
+
+  override def beforeWork(task: Task[_]): Unit = {
+    timings.put(task, new Timer)
+    ()
+  }
+
+  protected def clearTimings: Boolean = false
+  override def afterWork[A](task: Task[A], result: Either[Task[A], Result[A]]): Unit = {
+    if (clearTimings) timings.remove(task)
+    else
+      timings.get(task) match {
+        case null =>
+        case t    => t.stop()
+      }
+
+    // we need this to infer anonymous task names
+    result.left.foreach { t =>
+      calledBy.put(t, task)
+    }
+  }
+
+  private[this] val taskNameCache = new ConcurrentHashMap[Task[_], String]
+  protected def taskName(t: Task[_]): String = taskNameCache.get(t) match {
+    case null =>
+      val name = taskName0(t)
+      taskNameCache.putIfAbsent(t, name)
+      name
+    case name => name
+  }
+  private[this] def taskName0(t: Task[_]): String = {
+    def definedName(node: Task[_]): Option[String] =
+      node.info.name orElse TaskName.transformNode(node).map(showScopedKey.show)
+    def inferredName(t: Task[_]): Option[String] = nameDelegate(t) map taskName
+    def nameDelegate(t: Task[_]): Option[Task[_]] =
+      Option(anonOwners.get(t)) orElse Option(calledBy.get(t))
+    definedName(t) orElse inferredName(t) getOrElse TaskName.anonymousName(t)
+  }
+}
+
+object AbstractTaskExecuteProgress {
+  private[sbt] class Timer() {
+    val startNanos: Long = System.nanoTime()
+    val threadId: Long = Thread.currentThread().getId
+    var endNanos: Long = 0L
+    def stop(): Unit = {
+      endNanos = System.nanoTime()
+    }
+    def isActive = endNanos == 0L
+    def durationNanos: Long = endNanos - startNanos
+    def startMicros: Long = (startNanos.toDouble / 1000).toLong
+    def durationMicros: Long = (durationNanos.toDouble / 1000).toLong
+    def currentElapsedMicros: Long =
+      ((System.nanoTime() - startNanos).toDouble / 1000).toLong
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/Act.scala b/main/src/main/scala/sbt/internal/Act.scala
index f3da90b61..ce7a45639 100644
--- a/main/src/main/scala/sbt/internal/Act.scala
+++ b/main/src/main/scala/sbt/internal/Act.scala
@@ -1,75 +1,184 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
-import Def.{ showRelativeKey, ScopedKey }
+import Def.{ showRelativeKey2, ScopedKey }
 import Keys.sessionSettings
 import sbt.internal.util.complete.{ DefaultParsers, Parser }
 import Aggregation.{ KeyValue, Values }
 import DefaultParsers._
 import sbt.internal.util.Types.idFun
 import java.net.URI
-import sbt.internal.CommandStrings.{ MultiTaskCommand, ShowCommand }
-import sbt.internal.util.{ AttributeEntry, AttributeKey, AttributeMap, IMap, Settings, Show, Util }
+import sbt.internal.CommandStrings.{ MultiTaskCommand, ShowCommand, PrintCommand }
+import sbt.internal.util.{ AttributeEntry, AttributeKey, AttributeMap, IMap, Settings, Util }
+import sbt.util.Show
+import scala.collection.mutable
 
-final class ParsedKey(val key: ScopedKey[_], val mask: ScopeMask)
+final class ParsedKey(val key: ScopedKey[_], val mask: ScopeMask, val separaters: Seq[String]) {
+  def this(key: ScopedKey[_], mask: ScopeMask) = this(key, mask, Nil)
+
+  override def equals(o: Any): Boolean =
+    this.eq(o.asInstanceOf[AnyRef]) || (o match {
+      case x: ParsedKey => (this.key == x.key) && (this.mask == x.mask)
+      case _            => false
+    })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.ParsedKey".##) + this.key.##)) + this.mask.##
+  }
+}
 
 object Act {
-  val GlobalString = "*"
+  val ZeroString = "*"
+  private[sbt] val GlobalIdent = "Global"
+  private[sbt] val ZeroIdent = "Zero"
+  private[sbt] val ThisBuildIdent = "ThisBuild"
+
+  // new separator for unified shell syntax. this allows optional whitespace around /.
+  private[sbt] val spacedSlash: Parser[Unit] =
+    token(OptSpace ~> '/' <~ OptSpace).examples("/").map(_ => ())
+
+  private[sbt] val slashSeq: Seq[String] = Seq("/")
+  private[sbt] val colonSeq: Seq[String] = Seq(":")
+  private[sbt] val colonColonSeq: Seq[String] = Seq("::")
 
   // this does not take aggregation into account
-  def scopedKey(index: KeyIndex, current: ProjectRef, defaultConfigs: Option[ResolvedReference] => Seq[String],
-    keyMap: Map[String, AttributeKey[_]], data: Settings[Scope]): Parser[ScopedKey[_]] =
+  def scopedKey(
+      index: KeyIndex,
+      current: ProjectRef,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      keyMap: Map[String, AttributeKey[_]],
+      data: Settings[Scope]
+  ): Parser[ScopedKey[_]] =
     scopedKeySelected(index, current, defaultConfigs, keyMap, data).map(_.key)
 
   // the index should be an aggregated index for proper tab completion
-  def scopedKeyAggregated(current: ProjectRef, defaultConfigs: Option[ResolvedReference] => Seq[String], structure: BuildStructure): KeysParser =
-    for (selected <- scopedKeySelected(structure.index.aggregateKeyIndex, current, defaultConfigs, structure.index.keyMap, structure.data)) yield Aggregation.aggregate(selected.key, selected.mask, structure.extra)
+  def scopedKeyAggregated(
+      current: ProjectRef,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      structure: BuildStructure
+  ): KeysParser =
+    for (selected <- scopedKeySelected(
+           structure.index.aggregateKeyIndex,
+           current,
+           defaultConfigs,
+           structure.index.keyMap,
+           structure.data
+         ))
+      yield Aggregation.aggregate(selected.key, selected.mask, structure.extra)
 
-  def scopedKeySelected(index: KeyIndex, current: ProjectRef, defaultConfigs: Option[ResolvedReference] => Seq[String],
-    keyMap: Map[String, AttributeKey[_]], data: Settings[Scope]): Parser[ParsedKey] =
+  def scopedKeyAggregatedSep(
+      current: ProjectRef,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      structure: BuildStructure
+  ): KeysParserSep =
+    for (selected <- scopedKeySelected(
+           structure.index.aggregateKeyIndex,
+           current,
+           defaultConfigs,
+           structure.index.keyMap,
+           structure.data
+         ))
+      yield Aggregation
+        .aggregate(selected.key, selected.mask, structure.extra)
+        .map(k => k -> selected.separaters)
+
+  def scopedKeySelected(
+      index: KeyIndex,
+      current: ProjectRef,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      keyMap: Map[String, AttributeKey[_]],
+      data: Settings[Scope]
+  ): Parser[ParsedKey] =
     scopedKeyFull(index, current, defaultConfigs, keyMap) flatMap { choices =>
-      select(choices, data)(showRelativeKey(current, index.buildURIs.size > 1))
+      select(choices, data)(showRelativeKey2(current))
     }
 
-  def scopedKeyFull(index: KeyIndex, current: ProjectRef, defaultConfigs: Option[ResolvedReference] => Seq[String], keyMap: Map[String, AttributeKey[_]]): Parser[Seq[Parser[ParsedKey]]] =
-    {
-      def taskKeyExtra(proj: Option[ResolvedReference], confAmb: ParsedAxis[String], baseMask: ScopeMask): Seq[Parser[ParsedKey]] =
-        for {
-          conf <- configs(confAmb, defaultConfigs, proj, index)
-        } yield for {
-          taskAmb <- taskAxis(conf, index.tasks(proj, conf), keyMap)
-          task = resolveTask(taskAmb)
-          key <- key(index, proj, conf, task, keyMap)
-          extra <- extraAxis(keyMap, IMap.empty)
-        } yield {
-          val mask = baseMask.copy(task = taskAmb.isExplicit, extra = true)
-          new ParsedKey(makeScopedKey(proj, conf, task, extra, key), mask)
-        }
+  def scopedKeyFull(
+      index: KeyIndex,
+      current: ProjectRef,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      keyMap: Map[String, AttributeKey[_]]
+  ): Parser[Seq[Parser[ParsedKey]]] = {
+    val confParserCache
+        : mutable.Map[Option[sbt.ResolvedReference], Parser[(ParsedAxis[String], Seq[String])]] =
+      mutable.Map.empty
+    def fullKey =
+      for {
+        rawProject <- optProjectRef(index, current)
+        proj = resolveProject(rawProject, current)
+        confPair <- confParserCache.getOrElseUpdate(
+          proj,
+          configIdent(
+            index.configs(proj),
+            index.configIdents(proj),
+            index.fromConfigIdent(proj)
+          )
+        )
+        (confAmb, seps) = confPair
+        partialMask = ScopeMask(rawProject.isExplicit, confAmb.isExplicit, false, false)
+      } yield taskKeyExtra(index, defaultConfigs, keyMap, proj, confAmb, partialMask, seps)
 
-      val projectKeys =
-        for {
-          rawProject <- optProjectRef(index, current)
-          proj = resolveProject(rawProject, current)
-          confAmb <- config(index configs proj)
-          partialMask = ScopeMask(rawProject.isExplicit, confAmb.isExplicit, false, false)
-        } yield taskKeyExtra(proj, confAmb, partialMask)
+    val globalIdent = token(GlobalIdent ~ spacedSlash) ^^^ ParsedGlobal
+    def globalKey =
+      for {
+        g <- globalIdent
+      } yield taskKeyExtra(
+        index,
+        defaultConfigs,
+        keyMap,
+        None,
+        ParsedZero,
+        ScopeMask(true, true, false, false),
+        Nil
+      )
 
-      val build = Some(BuildRef(current.build))
-      val buildKeys =
-        for {
-          confAmb <- config(index configs build)
-          partialMask = ScopeMask(false, confAmb.isExplicit, false, false)
-        } yield taskKeyExtra(build, confAmb, partialMask)
+    globalKey | fullKey
+  }
 
-      buildKeys combinedWith projectKeys map (_.flatten)
+  def taskKeyExtra(
+      index: KeyIndex,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      keyMap: Map[String, AttributeKey[_]],
+      proj: Option[ResolvedReference],
+      confAmb: ParsedAxis[String],
+      baseMask: ScopeMask,
+      baseSeps: Seq[String]
+  ): Seq[Parser[ParsedKey]] =
+    for {
+      conf <- configs(confAmb, defaultConfigs, proj, index)
+    } yield for {
+      taskPair <- taskAxis(index.tasks(proj, conf), keyMap)
+      (taskAmb, taskSeps) = taskPair
+      task = resolveTask(taskAmb)
+      key <- key(index, proj, conf, task, keyMap)
+      extra <- extraAxis(keyMap, IMap.empty)
+    } yield {
+      val mask = baseMask.copy(task = taskAmb.isExplicit, extra = true)
+      val seps = baseSeps ++ taskSeps
+      new ParsedKey(makeScopedKey(proj, conf, task, extra, key), mask, seps)
     }
-  def makeScopedKey(proj: Option[ResolvedReference], conf: Option[String], task: Option[AttributeKey[_]], extra: ScopeAxis[AttributeMap], key: AttributeKey[_]): ScopedKey[_] =
-    ScopedKey(Scope(toAxis(proj, Global), toAxis(conf map ConfigKey.apply, Global), toAxis(task, Global), extra), key)
 
-  def select(allKeys: Seq[Parser[ParsedKey]], data: Settings[Scope])(implicit show: Show[ScopedKey[_]]): Parser[ParsedKey] =
+  def makeScopedKey(
+      proj: Option[ResolvedReference],
+      conf: Option[String],
+      task: Option[AttributeKey[_]],
+      extra: ScopeAxis[AttributeMap],
+      key: AttributeKey[_]
+  ): ScopedKey[_] =
+    ScopedKey(
+      Scope(toAxis(proj, Zero), toAxis(conf map ConfigKey.apply, Zero), toAxis(task, Zero), extra),
+      key
+    )
+
+  def select(allKeys: Seq[Parser[ParsedKey]], data: Settings[Scope])(
+      implicit show: Show[ScopedKey[_]]
+  ): Parser[ParsedKey] =
     seq(allKeys) flatMap { ss =>
       val default = ss.headOption match {
         case None    => noValidKeys
@@ -77,17 +186,14 @@ object Act {
       }
       selectFromValid(ss filter isValid(data), default)
     }
-  def selectFromValid(ss: Seq[ParsedKey], default: Parser[ParsedKey])(implicit show: Show[ScopedKey[_]]): Parser[ParsedKey] =
-    selectByTask(selectByConfig(ss)) partition isBuildKey match {
-      case (_, Seq(single))         => success(single)
-      case (Seq(single), Seq())     => success(single)
-      case (Seq(), Seq())           => default
-      case (buildKeys, projectKeys) => failure("Ambiguous keys: " + showAmbiguous(keys(buildKeys ++ projectKeys)))
+  def selectFromValid(ss: Seq[ParsedKey], default: Parser[ParsedKey])(
+      implicit show: Show[ScopedKey[_]]
+  ): Parser[ParsedKey] =
+    selectByTask(selectByConfig(ss)) match {
+      case Seq()       => default
+      case Seq(single) => success(single)
+      case multi       => failure("Ambiguous keys: " + showAmbiguous(keys(multi)))
     }
-  private def isBuildKey(parsed: ParsedKey): Boolean = parsed.key.scope.project match {
-    case Select(_: BuildReference) => true
-    case _                         => false
-  }
   private[this] def keys(ss: Seq[ParsedKey]): Seq[ScopedKey[_]] = ss.map(_.key)
   def selectByConfig(ss: Seq[ParsedKey]): Seq[ParsedKey] =
     ss match {
@@ -98,61 +204,115 @@ object Act {
           case xs    => x +: xs
         }
     }
-  def selectByTask(ss: Seq[ParsedKey]): Seq[ParsedKey] =
-    {
-      val (selects, globals) = ss.partition(_.key.scope.task.isSelect)
-      if (globals.nonEmpty) globals else selects
-    }
+  def selectByTask(ss: Seq[ParsedKey]): Seq[ParsedKey] = {
+    val (selects, zeros) = ss.partition(_.key.scope.task.isSelect)
+    if (zeros.nonEmpty) zeros else selects
+  }
 
   def noValidKeys = failure("No such key.")
 
   def showAmbiguous(keys: Seq[ScopedKey[_]])(implicit show: Show[ScopedKey[_]]): String =
-    keys.take(3).map(x => show(x)).mkString("", ", ", if (keys.size > 3) ", ..." else "")
+    keys.take(3).map(x => show.show(x)).mkString("", ", ", if (keys.size > 3) ", ..." else "")
 
-  def isValid(data: Settings[Scope])(parsed: ParsedKey): Boolean =
-    {
-      val key = parsed.key
-      data.definingScope(key.scope, key.key) == Some(key.scope)
-    }
+  def isValid(data: Settings[Scope])(parsed: ParsedKey): Boolean = {
+    val key = parsed.key
+    data.definingScope(key.scope, key.key) == Some(key.scope)
+  }
 
   def examples(p: Parser[String], exs: Set[String], label: String): Parser[String] =
     p !!! ("Expected " + label) examples exs
+
   def examplesStrict(p: Parser[String], exs: Set[String], label: String): Parser[String] =
     filterStrings(examples(p, exs, label), exs, label)
 
   def optionalAxis[T](p: Parser[T], ifNone: ScopeAxis[T]): Parser[ScopeAxis[T]] =
-    p.? map { opt => toAxis(opt, ifNone) }
+    p.? map { opt =>
+      toAxis(opt, ifNone)
+    }
+
   def toAxis[T](opt: Option[T], ifNone: ScopeAxis[T]): ScopeAxis[T] =
     opt match { case Some(t) => Select(t); case None => ifNone }
 
-  def config(confs: Set[String]): Parser[ParsedAxis[String]] =
-    {
-      val sep = ':' !!! "Expected ':' (if selecting a configuration)"
-      token((GlobalString ^^^ ParsedGlobal | value(examples(ID, confs, "configuration"))) <~ sep) ?? Omitted
-    }
+  def config(confs: Set[String]): Parser[ParsedAxis[String]] = {
+    val sep = ':' !!! "Expected ':' (if selecting a configuration)"
+    token((ZeroString ^^^ ParsedZero | value(examples(ID, confs, "configuration"))) <~ sep) ?? Omitted
+  }
 
-  def configs(explicit: ParsedAxis[String], defaultConfigs: Option[ResolvedReference] => Seq[String], proj: Option[ResolvedReference], index: KeyIndex): Seq[Option[String]] =
+  // New configuration parser that's able to parse configuration ident trailed by slash.
+  private[sbt] def configIdent(
+      confs: Set[String],
+      idents: Set[String],
+      fromIdent: String => String
+  ): Parser[(ParsedAxis[String], Seq[String])] = {
+    val oldSep: Parser[Char] = ':'
+    val sep: Parser[Unit] = spacedSlash !!! "Expected '/'"
+    token(
+      ((ZeroString ^^^ (ParsedZero -> colonSeq)) <~ oldSep)
+        | ((ZeroString ^^^ (ParsedZero -> slashSeq)) <~ sep)
+        | ((ZeroIdent ^^^ (ParsedZero -> slashSeq)) <~ sep)
+        | (value(examples(ID, confs, "configuration")).map(_ -> colonSeq) <~ oldSep)
+        | (value(examples(CapitalizedID, idents, "configuration ident").map(fromIdent))
+          .map(_ -> slashSeq) <~ sep)
+    ) ?? (Omitted -> Nil)
+  }
+
+  def configs(
+      explicit: ParsedAxis[String],
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      proj: Option[ResolvedReference],
+      index: KeyIndex
+  ): Seq[Option[String]] =
     explicit match {
-      case Omitted            => None +: defaultConfigurations(proj, index, defaultConfigs).flatMap(nonEmptyConfig(index, proj))
-      case ParsedGlobal       => None :: Nil
-      case pv: ParsedValue[x] => Some(pv.value) :: Nil
+      case Omitted =>
+        None +: defaultConfigurations(proj, index, defaultConfigs).flatMap(
+          nonEmptyConfig(index, proj)
+        )
+      case ParsedZero | ParsedGlobal => None :: Nil
+      case pv: ParsedValue[x]        => Some(pv.value) :: Nil
     }
-  def defaultConfigurations(proj: Option[ResolvedReference], index: KeyIndex, defaultConfigs: Option[ResolvedReference] => Seq[String]): Seq[String] =
+
+  def defaultConfigurations(
+      proj: Option[ResolvedReference],
+      index: KeyIndex,
+      defaultConfigs: Option[ResolvedReference] => Seq[String]
+  ): Seq[String] =
     if (index exists proj) defaultConfigs(proj) else Nil
-  def nonEmptyConfig(index: KeyIndex, proj: Option[ResolvedReference]): String => Seq[Option[String]] = config =>
-    if (index.isEmpty(proj, Some(config))) Nil else Some(config) :: Nil
 
-  def key(index: KeyIndex, proj: Option[ResolvedReference], conf: Option[String], task: Option[AttributeKey[_]], keyMap: Map[String, AttributeKey[_]]): Parser[AttributeKey[_]] =
-    {
-      def dropHyphenated(keys: Set[String]): Set[String] = keys.filterNot(Util.hasHyphen)
-      def keyParser(keys: Set[String]): Parser[AttributeKey[_]] =
-        token(ID !!! "Expected key" examples dropHyphenated(keys)) flatMap { keyString =>
-          getKey(keyMap, keyString, idFun)
-        }
-      keyParser(index.keys(proj, conf, task))
-    }
+  def nonEmptyConfig(
+      index: KeyIndex,
+      proj: Option[ResolvedReference]
+  ): String => Seq[Option[String]] =
+    config => if (index.isEmpty(proj, Some(config))) Nil else Some(config) :: Nil
 
-  def getKey[T](keyMap: Map[String, AttributeKey[_]], keyString: String, f: AttributeKey[_] => T): Parser[T] =
+  def key(
+      index: KeyIndex,
+      proj: Option[ResolvedReference],
+      conf: Option[String],
+      task: Option[AttributeKey[_]],
+      keyMap: Map[String, AttributeKey[_]]
+  ): Parser[AttributeKey[_]] = {
+    def dropHyphenated(keys: Set[String]): Set[String] = keys.filterNot(Util.hasHyphen)
+    def keyParser(keys: Set[String]): Parser[AttributeKey[_]] =
+      token(ID !!! "Expected key" examples dropHyphenated(keys)) flatMap { keyString =>
+        getKey(keyMap, keyString, idFun)
+      }
+    // Fixes sbt/sbt#2460 and sbt/sbt#2851
+    // The parser already accepts build-level keys.
+    // This queries the key index so tab completion will list the build-level keys.
+    val buildKeys: Set[String] =
+      proj match {
+        case Some(ProjectRef(uri, _)) => index.keys(Some(BuildRef(uri)), conf, task)
+        case _                        => Set()
+      }
+    val keys: Set[String] = index.keys(proj, conf, task) ++ buildKeys
+    keyParser(keys)
+  }
+
+  def getKey[T](
+      keyMap: Map[String, AttributeKey[_]],
+      keyString: String,
+      f: AttributeKey[_] => T
+  ): Parser[T] =
     keyMap.get(keyString) match {
       case Some(k) => success(f(k))
       case None    => failure(Command.invalidValue("key", keyMap.keys)(keyString))
@@ -160,50 +320,72 @@ object Act {
 
   val spacedComma = token(OptSpace ~ ',' ~ OptSpace)
 
-  def extraAxis(knownKeys: Map[String, AttributeKey[_]], knownValues: IMap[AttributeKey, Set]): Parser[ScopeAxis[AttributeMap]] =
-    {
-      val extrasP = extrasParser(knownKeys, knownValues)
-      val extras = token('(', hide = _ == 1 && knownValues.isEmpty) ~> extrasP <~ token(')')
-      optionalAxis(extras, Global)
-    }
+  def extraAxis(
+      knownKeys: Map[String, AttributeKey[_]],
+      knownValues: IMap[AttributeKey, Set]
+  ): Parser[ScopeAxis[AttributeMap]] = {
+    val extrasP = extrasParser(knownKeys, knownValues)
+    val extras = token('(', hide = _ == 1 && knownValues.isEmpty) ~> extrasP <~ token(')')
+    optionalAxis(extras, Zero)
+  }
+
+  def taskAxis(
+      tasks: Set[AttributeKey[_]],
+      allKnown: Map[String, AttributeKey[_]],
+  ): Parser[(ParsedAxis[AttributeKey[_]], Seq[String])] = {
+    val taskSeq = tasks.toSeq
+    def taskKeys(f: AttributeKey[_] => String): Seq[(String, AttributeKey[_])] =
+      taskSeq.map(key => (f(key), key))
+    val normKeys = taskKeys(_.label)
+    val valid = allKnown ++ normKeys
+    val suggested = normKeys.map(_._1).toSet
+    val keyP = filterStrings(examples(ID, suggested, "key"), valid.keySet, "key") map valid
+
+    ((token(
+      value(keyP).map(_ -> slashSeq)
+        | ZeroString ^^^ (ParsedZero -> slashSeq)
+        | ZeroIdent ^^^ (ParsedZero -> slashSeq)
+    ) <~ spacedSlash) |
+      (token(
+        value(keyP).map(_ -> colonColonSeq)
+          | ZeroString ^^^ (ParsedZero -> colonColonSeq)
+          | ZeroIdent ^^^ (ParsedZero -> colonColonSeq)
+      ) <~ token("::".id))) ?? (Omitted -> Nil)
+  }
 
-  def taskAxis(d: Option[String], tasks: Set[AttributeKey[_]], allKnown: Map[String, AttributeKey[_]]): Parser[ParsedAxis[AttributeKey[_]]] =
-    {
-      val taskSeq = tasks.toSeq
-      def taskKeys(f: AttributeKey[_] => String): Seq[(String, AttributeKey[_])] = taskSeq.map(key => (f(key), key))
-      val normKeys = taskKeys(_.label)
-      val valid = allKnown ++ normKeys
-      val suggested = normKeys.map(_._1).toSet
-      val keyP = filterStrings(examples(ID, suggested, "key"), valid.keySet, "key") map valid
-      (token(value(keyP) | GlobalString ^^^ ParsedGlobal) <~ token("::".id)) ?? Omitted
-    }
   def resolveTask(task: ParsedAxis[AttributeKey[_]]): Option[AttributeKey[_]] =
     task match {
-      case ParsedGlobal | Omitted                     => None
+      case ParsedZero | ParsedGlobal | Omitted        => None
       case t: ParsedValue[AttributeKey[_]] @unchecked => Some(t.value)
     }
 
   def filterStrings(base: Parser[String], valid: Set[String], label: String): Parser[String] =
     base.filter(valid, Command.invalidValue(label, valid))
 
-  def extrasParser(knownKeys: Map[String, AttributeKey[_]], knownValues: IMap[AttributeKey, Set]): Parser[AttributeMap] =
-    {
-      val validKeys = knownKeys.filter { case (_, key) => knownValues get key exists (_.nonEmpty) }
-      if (validKeys.isEmpty)
-        failure("No valid extra keys.")
-      else
-        rep1sep(extraParser(validKeys, knownValues), spacedComma) map AttributeMap.apply
-    }
+  def extrasParser(
+      knownKeys: Map[String, AttributeKey[_]],
+      knownValues: IMap[AttributeKey, Set]
+  ): Parser[AttributeMap] = {
+    val validKeys = knownKeys.filter { case (_, key) => knownValues get key exists (_.nonEmpty) }
+    if (validKeys.isEmpty)
+      failure("No valid extra keys.")
+    else
+      rep1sep(extraParser(validKeys, knownValues), spacedComma) map AttributeMap.apply
+  }
 
-  def extraParser(knownKeys: Map[String, AttributeKey[_]], knownValues: IMap[AttributeKey, Set]): Parser[AttributeEntry[_]] =
-    {
-      val keyp = knownIDParser(knownKeys, "Not a valid extra key") <~ token(':' ~ OptSpace)
-      keyp flatMap {
-        case key: AttributeKey[t] =>
-          val valueMap: Map[String, t] = knownValues(key).map(v => (v.toString, v)).toMap
-          knownIDParser(valueMap, "extra value") map { value => AttributeEntry(key, value) }
-      }
+  def extraParser(
+      knownKeys: Map[String, AttributeKey[_]],
+      knownValues: IMap[AttributeKey, Set]
+  ): Parser[AttributeEntry[_]] = {
+    val keyp = knownIDParser(knownKeys, "Not a valid extra key") <~ token(':' ~ OptSpace)
+    keyp flatMap {
+      case key: AttributeKey[t] =>
+        val valueMap: Map[String, t] = knownValues(key).map(v => (v.toString, v)).toMap
+        knownIDParser(valueMap, "extra value") map { value =>
+          AttributeEntry(key, value)
+        }
     }
+  }
   def knownIDParser[T](knownKeys: Map[String, T], label: String): Parser[T] =
     token(examplesStrict(ID, knownKeys.keys.toSet, label)) map knownKeys
 
@@ -212,99 +394,187 @@ object Act {
     token(examplesStrict(pluginLabelParser, knownPlugins.keys.toSet, label)) map knownPlugins
   }
 
-  def projectRef(index: KeyIndex, currentBuild: URI): Parser[ParsedAxis[ResolvedReference]] =
-    {
-      val global = token(GlobalString ~ '/') ^^^ ParsedGlobal
-      val trailing = '/' !!! "Expected '/' (if selecting a project)"
-      global | value(resolvedReference(index, currentBuild, trailing))
-    }
-  def resolvedReference(index: KeyIndex, currentBuild: URI, trailing: Parser[_]): Parser[ResolvedReference] =
-    {
-      def projectID(uri: URI) = token(examplesStrict(ID, index projects uri, "project ID") <~ trailing)
-      def projectRef(uri: URI) = projectID(uri) map { id => ProjectRef(uri, id) }
+  def projectRef(index: KeyIndex, currentBuild: URI): Parser[ParsedAxis[ResolvedReference]] = {
+    val global = token(ZeroString ~ spacedSlash) ^^^ ParsedZero
+    val zeroIdent = token(ZeroIdent ~ spacedSlash) ^^^ ParsedZero
+    val thisBuildIdent = value(token(ThisBuildIdent ~ spacedSlash) ^^^ BuildRef(currentBuild))
+    val trailing = spacedSlash !!! "Expected '/' (if selecting a project)"
+    global | zeroIdent | thisBuildIdent |
+      value(resolvedReferenceIdent(index, currentBuild, trailing)) |
+      value(resolvedReference(index, currentBuild, trailing))
+  }
 
-      val uris = index.buildURIs
-      val resolvedURI = Uri(uris).map(uri => Scope.resolveBuild(currentBuild, uri))
-      val buildRef = token('{' ~> resolvedURI <~ '}').?
-
-      buildRef flatMap {
-        case None      => projectRef(currentBuild)
-        case Some(uri) => projectRef(uri) | token(trailing ^^^ BuildRef(uri))
-      }
+  private[sbt] def resolvedReferenceIdent(
+      index: KeyIndex,
+      currentBuild: URI,
+      trailing: Parser[_]
+  ): Parser[ResolvedReference] = {
+    def projectID(uri: URI) =
+      token(
+        DQuoteChar ~> examplesStrict(ID, index projects uri, "project ID") <~ DQuoteChar <~ OptSpace <~ ")" <~ trailing
+      )
+    def projectRef(uri: URI) = projectID(uri) map { id =>
+      ProjectRef(uri, id)
     }
+
+    val uris = index.buildURIs
+    val resolvedURI = Uri(uris).map(uri => Scope.resolveBuild(currentBuild, uri))
+
+    val buildRef = token(
+      "ProjectRef(" ~> OptSpace ~> "uri(" ~> OptSpace ~> DQuoteChar ~>
+        resolvedURI <~ DQuoteChar <~ OptSpace <~ ")" <~ spacedComma
+    )
+    buildRef flatMap { uri =>
+      projectRef(uri)
+    }
+  }
+
+  def resolvedReference(
+      index: KeyIndex,
+      currentBuild: URI,
+      trailing: Parser[_]
+  ): Parser[ResolvedReference] = {
+    def projectID(uri: URI) =
+      token(examplesStrict(ID, index projects uri, "project ID") <~ trailing)
+    def projectRef(uri: URI) = projectID(uri) map { id =>
+      ProjectRef(uri, id)
+    }
+
+    val uris = index.buildURIs
+    val resolvedURI = Uri(uris).map(uri => Scope.resolveBuild(currentBuild, uri))
+    val buildRef = token('{' ~> resolvedURI <~ '}').?
+
+    buildRef flatMap {
+      case None      => projectRef(currentBuild)
+      case Some(uri) => projectRef(uri) | token(trailing ^^^ BuildRef(uri))
+    }
+  }
   def optProjectRef(index: KeyIndex, current: ProjectRef): Parser[ParsedAxis[ResolvedReference]] =
     projectRef(index, current.build) ?? Omitted
-  def resolveProject(parsed: ParsedAxis[ResolvedReference], current: ProjectRef): Option[ResolvedReference] =
+
+  def resolveProject(
+      parsed: ParsedAxis[ResolvedReference],
+      current: ProjectRef
+  ): Option[ResolvedReference] =
     parsed match {
       case Omitted             => Some(current)
+      case ParsedZero          => None
       case ParsedGlobal        => None
       case pv: ParsedValue[rr] => Some(pv.value)
     }
 
   def actParser(s: State): Parser[() => State] = requireSession(s, actParser0(s))
 
-  private[this] def actParser0(state: State): Parser[() => State] =
-    {
-      val extracted = Project extract state
-      import extracted.{ showKey, structure }
-      import Aggregation.evaluatingParser
-      actionParser.flatMap { action =>
-        val akp = aggregatedKeyParser(extracted)
-        def evaluate(kvs: Seq[ScopedKey[_]]): Parser[() => State] = {
-          val preparedPairs = anyKeyValues(structure, kvs)
-          val showConfig = Aggregation.defaultShow(state, showTasks = action == ShowAction)
-          evaluatingParser(state, structure, showConfig)(preparedPairs) map { evaluate =>
-            () => {
-              val keyStrings = preparedPairs.map(pp => showKey(pp.key)).mkString(", ")
-              state.log.debug("Evaluating tasks: " + keyStrings)
-              evaluate()
-            }
+  private[this] def actParser0(state: State): Parser[() => State] = {
+    val extracted = Project extract state
+    import extracted.{ showKey, structure }
+    import Aggregation.evaluatingParser
+    actionParser.flatMap { action =>
+      val akp = aggregatedKeyParserSep(extracted)
+      def warnOldShellSyntax(seps: Seq[String], keyStrings: String): Unit =
+        if (seps.contains(":") || seps.contains("::")) {
+          state.log.warn(
+            s"sbt 0.13 shell syntax is deprecated; use slash syntax instead: $keyStrings"
+          )
+        } else ()
+      def evaluate(pairs: Seq[(ScopedKey[_], Seq[String])]): Parser[() => State] = {
+        val kvs = pairs.map(_._1)
+        val seps = pairs.headOption.map(_._2).getOrElse(Nil)
+        val preparedPairs = anyKeyValues(structure, kvs)
+        val showConfig = if (action == PrintAction) {
+          Aggregation.ShowConfig(true, true, println, false)
+        } else {
+          Aggregation.defaultShow(state, showTasks = action == ShowAction)
+        }
+        evaluatingParser(state, showConfig)(preparedPairs) map { evaluate => () =>
+          {
+            val keyStrings = preparedPairs.map(pp => showKey.show(pp.key)).mkString(", ")
+            state.log.debug("Evaluating tasks: " + keyStrings)
+            warnOldShellSyntax(seps, keyStrings)
+            evaluate()
           }
         }
-        action match {
-          case SingleAction => akp flatMap evaluate
-          case ShowAction | MultiAction =>
-            rep1sep(akp, token(Space)).flatMap(kvss => evaluate(kvss.flatten))
-        }
+      }
+      action match {
+        case SingleAction => akp flatMap evaluate
+        case ShowAction | PrintAction | MultiAction =>
+          rep1sep(akp, token(Space)) flatMap { pairs =>
+            val flat: mutable.ListBuffer[(ScopedKey[_], Seq[String])] = mutable.ListBuffer.empty
+            pairs foreach { xs =>
+              flat ++= xs
+            }
+            evaluate(flat.toList)
+          }
       }
     }
+  }
 
   private[this] final class ActAction
-  private[this] final val ShowAction, MultiAction, SingleAction = new ActAction
+  private[this] final val ShowAction, MultiAction, SingleAction, PrintAction = new ActAction
 
   private[this] def actionParser: Parser[ActAction] =
     token(
       ((ShowCommand ^^^ ShowAction) |
+        (PrintCommand ^^^ PrintAction) |
         (MultiTaskCommand ^^^ MultiAction)) <~ Space
     ) ?? SingleAction
 
-  @deprecated("No longer used.", "0.13.2")
-  def showParser = token((ShowCommand ~ Space) ^^^ true) ?? false
-
   def scopedKeyParser(state: State): Parser[ScopedKey[_]] = scopedKeyParser(Project extract state)
-  def scopedKeyParser(extracted: Extracted): Parser[ScopedKey[_]] = scopedKeyParser(extracted.structure, extracted.currentRef)
+  def scopedKeyParser(extracted: Extracted): Parser[ScopedKey[_]] =
+    scopedKeyParser(extracted.structure, extracted.currentRef)
   def scopedKeyParser(structure: BuildStructure, currentRef: ProjectRef): Parser[ScopedKey[_]] =
-    scopedKey(structure.index.keyIndex, currentRef, structure.extra.configurationsForAxis, structure.index.keyMap, structure.data)
+    scopedKey(
+      structure.index.keyIndex,
+      currentRef,
+      structure.extra.configurationsForAxis,
+      structure.index.keyMap,
+      structure.data
+    )
 
   type KeysParser = Parser[Seq[ScopedKey[T]] forSome { type T }]
+  type KeysParserSep = Parser[Seq[(ScopedKey[T], Seq[String])] forSome { type T }]
+
   def aggregatedKeyParser(state: State): KeysParser = aggregatedKeyParser(Project extract state)
-  def aggregatedKeyParser(extracted: Extracted): KeysParser = aggregatedKeyParser(extracted.structure, extracted.currentRef)
+  def aggregatedKeyParser(extracted: Extracted): KeysParser =
+    aggregatedKeyParser(extracted.structure, extracted.currentRef)
   def aggregatedKeyParser(structure: BuildStructure, currentRef: ProjectRef): KeysParser =
     scopedKeyAggregated(currentRef, structure.extra.configurationsForAxis, structure)
 
-  def keyValues[T](state: State)(keys: Seq[ScopedKey[T]]): Values[T] = keyValues(Project extract state)(keys)
-  def keyValues[T](extracted: Extracted)(keys: Seq[ScopedKey[T]]): Values[T] = keyValues(extracted.structure)(keys)
+  private[sbt] def aggregatedKeyParserSep(extracted: Extracted): KeysParserSep =
+    aggregatedKeyParserSep(extracted.structure, extracted.currentRef)
+  private[sbt] def aggregatedKeyParserSep(
+      structure: BuildStructure,
+      currentRef: ProjectRef
+  ): KeysParserSep =
+    scopedKeyAggregatedSep(currentRef, structure.extra.configurationsForAxis, structure)
+
+  def keyValues[T](state: State)(keys: Seq[ScopedKey[T]]): Values[T] =
+    keyValues(Project extract state)(keys)
+  def keyValues[T](extracted: Extracted)(keys: Seq[ScopedKey[T]]): Values[T] =
+    keyValues(extracted.structure)(keys)
   def keyValues[T](structure: BuildStructure)(keys: Seq[ScopedKey[T]]): Values[T] =
     keys.flatMap { key =>
-      getValue(structure.data, key.scope, key.key) map { value => KeyValue(key, value) }
+      getValue(structure.data, key.scope, key.key) map { value =>
+        KeyValue(key, value)
+      }
     }
-  private[this] def anyKeyValues(structure: BuildStructure, keys: Seq[ScopedKey[_]]): Seq[KeyValue[_]] =
+  private[this] def anyKeyValues(
+      structure: BuildStructure,
+      keys: Seq[ScopedKey[_]]
+  ): Seq[KeyValue[_]] =
     keys.flatMap { key =>
-      getValue(structure.data, key.scope, key.key) map { value => KeyValue(key, value) }
+      getValue(structure.data, key.scope, key.key) map { value =>
+        KeyValue(key, value)
+      }
     }
 
-  private[this] def getValue[T](data: Settings[Scope], scope: Scope, key: AttributeKey[T]): Option[T] =
-    if (java.lang.Boolean.getBoolean("sbt.cli.nodelegation")) data.getDirect(scope, key) else data.get(scope, key)
+  private[this] def getValue[T](
+      data: Settings[Scope],
+      scope: Scope,
+      key: AttributeKey[T]
+  ): Option[T] =
+    if (java.lang.Boolean.getBoolean("sbt.cli.nodelegation")) data.getDirect(scope, key)
+    else data.get(scope, key)
 
   def requireSession[T](s: State, p: => Parser[T]): Parser[T] =
     if (s get sessionSettings isEmpty) failure("No project loaded") else p
@@ -313,7 +583,10 @@ object Act {
     final def isExplicit = this != Omitted
   }
   final object ParsedGlobal extends ParsedAxis[Nothing]
+  final object ParsedZero extends ParsedAxis[Nothing]
   final object Omitted extends ParsedAxis[Nothing]
   final class ParsedValue[T](val value: T) extends ParsedAxis[T]
-  def value[T](t: Parser[T]): Parser[ParsedAxis[T]] = t map { v => new ParsedValue(v) }
+  def value[T](t: Parser[T]): Parser[ParsedAxis[T]] = t map { v =>
+    new ParsedValue(v)
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/AddSettings.scala b/main/src/main/scala/sbt/internal/AddSettings.scala
index 96e7b0a56..14acc5c05 100644
--- a/main/src/main/scala/sbt/internal/AddSettings.scala
+++ b/main/src/main/scala/sbt/internal/AddSettings.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -11,15 +18,20 @@ import java.io.File
 sealed abstract class AddSettings
 
 object AddSettings {
-  private[sbt] final class Sequence(val sequence: Seq[AddSettings]) extends AddSettings
+  private[sbt] final class Sequence(val sequence: Seq[AddSettings]) extends AddSettings {
+    override def toString: String = s"Sequence($sequence)"
+  }
   private[sbt] final object User extends AddSettings
   private[sbt] final class AutoPlugins(val include: AutoPlugin => Boolean) extends AddSettings
   private[sbt] final class DefaultSbtFiles(val include: File => Boolean) extends AddSettings
-  private[sbt] final class SbtFiles(val files: Seq[File]) extends AddSettings
+  private[sbt] final class SbtFiles(val files: Seq[File]) extends AddSettings {
+    override def toString: String = s"SbtFiles($files)"
+  }
   private[sbt] final object BuildScalaFiles extends AddSettings
 
   /** Adds all settings from autoplugins. */
-  val autoPlugins: AddSettings = new AutoPlugins(const(true)) // Note: We do not expose fine-grained autoplugins because
+  val autoPlugins
+      : AddSettings = new AutoPlugins(const(true)) // Note: We do not expose fine-grained autoplugins because
   // it's dangerous to control at that level right now.
   // Leaving the hook in place in case we need to expose
   // it, but most likely it will remain locked out
@@ -55,19 +67,22 @@ object AddSettings {
     case _                            => seq(a, b)
   }
 
-  def clearSbtFiles(a: AddSettings): AddSettings = tx(a) {
-    case _: DefaultSbtFiles | _: SbtFiles => None
-    case x                                => Some(x)
-  } getOrElse seq()
+  def clearSbtFiles(a: AddSettings): AddSettings =
+    tx(a) {
+      case _: DefaultSbtFiles | _: SbtFiles => None
+      case x                                => Some(x)
+    } getOrElse seq()
 
-  private[sbt] def tx(a: AddSettings)(f: AddSettings => Option[AddSettings]): Option[AddSettings] = a match {
-    case s: Sequence =>
-      s.sequence.flatMap { b => tx(b)(f) } match {
-        case Seq()  => None
-        case Seq(x) => Some(x)
-        case ss     => Some(new Sequence(ss))
-      }
-    case x => f(x)
-  }
+  private[sbt] def tx(a: AddSettings)(f: AddSettings => Option[AddSettings]): Option[AddSettings] =
+    a match {
+      case s: Sequence =>
+        s.sequence.flatMap { b =>
+          tx(b)(f)
+        } match {
+          case Seq()  => None
+          case Seq(x) => Some(x)
+          case ss     => Some(new Sequence(ss))
+        }
+      case x => f(x)
+    }
 }
-
diff --git a/main/src/main/scala/sbt/internal/Aggregation.scala b/main/src/main/scala/sbt/internal/Aggregation.scala
index d431ebc26..b17413652 100644
--- a/main/src/main/scala/sbt/internal/Aggregation.scala
+++ b/main/src/main/scala/sbt/internal/Aggregation.scala
@@ -1,76 +1,117 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
-import Def.ScopedKey
-import Keys.{ showSuccess, showTiming, timingFormat }
+import java.text.DateFormat
+
+import sbt.Def.ScopedKey
+import sbt.Keys.{ showSuccess, showTiming, timingFormat }
+import sbt.SlashSyntax0._
 import sbt.internal.util.complete.Parser
-import sbt.internal.util.{ Dag, HList, Relation, Settings, Show, Util }
-import sbt.util.Logger
-import java.net.URI
-import Parser.{ seq, failure, success }
-import std.Transform.DummyTaskMap
+import sbt.internal.util.complete.Parser.{ failure, seq, success }
+import sbt.internal.util._
+import sbt.std.Transform.DummyTaskMap
+import sbt.util.{ Logger, Show }
+import scala.annotation.nowarn
 
 sealed trait Aggregation
 object Aggregation {
-  final case class ShowConfig(settingValues: Boolean, taskValues: Boolean, print: String => Unit, success: Boolean)
-  final case class Complete[T](start: Long, stop: Long, results: sbt.Result[Seq[KeyValue[T]]], state: State)
+  final case class ShowConfig(
+      settingValues: Boolean,
+      taskValues: Boolean,
+      print: String => Unit,
+      success: Boolean
+  )
+
+  final case class Complete[T](
+      start: Long,
+      stop: Long,
+      results: sbt.Result[Seq[KeyValue[T]]],
+      state: State
+  )
+
   final case class KeyValue[+T](key: ScopedKey[_], value: T)
 
-  def defaultShow(state: State, showTasks: Boolean): ShowConfig = ShowConfig(settingValues = true, taskValues = showTasks, s => state.log.info(s), success = true)
-  def printSettings(xs: Seq[KeyValue[_]], print: String => Unit)(implicit display: Show[ScopedKey[_]]) =
+  def defaultShow(state: State, showTasks: Boolean): ShowConfig =
+    ShowConfig(
+      settingValues = true,
+      taskValues = showTasks,
+      s => state.log.info(s),
+      success = true
+    )
+
+  def printSettings(xs: Seq[KeyValue[_]], print: String => Unit)(
+      implicit display: Show[ScopedKey[_]]
+  ): Unit =
     xs match {
       case KeyValue(_, x: Seq[_]) :: Nil => print(x.mkString("* ", "\n* ", ""))
       case KeyValue(_, x) :: Nil         => print(x.toString)
-      case _                             => xs foreach { case KeyValue(key, value) => print(display(key) + "\n\t" + value.toString) }
+      case _ =>
+        xs foreach (kv => print(display.show(kv.key) + "\n\t" + kv.value.toString))
     }
+
   type Values[T] = Seq[KeyValue[T]]
   type AnyKeys = Values[_]
-  def seqParser[T](ps: Values[Parser[T]]): Parser[Seq[KeyValue[T]]] = seq(ps.map { case KeyValue(k, p) => p.map(v => KeyValue(k, v)) })
 
-  def applyTasks[T](s: State, structure: BuildStructure, ps: Values[Parser[Task[T]]], show: ShowConfig)(implicit display: Show[ScopedKey[_]]): Parser[() => State] =
-    Command.applyEffect(seqParser(ps)) { ts =>
-      runTasks(s, structure, ts, DummyTaskMap(Nil), show)
-    }
+  def seqParser[T](ps: Values[Parser[T]]): Parser[Seq[KeyValue[T]]] =
+    seq(ps.map { case KeyValue(k, p) => p.map(v => KeyValue(k, v)) })
 
-  @deprecated("Use `timedRun` and `showRun` directly or use `runTasks`.", "0.13.0")
-  def runTasksWithResult[T](s: State, structure: BuildStructure, ts: Values[Task[T]], extra: DummyTaskMap, show: ShowConfig)(implicit display: Show[ScopedKey[_]]): (State, Result[Seq[KeyValue[T]]]) =
-    {
-      val complete = timedRun[T](s, ts, extra)
-      showRun(complete, show)
-      (complete.state, complete.results)
-    }
-  def showRun[T](complete: Complete[T], show: ShowConfig)(implicit display: Show[ScopedKey[_]]): Unit = {
+  def applyTasks[T](
+      s: State,
+      ps: Values[Parser[Task[T]]],
+      show: ShowConfig
+  )(implicit display: Show[ScopedKey[_]]): Parser[() => State] =
+    Command.applyEffect(seqParser(ps))(ts => runTasks(s, ts, DummyTaskMap(Nil), show))
+
+  private def showRun[T](complete: Complete[T], show: ShowConfig)(
+      implicit display: Show[ScopedKey[_]]
+  ): Unit = {
     import complete._
     val log = state.log
     val extracted = Project.extract(state)
     val success = results match { case Value(_) => true; case Inc(_) => false }
-    results.toEither.right.foreach { r => if (show.taskValues) printSettings(r, show.print) }
-    if (show.success) printSuccess(start, stop, extracted, success, log)
-  }
-  def timedRun[T](s: State, ts: Values[Task[T]], extra: DummyTaskMap): Complete[T] =
-    {
-      import EvaluateTask._
-      import std.TaskExtra._
-
-      val extracted = Project extract s
-      import extracted.structure
-      val toRun = ts map { case KeyValue(k, t) => t.map(v => KeyValue(k, v)) } join;
-      val roots = ts map { case KeyValue(k, _) => k }
-      val config = extractedTaskConfig(extracted, structure, s)
-
-      val start = System.currentTimeMillis
-      val (newS, result) = withStreams(structure, s) { str =>
-        val transform = nodeView(s, str, roots, extra)
-        runTask(toRun, s, str, structure.index.triggers, config)(transform)
-      }
-      val stop = System.currentTimeMillis
-      Complete(start, stop, result, newS)
+    results.toEither.right.foreach { r =>
+      if (show.taskValues) printSettings(r, show.print)
     }
+    if (show.success && !state.get(suppressShow).getOrElse(false))
+      printSuccess(start, stop, extracted, success, log)
+  }
 
-  def runTasks[HL <: HList, T](s: State, structure: BuildStructure, ts: Values[Task[T]], extra: DummyTaskMap, show: ShowConfig)(implicit display: Show[ScopedKey[_]]): State = {
+  def timedRun[T](
+      s: State,
+      ts: Values[Task[T]],
+      extra: DummyTaskMap
+  ): Complete[T] = {
+    import EvaluateTask._
+    import std.TaskExtra._
+
+    val extracted = Project extract s
+    import extracted.structure
+    val toRun = ts map { case KeyValue(k, t) => t.map(v => KeyValue(k, v)) } join;
+    val roots = ts map { case KeyValue(k, _) => k }
+    val config = extractedTaskConfig(extracted, structure, s)
+
+    val start = System.currentTimeMillis
+    val (newS, result) = withStreams(structure, s) { str =>
+      val transform = nodeView(s, str, roots, extra)
+      runTask(toRun, s, str, structure.index.triggers, config)(transform)
+    }
+    val stop = System.currentTimeMillis
+    Complete(start, stop, result, newS)
+  }
+
+  def runTasks[HL <: HList, T](
+      s: State,
+      ts: Values[Task[T]],
+      extra: DummyTaskMap,
+      show: ShowConfig
+  )(implicit display: Show[ScopedKey[_]]): State = {
     val complete = timedRun[T](s, ts, extra)
     showRun(complete, show)
     complete.results match {
@@ -79,131 +120,179 @@ object Aggregation {
     }
   }
 
-  def printSuccess(start: Long, stop: Long, extracted: Extracted, success: Boolean, log: Logger): Unit = {
+  def printSuccess(
+      start: Long,
+      stop: Long,
+      extracted: Extracted,
+      success: Boolean,
+      log: Logger
+  ): Unit = {
     import extracted._
-    def get(key: SettingKey[Boolean]): Boolean = key in currentRef get structure.data getOrElse true
+    def get(key: SettingKey[Boolean]): Boolean =
+      (currentRef / key).get(structure.data) getOrElse true
+
     if (get(showSuccess)) {
       if (get(showTiming)) {
-        val msg = timingString(start, stop, "", structure.data, currentRef, log)
-        if (success) log.success(msg) else log.error(msg)
+        val msg = timingString(start, stop, structure.data, currentRef)
+        if (success) log.success(msg) else if (Terminal.get.isSuccessEnabled) log.error(msg)
       } else if (success)
         log.success("")
     }
   }
-  private def timingString(startTime: Long, endTime: Long, s: String, data: Settings[Scope], currentRef: ProjectRef, log: Logger): String =
-    {
-      val format = timingFormat in currentRef get data getOrElse defaultFormat
-      timing(format, startTime, endTime, "", log)
-    }
-  def timing(format: java.text.DateFormat, startTime: Long, endTime: Long, s: String, log: Logger): String =
-    {
-      val ss = if (s.isEmpty) "" else s + " "
-      val nowString = format.format(new java.util.Date(endTime))
-      "Total " + ss + "time: " + (endTime - startTime + 500) / 1000 + " s, completed " + nowString
-    }
-  def defaultFormat =
-    {
-      import java.text.DateFormat
-      DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM)
-    }
 
-  def applyDynamicTasks[I](s: State, structure: BuildStructure, inputs: Values[InputTask[I]], show: ShowConfig)(implicit display: Show[ScopedKey[_]]): Parser[() => State] =
-    {
-      val parsers = for (KeyValue(k, it) <- inputs) yield it.parser(s).map(v => KeyValue(k, v))
-      Command.applyEffect(seq(parsers)) { roots =>
-        runTasks(s, structure, roots, DummyTaskMap(Nil), show)
+  private def timingString(
+      startTime: Long,
+      endTime: Long,
+      data: Settings[Scope],
+      currentRef: ProjectRef,
+  ): String = {
+    val format = (currentRef / timingFormat).get(data) getOrElse defaultFormat
+    timing(format, startTime, endTime)
+  }
+
+  def timing(format: java.text.DateFormat, startTime: Long, endTime: Long): String = {
+    val nowString = format.format(new java.util.Date(endTime))
+    val total = (endTime - startTime + 500) / 1000
+    val totalString = s"$total s" +
+      (if (total <= 60) ""
+       else {
+         val maybeHours = total / 3600 match {
+           case 0 => ""
+           case h => f"$h%02d:"
+         }
+         val mins = f"${total % 3600 / 60}%02d"
+         val secs = f"${total % 60}%02d"
+         s" ($maybeHours$mins:$secs)"
+       })
+    s"Total time: $totalString, completed $nowString"
+  }
+
+  def defaultFormat: DateFormat = {
+    import java.text.DateFormat
+    DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM)
+  }
+
+  def applyDynamicTasks[I](
+      s: State,
+      inputs: Values[InputTask[I]],
+      show: ShowConfig
+  )(implicit display: Show[ScopedKey[_]]): Parser[() => State] = {
+    val parsers =
+      for (KeyValue(k, it) <- inputs)
+        yield it.parser(s).map(v => KeyValue(k, v))
+    Command.applyEffect(seq(parsers)) { roots =>
+      runTasks(s, roots, DummyTaskMap(Nil), show)
+    }
+  }
+
+  def evaluatingParser(s: State, show: ShowConfig)(keys: Seq[KeyValue[_]])(
+      implicit display: Show[ScopedKey[_]]
+  ): Parser[() => State] = {
+
+    // to make the call sites clearer
+    def separate[L](in: Seq[KeyValue[_]])(
+        f: KeyValue[_] => Either[KeyValue[L], KeyValue[_]]
+    ): (Seq[KeyValue[L]], Seq[KeyValue[_]]) =
+      Util.separate(in)(f)
+
+    val kvs = keys.toList
+    if (kvs.isEmpty)
+      failure("No such setting/task")
+    else {
+      val (inputTasks, other) = separate[InputTask[_]](kvs) {
+        case KeyValue(k, v: InputTask[_]) => Left(KeyValue(k, v))
+        case kv                           => Right(kv)
       }
-    }
-
-  def evaluatingParser(s: State, structure: BuildStructure, show: ShowConfig)(keys: Seq[KeyValue[_]])(implicit display: Show[ScopedKey[_]]): Parser[() => State] =
-    {
-      // to make the call sites clearer
-      def separate[L](in: Seq[KeyValue[_]])(f: KeyValue[_] => Either[KeyValue[L], KeyValue[_]]): (Seq[KeyValue[L]], Seq[KeyValue[_]]) =
-        Util.separate(in)(f)
-
-      val kvs = keys.toList
-      if (kvs.isEmpty)
-        failure("No such setting/task")
-      else {
-        val (inputTasks, other) = separate[InputTask[_]](kvs) {
-          case KeyValue(k, v: InputTask[_]) => Left(KeyValue(k, v))
-          case kv                           => Right(kv)
-        }
-        val (tasks, settings) = separate[Task[_]](other) {
-          case KeyValue(k, v: Task[_]) => Left(KeyValue(k, v))
-          case kv                      => Right(kv)
-        }
-        // currently, disallow input tasks to be mixed with normal tasks.
-        // This occurs in `all` or `show`, which support multiple tasks.
-        // Previously, multiple tasks could be run in one execution, but they were all for the same key, just in different scopes.
-        // When `all` was added, it allowed different keys and thus opened the possibility for mixing settings,
-        //  tasks, and input tasks in the same call.  The code below allows settings and tasks to be mixed, but not input tasks.
-        // One problem with input tasks in `all` is that many input tasks consume all input and would need syntactic delimiters.
-        // Once that is addressed, the tasks constructed by the input tasks would need to be combined with the explicit tasks.
-        if (inputTasks.nonEmpty) {
-          if (other.nonEmpty) {
-            val inputStrings = inputTasks.map(_.key).mkString("Input task(s):\n\t", "\n\t", "\n")
-            val otherStrings = other.map(_.key).mkString("Task(s)/setting(s):\n\t", "\n\t", "\n")
-            failure(s"Cannot mix input tasks with plain tasks/settings.  $inputStrings $otherStrings")
-          } else
-            applyDynamicTasks(s, structure, maps(inputTasks)(castToAny), show)
-        } else {
-          val base = if (tasks.isEmpty) success(() => s) else
-            applyTasks(s, structure, maps(tasks)(x => success(castToAny(x))), show)
-          base.map { res =>
-            () =>
-              val newState = res()
-              if (show.settingValues && settings.nonEmpty) printSettings(settings, show.print)
-              newState
-          }
+      val (tasks, settings) = separate[Task[_]](other) {
+        case KeyValue(k, v: Task[_]) => Left(KeyValue(k, v))
+        case kv                      => Right(kv)
+      }
+      // currently, disallow input tasks to be mixed with normal tasks.
+      // This occurs in `all` or `show`, which support multiple tasks.
+      // Previously, multiple tasks could be run in one execution, but they were all for the same key, just in different scopes.
+      // When `all` was added, it allowed different keys and thus opened the possibility for mixing settings,
+      //  tasks, and input tasks in the same call.  The code below allows settings and tasks to be mixed, but not input tasks.
+      // One problem with input tasks in `all` is that many input tasks consume all input and would need syntactic delimiters.
+      // Once that is addressed, the tasks constructed by the input tasks would need to be combined with the explicit tasks.
+      if (inputTasks.nonEmpty) {
+        if (other.nonEmpty) {
+          val inputStrings = inputTasks.map(_.key).mkString("Input task(s):\n\t", "\n\t", "\n")
+          val otherStrings = other.map(_.key).mkString("Task(s)/setting(s):\n\t", "\n\t", "\n")
+          failure(s"Cannot mix input tasks with plain tasks/settings.  $inputStrings $otherStrings")
+        } else
+          applyDynamicTasks(s, maps(inputTasks)(castToAny), show)
+      } else {
+        val base =
+          if (tasks.isEmpty) success(() => s)
+          else
+            applyTasks(s, maps(tasks)(x => success(castToAny(x))), show)
+        base.map { res => () =>
+          val newState = res()
+          if (show.settingValues && settings.nonEmpty) printSettings(settings, show.print)
+          newState
         }
       }
     }
+  }
   // this is a hack to avoid duplicating method implementations
   private[this] def castToAny[T[_]](t: T[_]): T[Any] = t.asInstanceOf[T[Any]]
 
   private[this] def maps[T, S](vs: Values[T])(f: T => S): Values[S] =
     vs map { case KeyValue(k, v) => KeyValue(k, f(v)) }
 
-  def projectAggregates[Proj](proj: Option[Reference], extra: BuildUtil[Proj], reverse: Boolean): Seq[ProjectRef] =
-    {
-      val resRef = proj.map(p => extra.projectRefFor(extra.resolveRef(p)))
-      resRef.toList.flatMap(ref =>
-        if (reverse) extra.aggregates.reverse(ref) else extra.aggregates.forward(ref)
-      )
-    }
+  def projectAggregates[Proj](
+      proj: Option[Reference],
+      extra: BuildUtil[Proj],
+      reverse: Boolean
+  ): Seq[ProjectRef] = {
+    val resRef = proj.map(p => extra.projectRefFor(extra.resolveRef(p)))
+    resRef.toList.flatMap(
+      ref => if (reverse) extra.aggregates.reverse(ref) else extra.aggregates.forward(ref)
+    )
+  }
 
-  def aggregate[T, Proj](key: ScopedKey[T], rawMask: ScopeMask, extra: BuildUtil[Proj], reverse: Boolean = false): Seq[ScopedKey[T]] =
-    {
-      val mask = rawMask.copy(project = true)
-      Dag.topologicalSort(key) { k =>
-        if (reverse)
-          reverseAggregatedKeys(k, extra, mask)
-        else if (aggregationEnabled(k, extra.data))
-          aggregatedKeys(k, extra, mask)
-        else
-          Nil
-      }
+  def aggregate[T, Proj](
+      key: ScopedKey[T],
+      rawMask: ScopeMask,
+      extra: BuildUtil[Proj],
+      reverse: Boolean = false
+  ): Seq[ScopedKey[T]] = {
+    val mask = rawMask.copy(project = true)
+    Dag.topologicalSort(key) { k =>
+      if (reverse)
+        reverseAggregatedKeys(k, extra, mask)
+      else if (aggregationEnabled(k, extra.data))
+        aggregatedKeys(k, extra, mask)
+      else
+        Nil
     }
-  def reverseAggregatedKeys[T](key: ScopedKey[T], extra: BuildUtil[_], mask: ScopeMask): Seq[ScopedKey[T]] =
+  }
+  def reverseAggregatedKeys[T](
+      key: ScopedKey[T],
+      extra: BuildUtil[_],
+      mask: ScopeMask
+  ): Seq[ScopedKey[T]] =
     projectAggregates(key.scope.project.toOption, extra, reverse = true) flatMap { ref =>
       val toResolve = key.scope.copy(project = Select(ref))
-      val resolved = Resolve(extra, Global, key.key, mask)(toResolve)
+      val resolved = Resolve(extra, Zero, key.key, mask)(toResolve)
       val skey = ScopedKey(resolved, key.key)
       if (aggregationEnabled(skey, extra.data)) skey :: Nil else Nil
     }
 
-  def aggregatedKeys[T](key: ScopedKey[T], extra: BuildUtil[_], mask: ScopeMask): Seq[ScopedKey[T]] =
+  def aggregatedKeys[T](
+      key: ScopedKey[T],
+      extra: BuildUtil[_],
+      mask: ScopeMask
+  ): Seq[ScopedKey[T]] =
     projectAggregates(key.scope.project.toOption, extra, reverse = false) map { ref =>
       val toResolve = key.scope.copy(project = Select(ref))
-      val resolved = Resolve(extra, Global, key.key, mask)(toResolve)
+      val resolved = Resolve(extra, Zero, key.key, mask)(toResolve)
       ScopedKey(resolved, key.key)
     }
 
+  @nowarn
   def aggregationEnabled(key: ScopedKey[_], data: Settings[Scope]): Boolean =
     Keys.aggregate in Scope.fillTaskAxis(key.scope, key.key) get data getOrElse true
-
-  @deprecated("Use BuildUtil.aggregationRelation", "0.13.0")
-  def relation(units: Map[URI, LoadedBuildUnit]): Relation[ProjectRef, ProjectRef] =
-    BuildUtil.aggregationRelation(units)
+  private[sbt] val suppressShow =
+    AttributeKey[Boolean]("suppress-aggregation-show", Int.MaxValue)
 }
diff --git a/main/src/main/scala/sbt/internal/Banner.scala b/main/src/main/scala/sbt/internal/Banner.scala
new file mode 100644
index 000000000..35f94bc80
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/Banner.scala
@@ -0,0 +1,35 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+private[sbt] object Banner {
+  def apply(version: String): Option[String] =
+    version match {
+      case v if v.startsWith("1.4.0") =>
+        Some(s"""
+                |Here are some highlights of this release:
+                |  - Build server protocol (BSP) support
+                |  - sbtn: a native thin client for sbt
+                |  - VirtualFile + RemoteCache: caches build artifacts across different machines
+                |  - ThisBuild / versionScheme to take the guessing out of eviction warning
+                |See http://eed3si9n.com/sbt-1.4.0 for full release notes.
+                |Hide the banner for this release by running `skipBanner`.
+                |""".stripMargin.linesIterator.mkString("\n"))
+      case "1.3.0" =>
+        Some(s"""
+                |Welcome to sbt $version.
+                |Here are some highlights of this release:
+                |  - Coursier: new default library management using https://get-coursier.io
+                |  - Super shell: displays actively running tasks
+                |  - Turbo mode: makes `test` and `run` faster in interactive sessions. Try it by running `set ThisBuild / turbo := true`.
+                |See https://www.lightbend.com/blog/sbt-1.3.0-release for full release notes.
+                |Hide the banner for this release by running `skipBanner`.
+                |""".stripMargin.linesIterator.filter(_.nonEmpty).mkString("\n"))
+      case _ => None
+    }
+}
diff --git a/main/src/main/scala/sbt/internal/BuildDef.scala b/main/src/main/scala/sbt/internal/BuildDef.scala
index bd3ce24e5..4c17f2f05 100644
--- a/main/src/main/scala/sbt/internal/BuildDef.scala
+++ b/main/src/main/scala/sbt/internal/BuildDef.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
@@ -8,16 +12,17 @@ import java.io.File
 import Keys.{ organization, thisProject, autoGeneratedProject }
 import Def.Setting
 import sbt.io.Hash
-import sbt.internal.util.{ Attributed, Eval }
+import sbt.internal.util.Attributed
 import sbt.internal.inc.ReflectUtilities
-import sbt.Project._
 
 trait BuildDef {
-  def projectDefinitions(baseDirectory: File): Seq[Project] = projects
-  def projects: Seq[Project] = ReflectUtilities.allVals[Project](this).values.toSeq
+  def projectDefinitions(@deprecated("unused", "") baseDirectory: File): Seq[Project] = projects
+  def projects: Seq[Project] =
+    CompositeProject.expand(ReflectUtilities.allVals[CompositeProject](this).values.toSeq)
   // TODO: Should we grab the build core settings here or in a plugin?
   def settings: Seq[Setting[_]] = Defaults.buildCore
   def buildLoaders: Seq[BuildLoader.Components] = Nil
+
   /**
    * Explicitly defines the root project.
    * If None, the root project is the first project in the build's root directory or just the first project if none are in the root directory.
@@ -27,19 +32,32 @@ trait BuildDef {
 
 private[sbt] object BuildDef {
   val defaultEmpty: BuildDef = new BuildDef { override def projects = Nil }
-  val default: BuildDef = new BuildDef { override def projectDefinitions(base: File) = defaultProject(defaultID(base), base) :: Nil }
-  def defaultAggregated(id: String, aggregate: Seq[ProjectRef]): BuildDef = new BuildDef {
-    override def projectDefinitions(base: File) = defaultAggregatedProject(id, base, aggregate) :: Nil
+
+  val default: BuildDef = new BuildDef {
+    override def projectDefinitions(base: File) = defaultProject(defaultID(base), base) :: Nil
   }
 
-  def defaultID(base: File, prefix: String = "default"): String = prefix + "-" + Hash.trimHashString(base.getAbsolutePath, 6)
+  def defaultAggregated(id: String, aggregate: Seq[ProjectRef]): BuildDef = new BuildDef {
+    override def projectDefinitions(base: File) =
+      defaultAggregatedProject(id, base, aggregate) :: Nil
+  }
+
+  def defaultID(base: File, prefix: String = "default"): String =
+    prefix + "-" + Hash.trimHashString(base.getAbsolutePath, 6)
+
+  def defaultProject(id: String, base: File): Project =
+    Project(id, base).settings(defaultProjectSettings)
 
-  def defaultProject(id: String, base: File): Project = Project(id, base).settings(defaultProjectSettings)
   def defaultAggregatedProject(id: String, base: File, agg: Seq[ProjectRef]): Project =
     defaultProject(id, base).aggregate(agg: _*)
 
-  private[sbt] def generatedRootWithoutIvyPlugin(id: String, base: File, agg: Seq[ProjectRef]): Project =
-    Project.mkGeneratedRoot(id, base, Eval.later(agg)).settings(defaultProjectSettings)
+  private[sbt] def generatedRootWithoutIvyPlugin(
+      id: String,
+      base: File,
+      agg: Seq[ProjectRef]
+  ): Project =
+    Project.mkGeneratedRoot(id, base, agg).settings(defaultProjectSettings)
+
   private[sbt] def defaultProjectSettings: Seq[Setting[_]] = Seq(
     // TODO - Can we move this somewhere else?  ordering of settings is causing this to get borked.
     // if the user has overridden the name, use the normal organization that is derived from the name.
@@ -52,5 +70,8 @@ private[sbt] object BuildDef {
     },
     autoGeneratedProject := true
   )
-  def analyzed(in: Seq[Attributed[_]]): Seq[xsbti.compile.CompileAnalysis] = in.flatMap { _.metadata.get(Keys.analysis) }
+
+  def analyzed(in: Seq[Attributed[_]]): Seq[xsbti.compile.CompileAnalysis] =
+    in.flatMap { _.metadata.get(Keys.analysis) }
+
 }
diff --git a/main/src/main/scala/sbt/internal/BuildDependencies.scala b/main/src/main/scala/sbt/internal/BuildDependencies.scala
index 45a618d58..601584de7 100644
--- a/main/src/main/scala/sbt/internal/BuildDependencies.scala
+++ b/main/src/main/scala/sbt/internal/BuildDependencies.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -5,12 +12,16 @@ import sbt.internal.util.Types.idFun
 import sbt.internal.util.Dag
 import BuildDependencies._
 
-final class BuildDependencies private (val classpath: DependencyMap[ClasspathDep[ProjectRef]], val aggregate: DependencyMap[ProjectRef]) {
+final class BuildDependencies private (
+    val classpath: DependencyMap[ClasspathDep[ProjectRef]],
+    val aggregate: DependencyMap[ProjectRef]
+) {
   def classpathRefs(ref: ProjectRef): Seq[ProjectRef] = classpath(ref) map getID
   def classpathTransitiveRefs(ref: ProjectRef): Seq[ProjectRef] = classpathTransitive(ref)
 
   lazy val classpathTransitive: DependencyMap[ProjectRef] = transitive(classpath, getID)
-  lazy val aggregateTransitive: DependencyMap[ProjectRef] = transitive(aggregate, idFun[ProjectRef])
+  lazy val aggregateTransitive: DependencyMap[ProjectRef] =
+    transitive(aggregate, idFun[ProjectRef])
 
   def addClasspath(ref: ProjectRef, deps: ClasspathDep[ProjectRef]*): BuildDependencies =
     new BuildDependencies(classpath.updated(ref, deps ++ classpath.getOrElse(ref, Nil)), aggregate)
@@ -18,7 +29,10 @@ final class BuildDependencies private (val classpath: DependencyMap[ClasspathDep
     new BuildDependencies(classpath, aggregate.updated(ref, deps ++ aggregate.getOrElse(ref, Nil)))
 }
 object BuildDependencies {
-  def apply(classpath: DependencyMap[ClasspathDep[ProjectRef]], aggregate: DependencyMap[ProjectRef]): BuildDependencies =
+  def apply(
+      classpath: DependencyMap[ClasspathDep[ProjectRef]],
+      aggregate: DependencyMap[ProjectRef]
+  ): BuildDependencies =
     new BuildDependencies(classpath, aggregate)
 
   type DependencyMap[D] = Map[ProjectRef, Seq[D]]
diff --git a/main/src/main/scala/sbt/internal/BuildLoader.scala b/main/src/main/scala/sbt/internal/BuildLoader.scala
index e7b97d7ed..76c67addc 100644
--- a/main/src/main/scala/sbt/internal/BuildLoader.scala
+++ b/main/src/main/scala/sbt/internal/BuildLoader.scala
@@ -1,36 +1,66 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
 import java.io.File
 import java.net.URI
 import BuildLoader._
-import sbt.internal.io.Alternatives._
 import sbt.internal.util.Types.{ const, idFun }
 import sbt.util.Logger
 import sbt.librarymanagement.ModuleID
 
-final class MultiHandler[S, T](builtIn: S => Option[T], root: Option[S => Option[T]], nonRoots: List[(URI, S => Option[T])], getURI: S => URI, log: S => Logger) {
+private[internal] object Alternatives {
+  private[internal] implicit class Alternative[A, B](val f: A => Option[B]) {
+    def |(g: A => Option[B]): A => Option[B] = (a: A) => f(a) orElse g(a)
+  }
+}
+import Alternatives.Alternative
+final class MultiHandler[S, T](
+    builtIn: S => Option[T],
+    root: Option[S => Option[T]],
+    nonRoots: List[(URI, S => Option[T])],
+    getURI: S => URI,
+    log: S => Logger
+) {
   def applyFun: S => Option[T] = apply
   def apply(info: S): Option[T] =
     (baseLoader(info), applyNonRoots(info)) match {
       case (None, Nil) => None
       case (None, xs @ (_, nr) :: ignored) =>
-        if (ignored.nonEmpty) warn("Using first of multiple matching non-root build resolvers for " + getURI(info), log(info), xs)
+        if (ignored.nonEmpty)
+          warn(
+            "Using first of multiple matching non-root build resolvers for " + getURI(info),
+            log(info),
+            xs
+          )
         Some(nr)
       case (Some(b), xs) =>
-        if (xs.nonEmpty) warn("Ignoring shadowed non-root build resolver(s) for " + getURI(info), log(info), xs)
+        if (xs.nonEmpty)
+          warn("Ignoring shadowed non-root build resolver(s) for " + getURI(info), log(info), xs)
         Some(b)
     }
 
-  def baseLoader: S => Option[T] = root match { case Some(rl) => rl | builtIn; case None => builtIn }
+  def baseLoader: S => Option[T] = root match {
+    case Some(rl) => rl | builtIn; case None => builtIn
+  }
 
-  def addNonRoot(uri: URI, loader: S => Option[T]) = new MultiHandler(builtIn, root, (uri, loader) :: nonRoots, getURI, log)
-  def setRoot(resolver: S => Option[T]) = new MultiHandler(builtIn, Some(resolver), nonRoots, getURI, log)
+  def addNonRoot(uri: URI, loader: S => Option[T]) =
+    new MultiHandler(builtIn, root, (uri, loader) :: nonRoots, getURI, log)
+  def setRoot(resolver: S => Option[T]) =
+    new MultiHandler(builtIn, Some(resolver), nonRoots, getURI, log)
   def applyNonRoots(info: S): List[(URI, T)] =
-    nonRoots flatMap { case (definingURI, loader) => loader(info) map { unit => (definingURI, unit) } }
+    nonRoots flatMap {
+      case (definingURI, loader) =>
+        loader(info) map { unit =>
+          (definingURI, unit)
+        }
+    }
 
   private[this] def warn(baseMessage: String, log: Logger, matching: Seq[(URI, T)]): Unit = {
     log.warn(baseMessage)
@@ -40,6 +70,7 @@ final class MultiHandler[S, T](builtIn: S => Option[T], root: Option[S => Option
 }
 
 object BuildLoader {
+
   /**
    * in: Build URI and staging directory
    * out: None if unhandled or Some containing the retrieve function, which returns the directory retrieved to (can be the same as the staging directory)
@@ -50,16 +81,34 @@ object BuildLoader {
   type Loader = LoadInfo => Option[() => BuildUnit]
   type TransformAll = PartBuild => PartBuild
 
-  final class Components(val resolver: Resolver, val builder: Builder, val transformer: Transformer, val full: Loader, val transformAll: TransformAll) {
+  final class Components(
+      val resolver: Resolver,
+      val builder: Builder,
+      val transformer: Transformer,
+      val full: Loader,
+      val transformAll: TransformAll
+  ) {
     def |(cs: Components): Components =
-      new Components(resolver | cs.resolver, builder | cs.builder, seq(transformer, cs.transformer), full | cs.full, transformAll andThen cs.transformAll)
+      new Components(
+        resolver | cs.resolver,
+        builder | cs.builder,
+        seq(transformer, cs.transformer),
+        full | cs.full,
+        transformAll andThen cs.transformAll
+      )
   }
   def transform(t: Transformer): Components = components(transformer = t)
   def resolve(r: Resolver): Components = components(resolver = r)
   def build(b: Builder): Components = components(builder = b)
   def full(f: Loader): Components = components(full = f)
   def transformAll(t: TransformAll) = components(transformAll = t)
-  def components(resolver: Resolver = const(None), builder: Builder = const(None), transformer: Transformer = _.unit, full: Loader = const(None), transformAll: TransformAll = idFun) =
+  def components(
+      resolver: Resolver = const(None),
+      builder: Builder = const(None),
+      transformer: Transformer = _.unit,
+      full: Loader = const(None),
+      transformAll: TransformAll = idFun
+  ) =
     new Components(resolver, builder, transformer, full, transformAll)
 
   def seq(a: Transformer, b: Transformer): Transformer = info => b(info.setUnit(a(info)))
@@ -69,19 +118,56 @@ object BuildLoader {
     def config: LoadBuildConfiguration
     def state: State
   }
-  final class ResolveInfo(val uri: URI, val staging: File, val config: LoadBuildConfiguration, val state: State) extends Info
-  final class BuildInfo(val uri: URI, val base: File, val config: LoadBuildConfiguration, val state: State) extends Info
-  final class TransformInfo(val uri: URI, val base: File, val unit: BuildUnit, val config: LoadBuildConfiguration, val state: State) extends Info {
-    def setUnit(newUnit: BuildUnit): TransformInfo = new TransformInfo(uri, base, newUnit, config, state)
+  final class ResolveInfo(
+      val uri: URI,
+      val staging: File,
+      val config: LoadBuildConfiguration,
+      val state: State
+  ) extends Info
+  final class BuildInfo(
+      val uri: URI,
+      val base: File,
+      val config: LoadBuildConfiguration,
+      val state: State
+  ) extends Info
+  final class TransformInfo(
+      val uri: URI,
+      val base: File,
+      val unit: BuildUnit,
+      val config: LoadBuildConfiguration,
+      val state: State
+  ) extends Info {
+    def setUnit(newUnit: BuildUnit): TransformInfo =
+      new TransformInfo(uri, base, newUnit, config, state)
   }
 
-  final class LoadInfo(val uri: URI, val staging: File, val config: LoadBuildConfiguration, val state: State, val components: Components) extends Info
+  final class LoadInfo(
+      val uri: URI,
+      val staging: File,
+      val config: LoadBuildConfiguration,
+      val state: State,
+      val components: Components
+  ) extends Info
 
-  def apply(base: Components, fail: URI => Nothing, s: State, config: LoadBuildConfiguration): BuildLoader =
-    {
-      def makeMulti[S <: Info, T](base: S => Option[T]) = new MultiHandler[S, T](base, None, Nil, _.uri, _.config.log)
-      new BuildLoader(fail, s, config, makeMulti(base.resolver), makeMulti(base.builder), base.transformer, makeMulti(base.full), base.transformAll)
-    }
+  def apply(
+      base: Components,
+      fail: URI => Nothing,
+      s: State,
+      config: LoadBuildConfiguration
+  ): BuildLoader = {
+    def makeMulti[S <: Info, T](base: S => Option[T]) =
+      new MultiHandler[S, T](base, None, Nil, _.uri, _.config.log)
+    new BuildLoader(
+      fail,
+      s,
+      config,
+      makeMulti(base.resolver),
+      makeMulti(base.builder),
+      base.transformer,
+      makeMulti(base.full),
+      base.transformAll
+    )
+  }
 
   def componentLoader: Loader = (info: LoadInfo) => {
     import info.{ config, staging, state, uri }
@@ -97,6 +183,17 @@ object BuildLoader {
   }
 }
 
+/** Defines the responsible for loading builds.
+ *
+ * @param fail A reporter for failures.
+ * @param state The state.
+ * @param config The current configuration for any build.
+ * @param resolvers The structure responsible of mapping base directories.
+ * @param builders The structure responsible of mapping to build units.
+ * @param transformer An instance to modify the created build unit.
+ * @param full The structure responsible of mapping to loaded build units.
+ * @param transformAll A function specifying which builds units should be transformed.
+ */
 final class BuildLoader(
     val fail: URI => Nothing,
     val state: State,
@@ -105,9 +202,13 @@ final class BuildLoader(
     val builders: MultiHandler[BuildInfo, () => BuildUnit],
     val transformer: Transformer,
     val full: MultiHandler[LoadInfo, () => BuildUnit],
-    val transformAll: TransformAll) {
+    val transformAll: TransformAll
+) {
   def addNonRoot(uri: URI, loaders: Components): BuildLoader =
-    new BuildLoader(fail, state, config,
+    new BuildLoader(
+      fail,
+      state,
+      config,
       resolvers.addNonRoot(uri, loaders.resolver),
       builders.addNonRoot(uri, loaders.builder),
       seq(transformer, loaders.transformer),
@@ -115,7 +216,10 @@ final class BuildLoader(
       transformAll andThen loaders.transformAll
     )
   def setRoot(loaders: Components): BuildLoader =
-    new BuildLoader(fail, state, config,
+    new BuildLoader(
+      fail,
+      state,
+      config,
       resolvers.setRoot(loaders.resolver),
       builders.setRoot(loaders.builder),
       seq(loaders.transformer, transformer),
@@ -124,22 +228,20 @@ final class BuildLoader(
     )
   def resetPluginDepth: BuildLoader = copyWithNewPM(config.pluginManagement.resetDepth)
 
-  def updatePluginManagement(overrides: Set[ModuleID]): BuildLoader =
-    {
-      val mgmt = config.pluginManagement
-      copyWithNewPM(mgmt.copy(overrides = mgmt.overrides ++ overrides))
-    }
-  private[this] def copyWithNewPM(newpm: PluginManagement): BuildLoader =
-    {
-      val newConfig = config.copy(pluginManagement = newpm)
-      new BuildLoader(fail, state, newConfig, resolvers, builders, transformer, full, transformAll)
-    }
+  def updatePluginManagement(overrides: Set[ModuleID]): BuildLoader = {
+    val mgmt = config.pluginManagement
+    copyWithNewPM(mgmt.copy(overrides = mgmt.overrides ++ overrides))
+  }
+  private[this] def copyWithNewPM(newpm: PluginManagement): BuildLoader = {
+    val newConfig = config.copy(pluginManagement = newpm)
+    new BuildLoader(fail, state, newConfig, resolvers, builders, transformer, full, transformAll)
+  }
 
-  def components = new Components(resolvers.applyFun, builders.applyFun, transformer, full.applyFun, transformAll)
-  def apply(uri: URI): BuildUnit =
-    {
-      val info = new LoadInfo(uri, config.stagingDirectory, config, state, components)
-      val load = full(info) getOrElse fail(uri)
-      load()
-    }
+  def components =
+    new Components(resolvers.applyFun, builders.applyFun, transformer, full.applyFun, transformAll)
+  def apply(uri: URI): BuildUnit = {
+    val info = new LoadInfo(uri, config.stagingDirectory, config, state, components)
+    val load = full(info) getOrElse fail(uri)
+    load()
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/BuildStructure.scala b/main/src/main/scala/sbt/internal/BuildStructure.scala
index 31f89725f..4c10fba22 100644
--- a/main/src/main/scala/sbt/internal/BuildStructure.scala
+++ b/main/src/main/scala/sbt/internal/BuildStructure.scala
@@ -1,54 +1,114 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
 import java.io.File
 import java.net.URI
-import Def.{ displayFull, ScopedKey, ScopeLocal, Setting }
+
+import Def.{ ScopeLocal, ScopedKey, Setting, displayFull }
 import BuildPaths.outputDirectory
 import Scope.GlobalScope
 import BuildStreams.Streams
+import sbt.LocalRootProject
 import sbt.io.syntax._
-import sbt.internal.util.{ Attributed, AttributeEntry, AttributeKey, AttributeMap, Settings }
+import sbt.internal.util.{ AttributeEntry, AttributeKey, AttributeMap, Attributed, Settings }
 import sbt.internal.util.Attributed.data
 import sbt.util.Logger
+import scala.annotation.nowarn
+
+final class BuildStructure(
+    val units: Map[URI, LoadedBuildUnit],
+    val root: URI,
+    val settings: Seq[Setting[_]],
+    val data: Settings[Scope],
+    val index: StructureIndex,
+    val streams: State => Streams,
+    val delegates: Scope => Seq[Scope],
+    val scopeLocal: ScopeLocal,
+    private[sbt] val compiledMap: Map[ScopedKey[_], Def.Compiled[_]],
+) {
+  @deprecated("Used the variant that takes a compiledMap", "1.4.0")
+  def this(
+      units: Map[URI, LoadedBuildUnit],
+      root: URI,
+      settings: Seq[Setting[_]],
+      data: Settings[Scope],
+      index: StructureIndex,
+      streams: State => Streams,
+      delegates: Scope => Seq[Scope],
+      scopeLocal: ScopeLocal,
+  ) = this(units, root, settings, data, index, streams, delegates, scopeLocal, Map.empty)
 
-final class BuildStructure(val units: Map[URI, LoadedBuildUnit], val root: URI, val settings: Seq[Setting[_]], val data: Settings[Scope], val index: StructureIndex, val streams: State => Streams, val delegates: Scope => Seq[Scope], val scopeLocal: ScopeLocal) {
-  val rootProject: URI => String = Load getRootProject units
-  def allProjects: Seq[ResolvedProject] = units.values.flatMap(_.defined.values).toSeq
-  def allProjects(build: URI): Seq[ResolvedProject] = units.get(build).toList.flatMap(_.defined.values)
-  def allProjectRefs: Seq[ProjectRef] = units.toSeq flatMap { case (build, unit) => refs(build, unit.defined.values.toSeq) }
-  def allProjectRefs(build: URI): Seq[ProjectRef] = refs(build, allProjects(build))
   val extra: BuildUtil[ResolvedProject] = BuildUtil(root, units, index.keyIndex, data)
-  private[this] def refs(build: URI, projects: Seq[ResolvedProject]): Seq[ProjectRef] = projects.map { p => ProjectRef(build, p.id) }
+
+  /** The root project for the specified build.  Throws if no build or empty build. */
+  val rootProject: URI => String = extra.rootProjectID
+
+  /** All the projects in all builds. */
+  def allProjects: Seq[ResolvedProject] = eachBuild((_, p) => p)
+
+  /** References to all the projects in all the builds. */
+  def allProjectRefs: Seq[ProjectRef] = eachBuild((b, p) => ProjectRef(b, p.id))
+
+  /** Both the projects and the projects reference of all the projects in all the builds. */
+  def allProjectPairs: Seq[(ResolvedProject, ProjectRef)] =
+    eachBuild((b, p) => p -> ProjectRef(b, p.id))
+
+  /** All the projects in the specified build. */
+  def allProjects(build: URI): Seq[ResolvedProject] = eachProject(build, identity)
+
+  /** The references to all the projects in the specified build. */
+  def allProjectRefs(build: URI): Seq[ProjectRef] = eachProject(build, p => ProjectRef(build, p.id))
+
+  /** Foreach project in each build apply the specified function. */
+  private[this] def eachBuild[A](f: (URI, ResolvedProject) => A): Seq[A] =
+    units.iterator.flatMap { case (build, unit) => unit.projects.map(f(build, _)) }.toIndexedSeq
+
+  /** Foreach project in the specified build apply the specified function. */
+  private[this] def eachProject[A](build: URI, f: ResolvedProject => A): Seq[A] =
+    units.get(build).iterator.flatMap(_.projects).map(f).toIndexedSeq
+
 }
+
 // information that is not original, but can be reconstructed from the rest of BuildStructure
 final class StructureIndex(
-  val keyMap: Map[String, AttributeKey[_]],
-  val taskToKey: Map[Task[_], ScopedKey[Task[_]]],
-  val triggers: Triggers[Task],
-  val keyIndex: KeyIndex,
-  val aggregateKeyIndex: KeyIndex)
+    val keyMap: Map[String, AttributeKey[_]],
+    val taskToKey: Map[Task[_], ScopedKey[Task[_]]],
+    val triggers: Triggers[Task],
+    val keyIndex: KeyIndex,
+    val aggregateKeyIndex: KeyIndex,
+)
 
 /**
  * A resolved build unit.  (`ResolvedBuildUnit` would be a better name to distinguish it from the loaded, but unresolved `BuildUnit`.)
  * @param unit The loaded, but unresolved [[BuildUnit]] this was resolved from.
  * @param defined The definitive map from project IDs to resolved projects.
- *                These projects have had [[Reference]]s resolved and [[AutoPlugin]]s evaluated.
+ *                These projects have had `Reference`s resolved and [[AutoPlugin]]s evaluated.
  * @param rootProjects The list of project IDs for the projects considered roots of this build.
  *                The first root project is used as the default in several situations where a project is not otherwise selected.
  */
-final class LoadedBuildUnit(val unit: BuildUnit, val defined: Map[String, ResolvedProject], val rootProjects: Seq[String], val buildSettings: Seq[Setting[_]]) extends BuildUnitBase {
+final class LoadedBuildUnit(
+    val unit: BuildUnit,
+    val defined: Map[String, ResolvedProject],
+    val rootProjects: Seq[String],
+    val buildSettings: Seq[Setting[_]]
+) extends BuildUnitBase {
+
   /**
    * The project to use as the default when one is not otherwise selected.
-   * [[LocalRootProject]] resolves to this from within the same build.
+   * `LocalRootProject` resolves to this from within the same build.
    */
-  val root = rootProjects match {
-    case Nil           => throw new java.lang.AssertionError("assertion failed: No root projects defined for build unit " + unit)
-    case Seq(root, _*) => root
-  }
+  val root = rootProjects.headOption.getOrElse(
+    throw new java.lang.AssertionError(
+      s"assertion failed: No root projects defined for build unit $unit"
+    )
+  )
 
   /** The base directory of the build unit (not the build definition).*/
   def localBase = unit.localBase
@@ -57,7 +117,8 @@ final class LoadedBuildUnit(val unit: BuildUnit, val defined: Map[String, Resolv
    * The classpath to use when compiling against this build unit's publicly visible code.
    * It includes build definition and plugin classes and classes for .sbt file statements and expressions.
    */
-  def classpath: Seq[File] = unit.definitions.target ++ unit.plugins.classpath ++ unit.definitions.dslDefinitions.classpath
+  def classpath: Seq[File] =
+    unit.definitions.target ++ unit.plugins.classpath ++ unit.definitions.dslDefinitions.classpath
 
   /**
    * The class loader to use for this build unit's publicly visible code.
@@ -67,6 +128,9 @@ final class LoadedBuildUnit(val unit: BuildUnit, val defined: Map[String, Resolv
 
   /** The imports to use for .sbt files, `consoleProject` and other contexts that use code from the build definition. */
   def imports = BuildUtil.getImports(unit)
+
+  def projects: Iterable[ResolvedProject] = defined.values
+
   override def toString = unit.toString
 }
 
@@ -92,17 +156,21 @@ final class LoadedDefinitions(
     val builds: Seq[BuildDef],
     val projects: Seq[Project],
     val buildNames: Seq[String],
-    val dslDefinitions: DefinedSbtValues) {
-  def this(base: File,
-    target: Seq[File],
-    loader: ClassLoader,
-    builds: Seq[BuildDef],
-    projects: Seq[Project],
-    buildNames: Seq[String]) = this(base, target, loader, builds, projects, buildNames, DefinedSbtValues.empty)
+    val dslDefinitions: DefinedSbtValues
+) {
+  def this(
+      base: File,
+      target: Seq[File],
+      loader: ClassLoader,
+      builds: Seq[BuildDef],
+      projects: Seq[Project],
+      buildNames: Seq[String]
+  ) = this(base, target, loader, builds, projects, buildNames, DefinedSbtValues.empty)
 }
 
 /** Auto-detected top-level modules (as in `object X`) of type `T` paired with their source names. */
 final class DetectedModules[T](val modules: Seq[(String, T)]) {
+
   /**
    * The source names of the modules.  This is "X" in `object X`, as opposed to the implementation class name "X$".
    * The names are returned in a stable order such that `names zip values` pairs a name with the actual module.
@@ -123,9 +191,14 @@ case class DetectedAutoPlugin(name: String, value: AutoPlugin, hasAutoImport: Bo
  * Auto-discovered modules for the build definition project.  These include modules defined in build definition sources
  * as well as modules in binary dependencies.
  *
- * @param builds The [[Build]]s detected in the build definition.  This does not include the default [[Build]] that sbt creates if none is defined.
+ * @param builds The [[BuildDef]]s detected in the build definition.
+ *               This does not include the default [[BuildDef]] that sbt creates if none is defined.
  */
-final class DetectedPlugins(val autoPlugins: Seq[DetectedAutoPlugin], val builds: DetectedModules[BuildDef]) {
+final class DetectedPlugins(
+    val autoPlugins: Seq[DetectedAutoPlugin],
+    val builds: DetectedModules[BuildDef]
+) {
+
   /**
    * Sequence of import expressions for the build definition.
    *  This includes the names of the [[BuildDef]], and [[DetectedAutoPlugin]] modules,
@@ -137,32 +210,26 @@ final class DetectedPlugins(val autoPlugins: Seq[DetectedAutoPlugin], val builds
     BuildUtil.importNamesRoot(autoPlugins.map(_.name).filter(nonTopLevelPlugin))
 
   private[this] lazy val (autoPluginAutoImports, topLevelAutoPluginAutoImports) =
-    autoPlugins.flatMap {
-      case DetectedAutoPlugin(name, ap, hasAutoImport) =>
-        if (hasAutoImport) Some(name)
-        else None
-    }.partition(nonTopLevelPlugin)
-
-  /** A function to select the right [[AutoPlugin]]s from [[autoPlugins]] for a [[Project]]. */
-  @deprecated("Use deducePluginsFromProject", "0.13.8")
-  lazy val deducePlugins: (Plugins, Logger) => Seq[AutoPlugin] = Plugins.deducer(autoPlugins.toList map { _.value })
+    autoPlugins
+      .flatMap {
+        case DetectedAutoPlugin(name, _, hasAutoImport) => if (hasAutoImport) Some(name) else None
+      }
+      .partition(nonTopLevelPlugin)
 
   /** Selects the right [[AutoPlugin]]s from a [[Project]]. */
-  def deducePluginsFromProject(p: Project, log: Logger): Seq[AutoPlugin] =
-    {
-      val ps0 = p.plugins
-      val allDetected = autoPlugins.toList map { _.value }
-      val detected = p match {
-        case _: GeneratedRootProject => allDetected filterNot { _ == sbt.plugins.IvyPlugin }
-        case _                       => allDetected
-      }
-      Plugins.deducer(detected)(ps0, log)
+  def deducePluginsFromProject(p: Project, log: Logger): Seq[AutoPlugin] = {
+    val ps0 = p.plugins
+    val allDetected = autoPlugins.toList map { _.value }
+    val detected = p match {
+      case _: GeneratedRootProject => allDetected filterNot { _ == sbt.plugins.IvyPlugin }
+      case _                       => allDetected
     }
+    Plugins.deducer(detected)(ps0, log)
+  }
 
   private[this] def autoImports(pluginNames: Seq[String]) = pluginNames.map(_ + ".autoImport")
 
   private[this] def nonTopLevelPlugin(name: String) = name.contains('.')
-
 }
 
 /**
@@ -173,78 +240,165 @@ final class DetectedPlugins(val autoPlugins: Seq[DetectedAutoPlugin], val builds
  * @param loader The class loader for the build definition project, notably excluding classes used for .sbt files.
  * @param detected Auto-detected modules in the build definition.
  */
-final class LoadedPlugins(val base: File, val pluginData: PluginData, val loader: ClassLoader, val detected: DetectedPlugins) {
+final class LoadedPlugins(
+    val base: File,
+    val pluginData: PluginData,
+    val loader: ClassLoader,
+    val detected: DetectedPlugins
+) {
   def fullClasspath: Seq[Attributed[File]] = pluginData.classpath
   def classpath = data(fullClasspath)
 }
+
 /**
  * The loaded, but unresolved build unit.
  * @param uri The uniquely identifying URI for the build.
  * @param localBase The working location of the build on the filesystem.
  *        For local URIs, this is the same as `uri`, but for remote URIs, this is the local copy or workspace allocated for the build.
  */
-final class BuildUnit(val uri: URI, val localBase: File, val definitions: LoadedDefinitions, val plugins: LoadedPlugins) {
-  override def toString = if (uri.getScheme == "file") localBase.toString else (uri + " (locally: " + localBase + ")")
+final class BuildUnit(
+    val uri: URI,
+    val localBase: File,
+    val definitions: LoadedDefinitions,
+    val plugins: LoadedPlugins
+) {
+  override def toString =
+    if (uri.getScheme == "file") localBase.toString else (uri + " (locally: " + localBase + ")")
 }
 
 final class LoadedBuild(val root: URI, val units: Map[URI, LoadedBuildUnit]) {
   BuildUtil.checkCycles(units)
-  def allProjectRefs: Seq[(ProjectRef, ResolvedProject)] = for ((uri, unit) <- units.toSeq; (id, proj) <- unit.defined) yield ProjectRef(uri, id) -> proj
-  def extra(data: Settings[Scope])(keyIndex: KeyIndex): BuildUtil[ResolvedProject] = BuildUtil(root, units, keyIndex, data)
+
+  def allProjectRefs: Seq[(ProjectRef, ResolvedProject)] =
+    units.iterator.flatMap {
+      case (build, unit) => unit.projects.map(p => ProjectRef(build, p.id) -> p)
+    }.toIndexedSeq
+
+  def extra(data: Settings[Scope])(keyIndex: KeyIndex): BuildUtil[ResolvedProject] =
+    BuildUtil(root, units, keyIndex, data)
 
   private[sbt] def autos = GroupedAutoPlugins(units)
 }
+
 final class PartBuild(val root: URI, val units: Map[URI, PartBuildUnit])
+
 sealed trait BuildUnitBase { def rootProjects: Seq[String]; def buildSettings: Seq[Setting[_]] }
-final class PartBuildUnit(val unit: BuildUnit, val defined: Map[String, Project], val rootProjects: Seq[String], val buildSettings: Seq[Setting[_]]) extends BuildUnitBase {
-  def resolve(f: Project => ResolvedProject): LoadedBuildUnit = new LoadedBuildUnit(unit, defined mapValues f toMap, rootProjects, buildSettings)
+
+final class PartBuildUnit(
+    val unit: BuildUnit,
+    val defined: Map[String, Project],
+    val rootProjects: Seq[String],
+    val buildSettings: Seq[Setting[_]]
+) extends BuildUnitBase {
+
+  def resolve(f: Project => ResolvedProject): LoadedBuildUnit =
+    new LoadedBuildUnit(unit, defined.mapValues(f).toMap, rootProjects, buildSettings)
+
   def resolveRefs(f: ProjectReference => ProjectRef): LoadedBuildUnit = resolve(_ resolve f)
 }
 
 object BuildStreams {
-  type Streams = std.Streams[ScopedKey[_]]
+  type Streams = sbt.std.Streams[ScopedKey[_]]
 
-  final val GlobalPath = "$global"
-  final val BuildUnitPath = "$build"
+  final val GlobalPath = "_global"
+  final val BuildUnitPath = "_build"
   final val StreamsDirectory = "streams"
+  private final val RootPath = "_root"
 
-  def mkStreams(units: Map[URI, LoadedBuildUnit], root: URI, data: Settings[Scope]): State => Streams = s =>
-    s get Keys.stateStreams getOrElse std.Streams(path(units, root, data), displayFull, LogManager.construct(data, s))
+  def mkStreams(
+      units: Map[URI, LoadedBuildUnit],
+      root: URI,
+      data: Settings[Scope]
+  ): State => Streams = s => {
+    (s get Keys.stateStreams) getOrElse {
+      std.Streams(
+        path(units, root, data)(_),
+        displayFull: ScopedKey[_] => String,
+        LogManager.construct(data, s), {
+          val factory =
+            s.get(Keys.cacheStoreFactoryFactory).getOrElse(InMemoryCacheStore.factory(0))
+          (file: File) => factory(file.toPath)
+        }
+      )
+    }
+  }
 
-  def path(units: Map[URI, LoadedBuildUnit], root: URI, data: Settings[Scope])(scoped: ScopedKey[_]): File =
+  def path(units: Map[URI, LoadedBuildUnit], root: URI, data: Settings[Scope])(
+      scoped: ScopedKey[_]
+  ): File =
     resolvePath(projectPath(units, root, scoped, data), nonProjectPath(scoped))
 
   def resolvePath(base: File, components: Seq[String]): File =
-    (base /: components)((b, p) => new File(b, p))
+    components.foldLeft(base)((b, p) => new File(b, p))
 
-  def pathComponent[T](axis: ScopeAxis[T], scoped: ScopedKey[_], label: String)(show: T => String): String =
+  def pathComponent[T](axis: ScopeAxis[T], scoped: ScopedKey[_], label: String)(
+      show: T => String
+  ): String =
     axis match {
-      case Global    => GlobalPath
-      case This      => sys.error("Unresolved This reference for " + label + " in " + displayFull(scoped))
+      case Zero      => GlobalPath
+      case This      => sys.error(s"Unresolved This reference for $label in ${displayFull(scoped)}")
       case Select(t) => show(t)
     }
-  def nonProjectPath[T](scoped: ScopedKey[T]): Seq[String] =
-    {
-      val scope = scoped.scope
-      pathComponent(scope.config, scoped, "config")(_.name) ::
-        pathComponent(scope.task, scoped, "task")(_.label) ::
-        pathComponent(scope.extra, scoped, "extra")(showAMap) ::
-        scoped.key.label ::
-        Nil
+
+  def nonProjectPath[T](scoped: ScopedKey[T]): Seq[String] = {
+    val scope = scoped.scope
+    pathComponent(scope.config, scoped, "config")(_.name) ::
+      pathComponent(scope.task, scoped, "task")(_.label) ::
+      pathComponent(scope.extra, scoped, "extra")(showAMap) ::
+      scoped.key.label :: previousComponent(scope.extra)
+  }
+
+  private def previousComponent(value: ScopeAxis[AttributeMap]): List[String] =
+    value match {
+      case Select(am) =>
+        am.get(Previous.scopedKeyAttribute) match {
+          case Some(sk) =>
+            val project = sk.scope.project match {
+              case Zero                                           => GlobalPath
+              case Select(BuildRef(_))                            => BuildUnitPath
+              case Select(ProjectRef(_, id))                      => id
+              case Select(LocalProject(id))                       => id
+              case Select(RootProject(_))                         => RootPath
+              case Select(LocalRootProject)                       => LocalRootProject.toString
+              case Select(ThisBuild) | Select(ThisProject) | This =>
+                // Don't want to crash if somehow an unresolved key makes it in here.
+                This.toString
+            }
+            List(Previous.DependencyDirectory, project) ++ nonProjectPath(sk)
+          case _ => Nil
+        }
+      case _ => Nil
     }
   def showAMap(a: AttributeMap): String =
-    a.entries.toSeq.sortBy(_.key.label).map { case AttributeEntry(key, value) => key.label + "=" + value.toString } mkString (" ")
-  def projectPath(units: Map[URI, LoadedBuildUnit], root: URI, scoped: ScopedKey[_], data: Settings[Scope]): File =
+    a.entries.toStream
+      .sortBy(_.key.label)
+      .flatMap {
+        // The Previous.scopedKeyAttribute is an implementation detail that allows us to get a
+        // more specific cache directory for a task stream.
+        case AttributeEntry(key, _) if key == Previous.scopedKeyAttribute => Nil
+        case AttributeEntry(key, value)                                   => s"${key.label}=$value" :: Nil
+      }
+      .mkString(" ")
+
+  def projectPath(
+      units: Map[URI, LoadedBuildUnit],
+      root: URI,
+      scoped: ScopedKey[_],
+      data: Settings[Scope]
+  ): File =
     scoped.scope.project match {
-      case Global                           => refTarget(GlobalScope, units(root).localBase, data) / GlobalPath
+      case Zero                             => refTarget(GlobalScope, units(root).localBase, data) / GlobalPath
       case Select(br @ BuildRef(uri))       => refTarget(br, units(uri).localBase, data) / BuildUnitPath
       case Select(pr @ ProjectRef(uri, id)) => refTarget(pr, units(uri).defined(id).base, data)
-      case Select(pr)                       => sys.error("Unresolved project reference (" + pr + ") in " + displayFull(scoped))
-      case This                             => sys.error("Unresolved project reference (This) in " + displayFull(scoped))
+      case Select(pr) =>
+        sys.error("Unresolved project reference (" + pr + ") in " + displayFull(scoped))
+      case This => sys.error("Unresolved project reference (This) in " + displayFull(scoped))
     }
 
   def refTarget(ref: ResolvedReference, fallbackBase: File, data: Settings[Scope]): File =
     refTarget(GlobalScope.copy(project = Select(ref)), fallbackBase, data)
+
+  @nowarn
   def refTarget(scope: Scope, fallbackBase: File, data: Settings[Scope]): File =
-    (Keys.target in scope get data getOrElse outputDirectory(fallbackBase).asFile) / StreamsDirectory
+    (Keys.target in scope get data getOrElse outputDirectory(fallbackBase)) / StreamsDirectory
 }
diff --git a/main/src/main/scala/sbt/internal/BuildUtil.scala b/main/src/main/scala/sbt/internal/BuildUtil.scala
index 126b60857..78611a963 100644
--- a/main/src/main/scala/sbt/internal/BuildUtil.scala
+++ b/main/src/main/scala/sbt/internal/BuildUtil.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -12,9 +19,12 @@ final class BuildUtil[Proj](
     val rootProjectID: URI => String,
     val project: (URI, String) => Proj,
     val configurations: Proj => Seq[ConfigKey],
-    val aggregates: Relation[ProjectRef, ProjectRef]) {
-  def rootProject(uri: URI): Proj =
-    project(uri, rootProjectID(uri))
+    val aggregates: Relation[ProjectRef, ProjectRef]
+) {
+
+  def thisRootProject: Proj = rootProject(root)
+
+  def rootProject(uri: URI): Proj = project(uri, rootProjectID(uri))
 
   def resolveRef(ref: Reference): ResolvedReference =
     Scope.resolveReference(root, rootProjectID, ref)
@@ -23,14 +33,14 @@ final class BuildUtil[Proj](
     case ProjectRef(uri, id) => project(uri, id)
     case BuildRef(uri)       => rootProject(uri)
   }
+
   def projectRefFor(ref: ResolvedReference): ProjectRef = ref match {
     case p: ProjectRef => p
     case BuildRef(uri) => ProjectRef(uri, rootProjectID(uri))
   }
-  def projectForAxis(ref: Option[ResolvedReference]): Proj = ref match {
-    case Some(ref) => projectFor(ref)
-    case None      => rootProject(root)
-  }
+
+  def projectForAxis(ref: Option[ResolvedReference]): Proj = ref.fold(thisRootProject)(projectFor)
+
   def exactProject(refOpt: Option[Reference]): Option[Proj] = refOpt map resolveRef flatMap {
     case ProjectRef(uri, id) => Some(project(uri, id))
     case _                   => None
@@ -38,52 +48,60 @@ final class BuildUtil[Proj](
 
   val configurationsForAxis: Option[ResolvedReference] => Seq[String] =
     refOpt => configurations(projectForAxis(refOpt)).map(_.name)
-}
-object BuildUtil {
-  def apply(root: URI, units: Map[URI, LoadedBuildUnit], keyIndex: KeyIndex, data: Settings[Scope]): BuildUtil[ResolvedProject] =
-    {
-      val getp = (build: URI, project: String) => Load.getProject(units, build, project)
-      val configs = (_: ResolvedProject).configurations.map(c => ConfigKey(c.name))
-      val aggregates = aggregationRelation(units)
-      new BuildUtil(keyIndex, data, root, Load getRootProject units, getp, configs, aggregates)
-    }
 
-  def dependencies(units: Map[URI, LoadedBuildUnit]): BuildDependencies =
-    {
-      import collection.mutable.HashMap
-      val agg = new HashMap[ProjectRef, Seq[ProjectRef]]
-      val cp = new HashMap[ProjectRef, Seq[ClasspathDep[ProjectRef]]]
-      for (lbu <- units.values; rp <- lbu.defined.values) {
-        val ref = ProjectRef(lbu.unit.uri, rp.id)
-        cp(ref) = rp.dependencies
-        agg(ref) = rp.aggregate
-      }
-      BuildDependencies(cp.toMap, agg.toMap)
+}
+
+object BuildUtil {
+  def apply(
+      root: URI,
+      units: Map[URI, LoadedBuildUnit],
+      keyIndex: KeyIndex,
+      data: Settings[Scope]
+  ): BuildUtil[ResolvedProject] = {
+    val getp = (build: URI, project: String) => Load.getProject(units, build, project)
+    val configs = (_: ResolvedProject).configurations.map(c => ConfigKey(c.name))
+    val aggregates = aggregationRelation(units)
+    new BuildUtil(keyIndex, data, root, Load.getRootProject(units), getp, configs, aggregates)
+  }
+
+  def dependencies(units: Map[URI, LoadedBuildUnit]): BuildDependencies = {
+    import scala.collection.mutable
+    val agg = new mutable.HashMap[ProjectRef, Seq[ProjectRef]]
+    val cp = new mutable.HashMap[ProjectRef, Seq[ClasspathDep[ProjectRef]]]
+    for (lbu <- units.values; rp <- lbu.projects) {
+      val ref = ProjectRef(lbu.unit.uri, rp.id)
+      cp(ref) = rp.dependencies
+      agg(ref) = rp.aggregate
     }
+    BuildDependencies(cp.toMap, agg.toMap)
+  }
 
   def checkCycles(units: Map[URI, LoadedBuildUnit]): Unit = {
     def getRef(pref: ProjectRef) = units(pref.build).defined(pref.project)
-    def deps(proj: ResolvedProject)(base: ResolvedProject => Seq[ProjectRef]): Seq[ResolvedProject] = Dag.topologicalSort(proj)(p => base(p) map getRef)
+    def deps(
+        proj: ResolvedProject
+    )(base: ResolvedProject => Seq[ProjectRef]): Seq[ResolvedProject] =
+      Dag.topologicalSort(proj)(p => base(p) map getRef)
     // check for cycles
-    for ((_, lbu) <- units; proj <- lbu.defined.values) {
+    for ((_, lbu) <- units; proj <- lbu.projects) {
       deps(proj)(_.dependencies.map(_.project))
-      deps(proj)(_.delegates)
       deps(proj)(_.aggregate)
     }
   }
 
-  def baseImports: Seq[String] = "import scala.xml.{TopScope=>$scope}" :: "import sbt._, Keys._, syntax._" :: Nil
+  def baseImports: Seq[String] =
+    "import _root_.scala.xml.{TopScope=>$scope}" :: "import _root_.sbt._" :: "import _root_.sbt.Keys._" :: "import _root_.sbt.nio.Keys._" :: Nil
 
-  def getImports(unit: BuildUnit): Seq[String] = unit.plugins.detected.imports ++ unit.definitions.dslDefinitions.imports
-
-  @deprecated("Use getImports(Seq[String]).", "0.13.2")
-  def getImports(pluginNames: Seq[String], buildNames: Seq[String]): Seq[String] = getImports(pluginNames ++ buildNames)
+  def getImports(unit: BuildUnit): Seq[String] =
+    unit.plugins.detected.imports ++ unit.definitions.dslDefinitions.imports
 
   /** `import sbt._, Keys._`, and wildcard import `._` for all names. */
   def getImports(names: Seq[String]): Seq[String] = baseImports ++ importAllRoot(names)
 
   /** Import just the names. */
-  def importNames(names: Seq[String]): Seq[String] = if (names.isEmpty) Nil else names.mkString("import ", ", ", "") :: Nil
+  def importNames(names: Seq[String]): Seq[String] =
+    if (names.isEmpty) Nil else names.mkString("import ", ", ", "") :: Nil
+
   /** Prepend `_root_` and import just the names. */
   def importNamesRoot(names: Seq[String]): Seq[String] = importNames(names map rootedName)
 
@@ -92,15 +110,14 @@ object BuildUtil {
   def importAllRoot(values: Seq[String]): Seq[String] = importAll(values map rootedName)
   def rootedName(s: String): String = if (s contains '.') "_root_." + s else s
 
-  def aggregationRelation(units: Map[URI, LoadedBuildUnit]): Relation[ProjectRef, ProjectRef] =
-    {
-      val depPairs =
-        for {
-          (uri, unit) <- units.toIterable
-          project <- unit.defined.values
-          ref = ProjectRef(uri, project.id)
-          agg <- project.aggregate
-        } yield (ref, agg)
-      Relation.empty ++ depPairs
-    }
+  def aggregationRelation(units: Map[URI, LoadedBuildUnit]): Relation[ProjectRef, ProjectRef] = {
+    val depPairs =
+      for {
+        (uri, unit) <- units.toIterable // don't lose this toIterable, doing so breaks actions/cross-multiproject & actions/update-state-fail
+        project <- unit.projects
+        ref = ProjectRef(uri, project.id)
+        agg <- project.aggregate
+      } yield (ref, agg)
+    Relation.empty ++ depPairs
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/ClassLoaderWarmup.scala b/main/src/main/scala/sbt/internal/ClassLoaderWarmup.scala
new file mode 100644
index 000000000..00159964e
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/ClassLoaderWarmup.scala
@@ -0,0 +1,40 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.util.concurrent.{ ExecutorService, Executors }
+import sbt.plugins.{ CorePlugin, IvyPlugin, JvmPlugin }
+
+private[internal] object ClassLoaderWarmup {
+  def warmup(): Unit = {
+    if (Runtime.getRuntime.availableProcessors > 1) {
+      val executorService: ExecutorService =
+        Executors.newFixedThreadPool(Runtime.getRuntime.availableProcessors - 1)
+      def submit[R](f: => R): Unit = {
+        executorService.submit(new Runnable {
+          override def run(): Unit = { f; () }
+        })
+        ()
+      }
+
+      submit(Class.forName("sbt.internal.parser.SbtParserInit").getConstructor().newInstance())
+      submit(CorePlugin.projectSettings)
+      submit(IvyPlugin.projectSettings)
+      submit(JvmPlugin.projectSettings)
+      submit(() => {
+        try {
+          val clazz = Class.forName("scala.reflect.runtime.package$")
+          clazz.getMethod("universe").invoke(clazz.getField("MODULE$").get(null))
+        } catch {
+          case _: Exception =>
+        }
+        executorService.shutdown()
+      })
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/ClassLoaders.scala b/main/src/main/scala/sbt/internal/ClassLoaders.scala
new file mode 100644
index 000000000..1c5df8aa0
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/ClassLoaders.scala
@@ -0,0 +1,227 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.File
+import java.net.URL
+import java.nio.file.Path
+
+import sbt.ClassLoaderLayeringStrategy._
+import sbt.Keys._
+import sbt.SlashSyntax0._
+import sbt.internal.classpath.ClassLoaderCache
+import sbt.internal.inc.ScalaInstance
+import sbt.internal.inc.classpath.ClasspathUtil
+import sbt.internal.util.Attributed
+import sbt.internal.util.Attributed.data
+import sbt.io.IO
+import sbt.nio.FileStamp
+import sbt.nio.FileStamp.LastModified
+import sbt.nio.Keys._
+import sbt.util.Logger
+
+private[sbt] object ClassLoaders {
+  private implicit class SeqFileOps(val files: Seq[File]) extends AnyVal {
+    def urls: Array[URL] = files.toArray.map(_.toURI.toURL)
+  }
+  private[this] val interfaceLoader = classOf[sbt.testing.Framework].getClassLoader
+  /*
+   * Get the class loader for a test task. The configuration could be IntegrationTest or Test.
+   */
+  private[sbt] def testTask: Def.Initialize[Task[ClassLoader]] = Def.task {
+    val si = scalaInstance.value
+    val cp = fullClasspath.value.map(_.data)
+    val dependencyStamps = modifiedTimes((dependencyClasspathFiles / outputFileStamps).value).toMap
+    def getLm(f: File): Long = dependencyStamps.getOrElse(f, IO.getModifiedTimeOrZero(f))
+    val rawCP = cp.map(f => f -> getLm(f))
+    val fullCP =
+      if (si.isManagedVersion) rawCP
+      else si.libraryJars.map(j => j -> IO.getModifiedTimeOrZero(j)).toSeq ++ rawCP
+    val exclude = dependencyJars(exportedProducts).value.toSet ++ si.libraryJars
+    val logger = state.value.globalLogging.full
+    val close = closeClassLoaders.value
+    val allowZombies = allowZombieClassLoaders.value
+    buildLayers(
+      strategy = classLoaderLayeringStrategy.value,
+      si = si,
+      fullCP = fullCP,
+      allDependenciesSet = dependencyJars(dependencyClasspath).value.filterNot(exclude).toSet,
+      cache = extendedClassLoaderCache.value,
+      resources = ClasspathUtil.createClasspathResources(fullCP.map(_._1.toPath), si),
+      tmp = IO.createUniqueDirectory(taskTemporaryDirectory.value),
+      scope = resolvedScoped.value.scope,
+      logger = logger,
+      close = close,
+      allowZombies = allowZombies,
+    )
+  }
+
+  private[sbt] def runner: Def.Initialize[Task[ScalaRun]] = Def.taskDyn {
+    val resolvedScope = resolvedScoped.value.scope
+    val instance = scalaInstance.value
+    val s = streams.value
+    val opts = forkOptions.value
+    val options = javaOptions.value
+    if (fork.value) {
+      s.log.debug(s"javaOptions: $options")
+      Def.task(new ForkRun(opts))
+    } else {
+      Def.task {
+        if (options.nonEmpty) {
+          val mask = ScopeMask(project = false)
+          val showJavaOptions = Scope.displayMasked(
+            (resolvedScope / javaOptions).scopedKey.scope,
+            (resolvedScope / javaOptions).key.label,
+            mask
+          )
+          val showFork = Scope.displayMasked(
+            (resolvedScope / fork).scopedKey.scope,
+            (resolvedScope / fork).key.label,
+            mask
+          )
+          s.log.warn(s"$showJavaOptions will be ignored, $showFork is set to false")
+        }
+        val exclude = dependencyJars(exportedProducts).value.toSet ++ instance.libraryJars
+        val allDeps = dependencyJars(dependencyClasspath).value.filterNot(exclude)
+        val logger = state.value.globalLogging.full
+        val allowZombies = allowZombieClassLoaders.value
+        val close = closeClassLoaders.value
+        val newLoader =
+          (classpath: Seq[File]) => {
+            val mappings = classpath.map(f => f.getName -> f).toMap
+            val cp = classpath.map(_.toPath)
+            val transformedDependencies = allDeps.map(f => mappings.getOrElse(f.getName, f))
+            buildLayers(
+              strategy = classLoaderLayeringStrategy.value: @sbtUnchecked,
+              si = instance,
+              fullCP = classpath.map(f => f -> IO.getModifiedTimeOrZero(f)),
+              allDependenciesSet = transformedDependencies.toSet,
+              cache = extendedClassLoaderCache.value: @sbtUnchecked,
+              resources = ClasspathUtil.createClasspathResources(cp, instance),
+              tmp = taskTemporaryDirectory.value: @sbtUnchecked,
+              scope = resolvedScope,
+              logger = logger,
+              close = close,
+              allowZombies = allowZombies,
+            )
+          }
+        new Run(newLoader, trapExit.value)
+      }
+    }
+  }
+
+  private[this] def extendedClassLoaderCache: Def.Initialize[Task[ClassLoaderCache]] = Def.task {
+    val errorMessage = "Tried to extract classloader cache for uninitialized state."
+    state.value
+      .get(BasicKeys.extendedClassLoaderCache)
+      .getOrElse(throw new IllegalStateException(errorMessage))
+  }
+  /*
+   * Create a layered classloader. There are up to four layers:
+   * 1) the scala instance class loader (may actually be two layers if scala-reflect is used)
+   * 2) the resource layer
+   * 3) the dependency jars
+   * 4) the rest of the classpath
+   * The first three layers may be optionally cached to reduce memory usage and improve
+   * start up latency. Because there may be mutually incompatible libraries in the runtime
+   * and test dependencies, it's important to be able to configure which layers are used.
+   */
+  private def buildLayers(
+      strategy: ClassLoaderLayeringStrategy,
+      si: ScalaInstance,
+      fullCP: Seq[(File, Long)],
+      allDependenciesSet: Set[File],
+      cache: ClassLoaderCache,
+      resources: Map[String, String],
+      tmp: File,
+      scope: Scope,
+      logger: Logger,
+      close: Boolean,
+      allowZombies: Boolean
+  ): ClassLoader = {
+    val cpFiles = fullCP.map(_._1)
+    strategy match {
+      case Flat => new FlatLoader(cpFiles.urls, interfaceLoader, tmp, close, allowZombies, logger)
+      case _ =>
+        val layerDependencies = strategy match {
+          case _: AllLibraryJars => true
+          case _                 => false
+        }
+        val scalaLibraryLayer = {
+          cache.apply(
+            si.libraryJars.map(j => j -> IO.getModifiedTimeOrZero(j)).toList,
+            interfaceLoader,
+            () => new ScalaLibraryClassLoader(si.libraryJars.map(_.toURI.toURL), interfaceLoader)
+          )
+        }
+        val cpFiles = fullCP.map(_._1)
+
+        val allDependencies = cpFiles.filter(allDependenciesSet)
+        def isReflectJar(f: File): Boolean =
+          f.getName == "scala-reflect.jar" || f.getName.startsWith("scala-reflect-")
+        val scalaReflectJar = allDependencies.collectFirst {
+          case f if isReflectJar(f) => si.allJars.find(isReflectJar)
+        }.flatten
+        val scalaReflectLayer = scalaReflectJar
+          .map { file =>
+            cache.apply(
+              file -> IO.getModifiedTimeOrZero(file) :: Nil,
+              scalaLibraryLayer,
+              () => new ScalaReflectClassLoader(file.toURI.toURL, scalaLibraryLayer)
+            )
+          }
+          .getOrElse(scalaLibraryLayer)
+
+        // layer 2 (optional if in the test config and the runtime layer is not shared)
+        val dependencyLayer: ClassLoader =
+          if (layerDependencies && allDependencies.nonEmpty) {
+            cache(
+              allDependencies.toList.map(f => f -> IO.getModifiedTimeOrZero(f)),
+              scalaReflectLayer,
+              () =>
+                new ReverseLookupClassLoaderHolder(
+                  allDependencies,
+                  scalaReflectLayer,
+                  close,
+                  allowZombies,
+                  logger
+                )
+            )
+          } else scalaReflectLayer
+
+        val scalaJarNames = (si.libraryJars ++ scalaReflectJar).map(_.getName).toSet
+        // layer 3
+        val filteredSet =
+          if (layerDependencies) allDependencies.toSet ++ si.libraryJars ++ scalaReflectJar
+          else Set(si.libraryJars ++ scalaReflectJar: _*)
+        val dynamicClasspath = cpFiles.filterNot(f => filteredSet(f) || scalaJarNames(f.getName))
+        dependencyLayer match {
+          case dl: ReverseLookupClassLoaderHolder =>
+            dl.checkout(cpFiles, tmp)
+          case cl =>
+            cl.getParent match {
+              case dl: ReverseLookupClassLoaderHolder => dl.checkout(cpFiles, tmp)
+              case _ =>
+                new LayeredClassLoader(dynamicClasspath.urls, cl, tmp, close, allowZombies, logger)
+            }
+        }
+    }
+  }
+
+  private def dependencyJars(
+      key: sbt.TaskKey[Seq[Attributed[File]]]
+  ): Def.Initialize[Task[Seq[File]]] = Def.task(data(key.value).filter(_.getName.endsWith(".jar")))
+
+  private[this] def modifiedTimes(stamps: Seq[(Path, FileStamp)]): Seq[(File, Long)] = stamps.map {
+    case (p, LastModified(lm)) => p.toFile -> lm
+    case (p, _) =>
+      val f = p.toFile
+      f -> IO.getModifiedTimeOrZero(f)
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/ClasspathImpl.scala b/main/src/main/scala/sbt/internal/ClasspathImpl.scala
new file mode 100644
index 000000000..43f35dbd8
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/ClasspathImpl.scala
@@ -0,0 +1,434 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.File
+import java.util.LinkedHashSet
+import sbt.SlashSyntax0._
+import sbt.Keys._
+import sbt.nio.Keys._
+import sbt.nio.file.{ Glob, RecursiveGlob }
+import sbt.Def.Initialize
+import sbt.internal.inc.Analysis
+import sbt.internal.inc.JavaInterfaceUtil._
+import sbt.internal.util.{ Attributed, Dag, Settings }
+import sbt.librarymanagement.{ Configuration, TrackLevel }
+import sbt.librarymanagement.Configurations.names
+import sbt.std.TaskExtra._
+import sbt.util._
+import scala.collection.JavaConverters._
+import xsbti.compile.CompileAnalysis
+
+private[sbt] object ClasspathImpl {
+
+  // Since we can't predict the path for pickleProduct,
+  // we can't reduce the track level.
+  def exportedPicklesTask: Initialize[Task[VirtualClasspath]] =
+    Def.task {
+      // conditional task: do not refactor
+      if (exportPipelining.value) {
+        val module = projectID.value
+        val config = configuration.value
+        val products = pickleProducts.value
+        val analysis = compileEarly.value
+        val xs = products map { _ -> analysis }
+        for { (f, analysis) <- xs } yield APIMappings
+          .store(analyzed(f, analysis), apiURL.value)
+          .put(moduleID.key, module)
+          .put(configuration.key, config)
+      } else {
+        val c = fileConverter.value
+        val ps = exportedProducts.value
+        ps.map(attr => attr.map(x => c.toVirtualFile(x.toPath)))
+      }
+    }
+
+  def trackedExportedProducts(track: TrackLevel): Initialize[Task[Classpath]] =
+    Def.task {
+      val _ = (packageBin / dynamicDependency).value
+      val art = (packageBin / artifact).value
+      val module = projectID.value
+      val config = configuration.value
+      for { (f, analysis) <- trackedExportedProductsImplTask(track).value } yield APIMappings
+        .store(analyzed(f, analysis), apiURL.value)
+        .put(artifact.key, art)
+        .put(moduleID.key, module)
+        .put(configuration.key, config)
+    }
+
+  def trackedExportedJarProducts(track: TrackLevel): Initialize[Task[Classpath]] =
+    Def.task {
+      val _ = (packageBin / dynamicDependency).value
+      val art = (packageBin / artifact).value
+      val module = projectID.value
+      val config = configuration.value
+      for { (f, analysis) <- trackedJarProductsImplTask(track).value } yield APIMappings
+        .store(analyzed(f, analysis), apiURL.value)
+        .put(artifact.key, art)
+        .put(moduleID.key, module)
+        .put(configuration.key, config)
+    }
+
+  private[this] def trackedExportedProductsImplTask(
+      track: TrackLevel
+  ): Initialize[Task[Seq[(File, CompileAnalysis)]]] =
+    Def.taskDyn {
+      val _ = (packageBin / dynamicDependency).value
+      val useJars = exportJars.value
+      if (useJars) trackedJarProductsImplTask(track)
+      else trackedNonJarProductsImplTask(track)
+    }
+
+  private[this] def trackedNonJarProductsImplTask(
+      track: TrackLevel
+  ): Initialize[Task[Seq[(File, CompileAnalysis)]]] =
+    Def.taskDyn {
+      val dirs = productDirectories.value
+      val view = fileTreeView.value
+      def containsClassFile(): Boolean =
+        view.list(dirs.map(Glob(_, RecursiveGlob / "*.class"))).nonEmpty
+      TrackLevel.intersection(track, exportToInternal.value) match {
+        case TrackLevel.TrackAlways =>
+          Def.task {
+            products.value map { (_, compile.value) }
+          }
+        case TrackLevel.TrackIfMissing if !containsClassFile() =>
+          Def.task {
+            products.value map { (_, compile.value) }
+          }
+        case _ =>
+          Def.task {
+            val analysis = previousCompile.value.analysis.toOption.getOrElse(Analysis.empty)
+            dirs.map(_ -> analysis)
+          }
+      }
+    }
+
+  private[this] def trackedJarProductsImplTask(
+      track: TrackLevel
+  ): Initialize[Task[Seq[(File, CompileAnalysis)]]] =
+    Def.taskDyn {
+      val jar = (packageBin / artifactPath).value
+      TrackLevel.intersection(track, exportToInternal.value) match {
+        case TrackLevel.TrackAlways =>
+          Def.task {
+            Seq((packageBin.value, compile.value))
+          }
+        case TrackLevel.TrackIfMissing if !jar.exists =>
+          Def.task {
+            Seq((packageBin.value, compile.value))
+          }
+        case _ =>
+          Def.task {
+            val analysisOpt = previousCompile.value.analysis.toOption
+            Seq(jar) map { x =>
+              (
+                x,
+                if (analysisOpt.isDefined) analysisOpt.get
+                else Analysis.empty
+              )
+            }
+          }
+      }
+    }
+
+  def internalDependencyClasspathTask: Initialize[Task[Classpath]] = {
+    Def.taskDyn {
+      val _ = (
+        (exportedProductsNoTracking / transitiveClasspathDependency).value,
+        (exportedProductsIfMissing / transitiveClasspathDependency).value,
+        (exportedProducts / transitiveClasspathDependency).value,
+        (exportedProductJarsNoTracking / transitiveClasspathDependency).value,
+        (exportedProductJarsIfMissing / transitiveClasspathDependency).value,
+        (exportedProductJars / transitiveClasspathDependency).value
+      )
+      internalDependenciesImplTask(
+        thisProjectRef.value,
+        classpathConfiguration.value,
+        configuration.value,
+        settingsData.value,
+        buildDependencies.value,
+        trackInternalDependencies.value,
+        streams.value.log,
+      )
+    }
+  }
+
+  def internalDependenciesImplTask(
+      projectRef: ProjectRef,
+      conf: Configuration,
+      self: Configuration,
+      data: Settings[Scope],
+      deps: BuildDependencies,
+      track: TrackLevel,
+      log: Logger
+  ): Initialize[Task[Classpath]] =
+    Def.value {
+      interDependencies(projectRef, deps, conf, self, data, track, false, log)(
+        exportedProductsNoTracking,
+        exportedProductsIfMissing,
+        exportedProducts
+      )
+    }
+
+  def internalDependencyPicklePathTask: Initialize[Task[VirtualClasspath]] = {
+    def implTask(
+        projectRef: ProjectRef,
+        conf: Configuration,
+        self: Configuration,
+        data: Settings[Scope],
+        deps: BuildDependencies,
+        track: TrackLevel,
+        log: Logger
+    ): Initialize[Task[VirtualClasspath]] =
+      Def.value {
+        interDependencies(projectRef, deps, conf, self, data, track, false, log)(
+          exportedPickles,
+          exportedPickles,
+          exportedPickles
+        )
+      }
+    Def.taskDyn {
+      implTask(
+        thisProjectRef.value,
+        classpathConfiguration.value,
+        configuration.value,
+        settingsData.value,
+        buildDependencies.value,
+        TrackLevel.TrackAlways,
+        streams.value.log,
+      )
+    }
+  }
+
+  def internalDependencyJarsTask: Initialize[Task[Classpath]] =
+    Def.taskDyn {
+      internalDependencyJarsImplTask(
+        thisProjectRef.value,
+        classpathConfiguration.value,
+        configuration.value,
+        settingsData.value,
+        buildDependencies.value,
+        trackInternalDependencies.value,
+        streams.value.log,
+      )
+    }
+
+  private def internalDependencyJarsImplTask(
+      projectRef: ProjectRef,
+      conf: Configuration,
+      self: Configuration,
+      data: Settings[Scope],
+      deps: BuildDependencies,
+      track: TrackLevel,
+      log: Logger
+  ): Initialize[Task[Classpath]] =
+    Def.value {
+      interDependencies(projectRef, deps, conf, self, data, track, false, log)(
+        exportedProductJarsNoTracking,
+        exportedProductJarsIfMissing,
+        exportedProductJars
+      )
+    }
+
+  def unmanagedDependenciesTask: Initialize[Task[Classpath]] =
+    Def.taskDyn {
+      unmanagedDependencies0(
+        thisProjectRef.value,
+        configuration.value,
+        settingsData.value,
+        buildDependencies.value,
+        streams.value.log
+      )
+    }
+
+  def unmanagedDependencies0(
+      projectRef: ProjectRef,
+      conf: Configuration,
+      data: Settings[Scope],
+      deps: BuildDependencies,
+      log: Logger
+  ): Initialize[Task[Classpath]] =
+    Def.value {
+      interDependencies(
+        projectRef,
+        deps,
+        conf,
+        conf,
+        data,
+        TrackLevel.TrackAlways,
+        true,
+        log
+      )(
+        unmanagedJars,
+        unmanagedJars,
+        unmanagedJars
+      )
+    }
+
+  def unmanagedLibs(
+      dep: ResolvedReference,
+      conf: String,
+      data: Settings[Scope]
+  ): Task[Classpath] =
+    getClasspath(unmanagedJars, dep, conf, data)
+
+  def interDependencies[A](
+      projectRef: ProjectRef,
+      deps: BuildDependencies,
+      conf: Configuration,
+      self: Configuration,
+      data: Settings[Scope],
+      track: TrackLevel,
+      includeSelf: Boolean,
+      log: Logger
+  )(
+      noTracking: TaskKey[Seq[A]],
+      trackIfMissing: TaskKey[Seq[A]],
+      trackAlways: TaskKey[Seq[A]]
+  ): Task[Seq[A]] = {
+    val interDepConfigs = interSort(projectRef, conf, data, deps) filter {
+      case (dep, c) =>
+        includeSelf || (dep != projectRef) || (conf.name != c && self.name != c)
+    }
+    val tasks = (new LinkedHashSet[Task[Seq[A]]]).asScala
+    for {
+      (dep, c) <- interDepConfigs
+    } {
+      tasks += (track match {
+        case TrackLevel.NoTracking =>
+          getClasspath(noTracking, dep, c, data)
+        case TrackLevel.TrackIfMissing =>
+          getClasspath(trackIfMissing, dep, c, data)
+        case TrackLevel.TrackAlways =>
+          getClasspath(trackAlways, dep, c, data)
+      })
+    }
+    (tasks.toSeq.join).map(_.flatten.distinct)
+  }
+
+  def analyzed[A](data: A, analysis: CompileAnalysis) =
+    Attributed.blank(data).put(Keys.analysis, analysis)
+
+  def interSort(
+      projectRef: ProjectRef,
+      conf: Configuration,
+      data: Settings[Scope],
+      deps: BuildDependencies
+  ): Seq[(ProjectRef, String)] = {
+    val visited = (new LinkedHashSet[(ProjectRef, String)]).asScala
+    def visit(p: ProjectRef, c: Configuration): Unit = {
+      val applicableConfigs = allConfigs(c)
+      for {
+        ac <- applicableConfigs
+      } // add all configurations in this project
+      visited add (p -> ac.name)
+      val masterConfs = names(getConfigurations(projectRef, data).toVector)
+
+      for {
+        ResolvedClasspathDependency(dep, confMapping) <- deps.classpath(p)
+      } {
+        val configurations = getConfigurations(dep, data)
+        val mapping =
+          mapped(confMapping, masterConfs, names(configurations.toVector), "compile", "*->compile")
+        // map master configuration 'c' and all extended configurations to the appropriate dependency configuration
+        for {
+          ac <- applicableConfigs
+          depConfName <- mapping(ac.name)
+        } {
+          for {
+            depConf <- confOpt(configurations, depConfName)
+          } if (!visited((dep, depConfName))) {
+            visit(dep, depConf)
+          }
+        }
+      }
+    }
+    visit(projectRef, conf)
+    visited.toSeq
+  }
+
+  def mapped(
+      confString: Option[String],
+      masterConfs: Seq[String],
+      depConfs: Seq[String],
+      default: String,
+      defaultMapping: String
+  ): String => Seq[String] = {
+    lazy val defaultMap = parseMapping(defaultMapping, masterConfs, depConfs, _ :: Nil)
+    parseMapping(confString getOrElse default, masterConfs, depConfs, defaultMap)
+  }
+
+  def parseMapping(
+      confString: String,
+      masterConfs: Seq[String],
+      depConfs: Seq[String],
+      default: String => Seq[String]
+  ): String => Seq[String] =
+    union(confString.split(";") map parseSingleMapping(masterConfs, depConfs, default))
+
+  def parseSingleMapping(
+      masterConfs: Seq[String],
+      depConfs: Seq[String],
+      default: String => Seq[String]
+  )(confString: String): String => Seq[String] = {
+    val ms: Seq[(String, Seq[String])] =
+      trim(confString.split("->", 2)) match {
+        case x :: Nil => for (a <- parseList(x, masterConfs)) yield (a, default(a))
+        case x :: y :: Nil =>
+          val target = parseList(y, depConfs);
+          for (a <- parseList(x, masterConfs)) yield (a, target)
+        case _ => sys.error("Invalid configuration '" + confString + "'") // shouldn't get here
+      }
+    val m = ms.toMap
+    s => m.getOrElse(s, Nil)
+  }
+
+  def union[A, B](maps: Seq[A => Seq[B]]): A => Seq[B] =
+    a => maps.foldLeft(Seq[B]()) { _ ++ _(a) } distinct;
+
+  def parseList(s: String, allConfs: Seq[String]): Seq[String] =
+    (trim(s split ",") flatMap replaceWildcard(allConfs)).distinct
+
+  def replaceWildcard(allConfs: Seq[String])(conf: String): Seq[String] = conf match {
+    case ""  => Nil
+    case "*" => allConfs
+    case _   => conf :: Nil
+  }
+
+  private def trim(a: Array[String]): List[String] = a.toList.map(_.trim)
+
+  def allConfigs(conf: Configuration): Seq[Configuration] =
+    Dag.topologicalSort(conf)(_.extendsConfigs)
+
+  def getConfigurations(p: ResolvedReference, data: Settings[Scope]): Seq[Configuration] =
+    (p / ivyConfigurations).get(data).getOrElse(Nil)
+
+  def confOpt(configurations: Seq[Configuration], conf: String): Option[Configuration] =
+    configurations.find(_.name == conf)
+
+  def getClasspath[A](
+      key: TaskKey[Seq[A]],
+      dep: ResolvedReference,
+      conf: Configuration,
+      data: Settings[Scope]
+  ): Task[Seq[A]] = getClasspath(key, dep, conf.name, data)
+
+  def getClasspath[A](
+      key: TaskKey[Seq[A]],
+      dep: ResolvedReference,
+      conf: String,
+      data: Settings[Scope]
+  ): Task[Seq[A]] =
+    (dep / ConfigKey(conf) / key).get(data) match {
+      case Some(x) => x
+      case _       => constant(Nil)
+    }
+
+}
diff --git a/main/src/main/scala/sbt/internal/Clean.scala b/main/src/main/scala/sbt/internal/Clean.scala
new file mode 100644
index 000000000..c55a0f90a
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/Clean.scala
@@ -0,0 +1,163 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.IOException
+import java.nio.file.{ DirectoryNotEmptyException, Files, Path }
+
+import sbt.Def._
+import sbt.Keys._
+import sbt.Project.richInitializeTask
+import sbt.SlashSyntax0._
+import sbt.io.syntax._
+import sbt.nio.Keys._
+import sbt.nio.file._
+import sbt.nio.file.syntax._
+import sbt.util.Level
+import sjsonnew.JsonFormat
+import scala.annotation.nowarn
+
+private[sbt] object Clean {
+
+  private[sbt] def deleteContents(file: File, exclude: File => Boolean): Unit =
+    deleteContents(
+      file.toPath,
+      path => exclude(path.toFile),
+      FileTreeView.default,
+      tryDelete((_: String) => {})
+    )
+  private[this] def deleteContents(
+      path: Path,
+      exclude: Path => Boolean,
+      view: FileTreeView.Nio[FileAttributes],
+      delete: Path => Unit
+  ): Unit = {
+    def deleteRecursive(path: Path): Unit = {
+      view
+        .list(Glob(path, AnyPath))
+        .filterNot { case (p, _) => exclude(p) }
+        .foreach {
+          case (dir, attrs) if attrs.isDirectory && !attrs.isSymbolicLink =>
+            deleteRecursive(dir)
+            delete(dir)
+          case (file, _) => delete(file)
+        }
+    }
+    deleteRecursive(path)
+  }
+
+  private[this] def cleanFilter(scope: Scope): Def.Initialize[Task[Path => Boolean]] = Def.task {
+    val excludes = (scope / cleanKeepFiles).value.map {
+      // This mimics the legacy behavior of cleanFilesTask
+      case f if f.isDirectory => Glob(f, AnyPath)
+      case f                  => f.toGlob
+    } ++ (scope / cleanKeepGlobs).value
+    p: Path => excludes.exists(_.matches(p))
+  }
+  private[this] def cleanDelete(scope: Scope): Def.Initialize[Task[Path => Unit]] = Def.task {
+    // Don't use a regular logger because the logger actually writes to the target directory.
+    val debug = (scope / logLevel).?.value.orElse(state.value.get(logLevel.key)) match {
+      case Some(Level.Debug) =>
+        (string: String) => println(s"[debug] $string")
+      case _ =>
+        (_: String) => {}
+    }
+    tryDelete(debug)
+  }
+
+  /**
+   * Implements the clean task in a given scope. It uses the outputs task value in the provided
+   * scope to determine which files to delete.
+   *
+   * @param scope the scope in which the clean task is implemented
+   * @return the clean task definition.
+   */
+  private[sbt] def task(
+      scope: Scope,
+      full: Boolean
+  ): Def.Initialize[Task[Unit]] =
+    Def.taskDyn {
+      val state = Keys.state.value
+      val extracted = Project.extract(state)
+      val view = (scope / fileTreeView).value
+      val manager = streamsManager.value
+      Def.task {
+        val excludeFilter = cleanFilter(scope).value
+        val delete = cleanDelete(scope).value
+        val targetDir = (scope / target).?.value.map(_.toPath)
+
+        targetDir.filter(_ => full).foreach(deleteContents(_, excludeFilter, view, delete))
+        (scope / cleanFiles).?.value.getOrElse(Nil).foreach { x =>
+          if (x.isDirectory) deleteContents(x.toPath, excludeFilter, view, delete)
+          else delete(x.toPath)
+        }
+
+        // This is the special portion of the task where we clear out the relevant streams
+        // and file outputs of a task.
+        val streamsKey = scope.task.toOption.map(k => ScopedKey(scope.copy(task = Zero), k))
+        val stampsKey =
+          extracted.structure.data.getDirect(scope, inputFileStamps.key) match {
+            case Some(_) => ScopedKey(scope, inputFileStamps.key) :: Nil
+            case _       => Nil
+          }
+        val streamsGlobs =
+          (streamsKey.toSeq ++ stampsKey).map(k => manager(k).cacheDirectory.toGlob / **)
+        ((scope / fileOutputs).value.filter(g => targetDir.fold(true)(g.base.startsWith)) ++ streamsGlobs)
+          .foreach { g =>
+            val filter: Path => Boolean = { path =>
+              !g.matches(path) || excludeFilter(path)
+            }
+            deleteContents(g.base, filter, FileTreeView.default, delete)
+            delete(g.base)
+          }
+      }
+    } tag Tags.Clean
+  private[sbt] trait ToSeqPath[T] {
+    def apply(t: T): Seq[Path]
+  }
+  private[sbt] object ToSeqPath {
+    implicit val identitySeqPath: ToSeqPath[Seq[Path]] = identity _
+    implicit val seqFile: ToSeqPath[Seq[File]] = _.map(_.toPath)
+    implicit val path: ToSeqPath[Path] = _ :: Nil
+    implicit val file: ToSeqPath[File] = _.toPath :: Nil
+  }
+  private[this] implicit class ToSeqPathOps[T](val t: T) extends AnyVal {
+    def toSeqPath(implicit toSeqPath: ToSeqPath[T]): Seq[Path] = toSeqPath(t)
+  }
+
+  @nowarn
+  private[sbt] def cleanFileOutputTask[T: JsonFormat: ToSeqPath](
+      taskKey: TaskKey[T]
+  ): Def.Initialize[Task[Unit]] =
+    Def.taskDyn {
+      val scope = taskKey.scope in taskKey.key
+      Def.task {
+        val targetDir = (scope / target).value.toPath
+        val filter = cleanFilter(scope).value
+        // We do not want to inadvertently delete files that are not in the target directory.
+        val excludeFilter: Path => Boolean = path => !path.startsWith(targetDir) || filter(path)
+        val delete = cleanDelete(scope).value
+        val st = (scope / streams).value
+        taskKey.previous.foreach(_.toSeqPath.foreach(p => if (!excludeFilter(p)) delete(p)))
+        delete(st.cacheDirectory.toPath / Previous.DependencyDirectory)
+      }
+    } tag Tags.Clean
+  private[this] def tryDelete(debug: String => Unit): Path => Unit = path => {
+    try {
+      debug(s"clean -- deleting file $path")
+      Files.deleteIfExists(path)
+      ()
+    } catch {
+      case _: DirectoryNotEmptyException =>
+        debug(s"clean -- unable to delete non-empty directory $path")
+      case e: IOException =>
+        debug(s"Caught unexpected exception $e deleting $path")
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/CommandExchange.scala b/main/src/main/scala/sbt/internal/CommandExchange.scala
new file mode 100644
index 000000000..36059cdc3
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/CommandExchange.scala
@@ -0,0 +1,510 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+package internal
+import java.io.IOException
+import java.net.Socket
+import java.util.concurrent.atomic._
+import java.util.concurrent.{ LinkedBlockingQueue, TimeUnit }
+
+import sbt.BasicCommandStrings.{
+  Cancel,
+  CompleteExec,
+  Shutdown,
+  TerminateAction,
+  networkExecPrefix
+}
+import sbt.BasicKeys._
+import sbt.internal.protocol.JsonRpcResponseError
+import sbt.internal.server._
+import sbt.internal.ui.UITask
+import sbt.internal.util._
+import sbt.io.syntax._
+import sbt.io.{ Hash, IO }
+import sbt.nio.Watch.NullLogger
+import sbt.protocol.Serialization.attach
+import sbt.protocol.{ ExecStatusEvent, LogEvent }
+import sbt.util.Logger
+import sjsonnew.JsonFormat
+
+import scala.annotation.tailrec
+import scala.collection.mutable.ListBuffer
+import scala.concurrent.Await
+import scala.concurrent.duration._
+import scala.util.{ Failure, Success, Try }
+
+/**
+ * The command exchange merges multiple command channels (e.g. network and console),
+ * and acts as the central multiplexing point.
+ * Instead of blocking on JLine.readLine, the server command will block on
+ * this exchange, which could serve command request from either of the channel.
+ */
+private[sbt] final class CommandExchange {
+  private val autoStartServerSysProp =
+    sys.props get "sbt.server.autostart" forall (_.toLowerCase == "true")
+  private var server: Option[ServerInstance] = None
+  private val firstInstance: AtomicBoolean = new AtomicBoolean(true)
+  private val monitoringActiveJson: AtomicBoolean = new AtomicBoolean(false)
+  private val commandQueue: LinkedBlockingQueue[Exec] = new LinkedBlockingQueue[Exec]
+  private val channelBuffer: ListBuffer[CommandChannel] = new ListBuffer()
+  private val channelBufferLock = new AnyRef {}
+  private val fastTrackChannelQueue = new LinkedBlockingQueue[FastTrackTask]
+  private val nextChannelId: AtomicInteger = new AtomicInteger(0)
+  private[this] val lastState = new AtomicReference[State]
+  private[this] val currentExecRef = new AtomicReference[Exec]
+  private[sbt] def hasServer = server.isDefined
+  addConsoleChannel()
+
+  def channels: List[CommandChannel] = channelBuffer.toList
+
+  def subscribe(c: CommandChannel): Unit = channelBufferLock.synchronized {
+    channelBuffer.append(c)
+    c.register(commandQueue, fastTrackChannelQueue)
+  }
+
+  private[sbt] def withState[T](f: State => T): T = f(lastState.get)
+  def blockUntilNextExec: Exec = blockUntilNextExec(Duration.Inf, NullLogger)
+  // periodically move all messages from all the channels
+  private[sbt] def blockUntilNextExec(interval: Duration, logger: Logger): Exec =
+    blockUntilNextExec(interval, None, logger)
+  private[sbt] def blockUntilNextExec(
+      interval: Duration,
+      state: Option[State],
+      logger: Logger
+  ): Exec = {
+    val idleDeadline = state.flatMap { s =>
+      lastState.set(s)
+      s.get(BasicKeys.serverIdleTimeout) match {
+        case Some(Some(d)) => Some(d.fromNow)
+        case _             => None
+      }
+    }
+    @tailrec def impl(gcDeadline: Option[Deadline], idleDeadline: Option[Deadline]): Exec = {
+      state.foreach(s => prompt(ConsolePromptEvent(s)))
+      def poll: Option[Exec] = {
+        val deadline = gcDeadline.toSeq ++ idleDeadline match {
+          case s @ Seq(_, _) => Some(s.min)
+          case s             => s.headOption
+        }
+        try Option(deadline match {
+          case Some(d: Deadline) =>
+            commandQueue.poll(d.timeLeft.toMillis + 1, TimeUnit.MILLISECONDS) match {
+              case null if idleDeadline.fold(false)(_.isOverdue) =>
+                state.foreach { s =>
+                  s.get(BasicKeys.serverIdleTimeout) match {
+                    case Some(Some(d)) => s.log.info(s"sbt idle timeout of $d expired")
+                    case _             =>
+                  }
+                }
+                Exec(TerminateAction, Some(CommandSource(ConsoleChannel.defaultName)))
+              case x => x
+            }
+          case _ => commandQueue.take
+        })
+        catch { case _: InterruptedException => None }
+      }
+      poll match {
+        case Some(exec) if exec.source.fold(true)(s => channels.exists(_.name == s.channelName)) =>
+          exec.commandLine match {
+            case `TerminateAction`
+                if exec.source.fold(false)(_.channelName.startsWith("network")) =>
+              channels.collectFirst {
+                case c: NetworkChannel if exec.source.fold(false)(_.channelName == c.name) => c
+              } match {
+                case Some(c) if c.isAttached =>
+                  c.shutdown(false)
+                  impl(gcDeadline, idleDeadline)
+                case _ => exec
+              }
+            case _ => exec
+          }
+        case Some(e) => e
+        case None =>
+          val newDeadline = if (gcDeadline.fold(false)(_.isOverdue())) {
+            GCUtil.forceGcWithInterval(interval, logger)
+            None
+          } else gcDeadline
+          impl(newDeadline, idleDeadline)
+      }
+    }
+    // Do not manually run GC until the user has been idling for at least the min gc interval.
+    impl(interval match {
+      case d: FiniteDuration => Some(d.fromNow)
+      case _                 => None
+    }, idleDeadline)
+  }
+
+  private def addConsoleChannel(): Unit =
+    if (!Terminal.startedByRemoteClient) {
+      val name = ConsoleChannel.defaultName
+      subscribe(new ConsoleChannel(name, mkAskUser(name)))
+    }
+  def run(s: State): State = run(s, s.get(autoStartServer).getOrElse(true))
+  def run(s: State, autoStart: Boolean): State = {
+    if (autoStartServerSysProp && autoStart) runServer(s)
+    else s
+  }
+  private[sbt] def setState(s: State): Unit = lastState.set(s)
+
+  private def newNetworkName: String = s"network-${nextChannelId.incrementAndGet()}"
+
+  private[sbt] def removeChannel(c: CommandChannel): Unit = {
+    channelBufferLock.synchronized {
+      Util.ignoreResult(channelBuffer -= c)
+    }
+    commandQueue.removeIf { e =>
+      e.source.map(_.channelName) == Some(c.name) && e.commandLine != Shutdown
+    }
+    currentExec.filter(_.source.map(_.channelName) == Some(c.name)).foreach { e =>
+      Util.ignoreResult(NetworkChannel.cancel(e.execId, e.execId.getOrElse("0"), force = false))
+    }
+    try commandQueue.put(Exec(s"${ContinuousCommands.stopWatch} ${c.name}", None))
+    catch { case _: InterruptedException => }
+  }
+
+  private[this] def mkAskUser(
+      name: String,
+  ): (State, CommandChannel) => UITask = { (state, channel) =>
+    ContinuousCommands
+      .watchUITaskFor(state, channel)
+      .getOrElse(new UITask.AskUserTask(state, channel))
+  }
+
+  private[sbt] def currentExec = Option(currentExecRef.get)
+
+  /**
+   * Check if a server instance is running already, and start one if it isn't.
+   */
+  private[sbt] def runServer(s: State): State = {
+    lazy val port = s.get(serverPort).getOrElse(5001)
+    lazy val host = s.get(serverHost).getOrElse("127.0.0.1")
+    lazy val auth: Set[ServerAuthentication] =
+      s.get(serverAuthentication).getOrElse(Set(ServerAuthentication.Token))
+    lazy val connectionType = s.get(serverConnectionType).getOrElse(ConnectionType.Tcp)
+    lazy val handlers = s.get(fullServerHandlers).getOrElse(Nil)
+    lazy val win32Level = s.get(windowsServerSecurityLevel).getOrElse(2)
+    lazy val useJni = s.get(serverUseJni).getOrElse(false)
+    lazy val enableBsp = s.get(bspEnabled).getOrElse(true)
+    lazy val portfile = s.baseDir / "project" / "target" / "active.json"
+
+    def onIncomingSocket(socket: Socket, instance: ServerInstance): Unit = {
+      val name = newNetworkName
+      Terminal.consoleLog(s"new client connected: $name")
+      val channel =
+        new NetworkChannel(
+          name,
+          socket,
+          auth,
+          instance,
+          handlers,
+          mkAskUser(name),
+        )
+      subscribe(channel)
+    }
+    if (server.isEmpty && firstInstance.get) {
+      val h = Hash.halfHashString(IO.toURI(portfile).toString)
+      val serverDir =
+        sys.env get "SBT_GLOBAL_SERVER_DIR" map file getOrElse BuildPaths.getGlobalBase(s) / "server"
+      val tokenfile = serverDir / h / "token.json"
+      val socketfile = serverDir / h / "sock"
+      val pipeName = "sbt-server-" + h
+      val connection = ServerConnection(
+        connectionType,
+        host,
+        port,
+        auth,
+        portfile,
+        tokenfile,
+        socketfile,
+        pipeName,
+        s.configuration,
+        win32Level,
+        useJni,
+        enableBsp,
+      )
+      val serverInstance = Server.start(connection, onIncomingSocket, s.log)
+      // don't throw exception when it times out
+      val d = "10s"
+      Try(Await.ready(serverInstance.ready, Duration(d)))
+      serverInstance.ready.value match {
+        case Some(Success(())) =>
+          // remember to shutdown only when the server comes up
+          server = Some(serverInstance)
+          s.log.info("started sbt server")
+        case Some(Failure(_: AlreadyRunningException)) =>
+          s.log.warn(
+            "sbt server could not start because there's another instance of sbt running on this build."
+          )
+          s.log.warn("Running multiple instances is unsupported")
+          server = None
+          firstInstance.set(false)
+        case Some(Failure(e)) =>
+          s.log.error(e.toString)
+          server = None
+        case None =>
+          s.log.warn(s"sbt server could not start in $d")
+          server = None
+          firstInstance.set(false)
+      }
+      Terminal.setBootStreams(null, null)
+
+      if (s.get(BasicKeys.detachStdio).getOrElse(false)) {
+        Terminal.close()
+      }
+
+      s.get(Keys.bootServerSocket).foreach(_.close())
+    }
+    if (server.isEmpty && !monitoringActiveJson.get) {
+      s.get(sbt.nio.Keys.globalFileTreeRepository) match {
+        case Some(r) =>
+          r.register(sbt.nio.file.Glob(portfile)) match {
+            case Right(o) =>
+              o.addObserver { event =>
+                if (!event.exists) {
+                  firstInstance.set(true)
+                  monitoringActiveJson.set(false)
+                  // FailureWall is effectively a no-op command that will
+                  // cause shell to re-run which should start the server
+                  commandQueue.add(Exec(BasicCommandStrings.FailureWall, None))
+                  o.close()
+                }
+              }
+              monitoringActiveJson.set(true)
+            case _ =>
+          }
+        case _ =>
+      }
+    }
+    s.remove(Keys.bootServerSocket)
+  }
+
+  def shutdown(): Unit = {
+    fastTrackThread.close()
+    channels foreach (_.shutdown(true))
+    // interrupt and kill the thread
+    server.foreach(_.shutdown())
+    server = None
+  }
+
+  // This is an interface to directly respond events.
+  private[sbt] def respondError(
+      code: Long,
+      message: String,
+      execId: Option[String],
+      source: Option[CommandSource]
+  ): Unit = {
+    respondError(JsonRpcResponseError(code, message), execId, source)
+  }
+
+  private[sbt] def respondError(
+      err: JsonRpcResponseError,
+      execId: Option[String],
+      source: Option[CommandSource]
+  ): Unit = {
+    for {
+      source <- source.map(_.channelName)
+      channel <- channels.collectFirst {
+        // broadcast to the source channel only
+        case c: NetworkChannel if c.name == source => c
+      }
+    } tryTo(_.respondError(err, execId))(channel)
+  }
+
+  // This is an interface to directly respond events.
+  private[sbt] def respondEvent[A: JsonFormat](
+      event: A,
+      execId: Option[String],
+      source: Option[CommandSource]
+  ): Unit = {
+    for {
+      source <- source.map(_.channelName)
+      channel <- channels.collectFirst {
+        // broadcast to the source channel only
+        case c: NetworkChannel if c.name == source => c
+      }
+    } tryTo(_.respondResult(event, execId))(channel)
+  }
+
+  // This is an interface to directly notify events.
+  private[sbt] def notifyEvent[A: JsonFormat](method: String, params: A): Unit = {
+    channels.foreach {
+      case c: NetworkChannel => tryTo(_.notifyEvent(method, params))(c)
+      case _                 =>
+    }
+  }
+
+  private def tryTo(f: NetworkChannel => Unit)(
+      channel: NetworkChannel
+  ): Unit =
+    try f(channel)
+    catch { case _: IOException => removeChannel(channel) }
+
+  def respondStatus(event: ExecStatusEvent): Unit = {
+    import sbt.protocol.codec.JsonProtocol._
+    for {
+      source <- event.channelName
+      channel <- channels.collectFirst {
+        case c: NetworkChannel if c.name == source => c
+      }
+    } {
+      if (event.execId.isEmpty) {
+        tryTo(_.notifyEvent(event))(channel)
+      } else {
+        event.exitCode match {
+          case None | Some(0) =>
+            tryTo(_.respondResult(event, event.execId))(channel)
+          case Some(code) =>
+            tryTo(_.respondError(code, event.message.getOrElse(""), event.execId))(channel)
+        }
+      }
+    }
+  }
+
+  private[sbt] def setExec(exec: Option[Exec]): Unit = currentExecRef.set(exec.orNull)
+
+  def prompt(event: ConsolePromptEvent): Unit = {
+    currentExecRef.set(null)
+    channels.foreach {
+      case c if ContinuousCommands.isInWatch(lastState.get, c) =>
+      case c                                                   => c.prompt(event)
+    }
+  }
+  def unprompt(event: ConsoleUnpromptEvent): Unit = channels.foreach(_.unprompt(event))
+
+  def logMessage(event: LogEvent): Unit = {
+    channels.foreach {
+      case c: NetworkChannel => tryTo(_.notifyEvent(event))(c)
+      case _                 =>
+    }
+  }
+
+  def notifyStatus(event: ExecStatusEvent): Unit = {
+    for {
+      source <- event.channelName
+      channel <- channels.collectFirst {
+        case c: NetworkChannel if c.name == source => c
+      }
+    } tryTo(_.notifyEvent(event))(channel)
+  }
+
+  private[sbt] def killChannel(channel: String): Unit = {
+    channels.find(_.name == channel).foreach(_.shutdown(false))
+  }
+  private[sbt] def updateProgress(pe: ProgressEvent): Unit = {
+    val newPE = currentExec match {
+      case Some(e) if !e.commandLine.startsWith(networkExecPrefix) =>
+        pe.withCommand(currentExec.map(_.commandLine))
+          .withExecId(currentExec.flatMap(_.execId))
+          .withChannelName(currentExec.flatMap(_.source.map(_.channelName)))
+      case _ => pe
+    }
+    channels.foreach(c => ProgressState.updateProgressState(newPE, c.terminal))
+  }
+
+  /**
+   * When a reboot is initiated by a network client, we need to communicate
+   * to it which
+   *
+   * @param state
+   */
+  private[sbt] def reboot(state: State): Unit = state.source match {
+    case Some(s) if s.channelName.startsWith("network") =>
+      channels.foreach {
+        case nc: NetworkChannel if nc.name == s.channelName =>
+          val remainingCommands =
+            state.remainingCommands
+              .takeWhile(!_.commandLine.startsWith(CompleteExec))
+              .map(_.commandLine)
+              .filterNot(_.startsWith("sbtReboot"))
+              .mkString(";")
+          val execId = state.remainingCommands.collectFirst {
+            case e if e.commandLine.startsWith(CompleteExec) =>
+              e.commandLine.split(CompleteExec).last.trim
+          }
+          nc.shutdown(true, execId.map(_ -> remainingCommands))
+        case nc: NetworkChannel => nc.shutdown(true, Some(("", "")))
+        case _                  =>
+      }
+    case _ =>
+      channels.foreach {
+        case nc: NetworkChannel => nc.shutdown(true, Some(("", "")))
+        case c                  => c.shutdown(false)
+      }
+  }
+
+  private[sbt] def shutdown(name: String): Unit = {
+    Option(currentExecRef.get).foreach(cancel)
+    commandQueue.clear()
+    val exit = Exec(Shutdown, Some(Exec.newExecId), Some(CommandSource(name)))
+    commandQueue.add(exit)
+    ()
+  }
+  private[this] def cancel(e: Exec): Unit = {
+    if (e.commandLine.startsWith("console")) {
+      val terminal = Terminal.get
+      terminal.write(13, 13, 13, 4)
+      terminal.printStream.println("\nconsole session killed by remote sbt client")
+    } else {
+      Util.ignoreResult(NetworkChannel.cancel(e.execId, e.execId.getOrElse("0"), force = true))
+    }
+  }
+
+  private[this] class FastTrackThread
+      extends Thread("sbt-command-exchange-fastTrack")
+      with AutoCloseable {
+    setDaemon(true)
+    start()
+    private[this] val isStopped = new AtomicBoolean(false)
+    override def run(): Unit = {
+      def exit(mt: FastTrackTask): Unit = {
+        mt.channel.shutdown(false)
+        if (mt.channel.name.contains("console")) shutdown(mt.channel.name)
+      }
+      @tailrec def impl(): Unit = {
+        fastTrackChannelQueue.take match {
+          case null =>
+          case mt: FastTrackTask =>
+            mt.task match {
+              case `attach` | "" => mt.channel.prompt(ConsolePromptEvent(lastState.get))
+              case `Cancel` =>
+                Option(currentExecRef.get).foreach(cancel)
+                mt.channel.prompt(ConsolePromptEvent(lastState.get))
+              case t if t.startsWith(ContinuousCommands.stopWatch) =>
+                mt.channel match {
+                  case c: NetworkChannel if !c.isInteractive => exit(mt)
+                  case _                                     =>
+                }
+                commandQueue.add(Exec(t, None, None))
+              case `TerminateAction` => exit(mt)
+              case `Shutdown` =>
+                val console = Terminal.console
+                val needNewLine = console.prompt.isInstanceOf[Prompt.AskUser]
+                console.setPrompt(Prompt.Batch)
+                if (needNewLine) console.printStream.println()
+                channels.find(_.name == mt.channel.name) match {
+                  case Some(c: NetworkChannel) => c.shutdown(false)
+                  case _                       =>
+                }
+                shutdown(mt.channel.name)
+              case _ =>
+            }
+        }
+        if (!isStopped.get) impl()
+      }
+      try impl()
+      catch { case _: InterruptedException => }
+    }
+    override def close(): Unit = if (isStopped.compareAndSet(false, true)) {
+      interrupt()
+    }
+  }
+  private[sbt] def channelForName(channelName: String): Option[CommandChannel] =
+    channels.find(_.name == channelName)
+  private[this] val fastTrackThread = new FastTrackThread
+}
diff --git a/main/src/main/scala/sbt/internal/CommandStrings.scala b/main/src/main/scala/sbt/internal/CommandStrings.scala
index 0f6ed2a0f..7c50f506e 100644
--- a/main/src/main/scala/sbt/internal/CommandStrings.scala
+++ b/main/src/main/scala/sbt/internal/CommandStrings.scala
@@ -1,12 +1,17 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
 import sbt.io.Path
 
 object CommandStrings {
+
   /** The prefix used to identify a request to execute the remaining input on source changes.*/
   val AboutCommand = "about"
   val TasksCommand = "tasks"
@@ -14,21 +19,18 @@ object CommandStrings {
   val ProjectCommand = "project"
   val ProjectsCommand = "projects"
   val ShowCommand = "show"
+  val PrintCommand = "print"
   val MultiTaskCommand = "all"
   val BootCommand = "boot"
 
   val EvalCommand = "eval"
-  val evalBrief = (EvalCommand + " <expression>", "Evaluates a Scala expression and prints the result and type.")
+  val evalBrief =
+    (s"$EvalCommand <expression>", "Evaluates a Scala expression and prints the result and type.")
   val evalDetailed =
-    EvalCommand + """ <expression>
+    s"""$EvalCommand <expression>
 
 	Evaluates the given Scala expression and prints the result and type."""
 
-  @deprecated("Misnomer: was only for `show`.  Use showBrief.", "0.13.2")
-  def actBrief = showBrief
-  @deprecated("Misnomer: was only for `show`.  Use showDetailed.", "0.13.2")
-  def actDetailed = showDetailed
-
   def actHelp = showHelp ++ multiTaskHelp
 
   def multiTaskHelp = Help(MultiTaskCommand, (multiTaskSyntax, multiTaskBrief), multiTaskDetailed)
@@ -36,8 +38,8 @@ object CommandStrings {
     s"""$multiTaskSyntax
 
 	$multiTaskBrief"""
-  def multiTaskSyntax = s"""$MultiTaskCommand <task>+"""
-  def multiTaskBrief = """Executes all of the specified tasks concurrently."""
+  def multiTaskSyntax = s"$MultiTaskCommand <task>+"
+  def multiTaskBrief = "Executes all of the specified tasks concurrently."
 
   def showHelp = Help(ShowCommand, (s"$ShowCommand <key>", showBrief), showDetailed)
   def showBrief = "Displays the result of evaluating the setting or task associated with 'key'."
@@ -50,38 +52,66 @@ $ShowCommand <task>
 
 	Evaluates the specified task and display the value returned by the task."""
 
+  def printHelp = Help(PrintCommand, (s"$PrintCommand <key>", printBrief), printDetailed)
+  def printBrief =
+    "Prints the result of evaluating the setting or task associated with 'key' to standard output."
+  def printDetailed =
+    s"""$PrintCommand <setting>
+
+	Prints the value of the specified setting.
+
+$PrintCommand <task>
+
+	Evaluates the specified task and print the value returned by the task."""
+
   val PluginsCommand = "plugins"
   val PluginCommand = "plugin"
   def pluginsBrief = "Lists currently available plugins."
   def pluginsDetailed = pluginsBrief // TODO: expand
 
   val LastCommand = "last"
-  val LastGrepCommand = "last-grep"
+  val OldLastGrepCommand = "last-grep"
+  val LastGrepCommand = "lastGrep"
   val ExportCommand = "export"
   val ExportStream = "export"
 
-  val lastGrepBrief = (LastGrepCommand, "Shows lines from the last output for 'key' that match 'pattern'.")
-  val lastGrepDetailed =
-    LastGrepCommand + """ <pattern>
+  val oldLastGrepBrief =
+    (OldLastGrepCommand, "Shows lines from the last output for 'key' that match 'pattern'.")
+  val oldLastGrepDetailed =
+    s"""$OldLastGrepCommand <pattern>
 	Displays lines from the logging of previous commands that match `pattern`.
 
-""" + LastGrepCommand + """ <pattern> [key]
+$OldLastGrepCommand <pattern> [key]
 	Displays lines from logging associated with `key` that match `pattern`.  The key typically refers to a task (for example, test:compile).  The logging that is displayed is restricted to the logging for that particular task.
 
 	<pattern> is a regular expression interpreted by java.util.Pattern.  Matching text is highlighted (when highlighting is supported and enabled).
-	See also '""" + LastCommand + "'."
+	See also '$LastCommand'."""
 
-  val lastBrief = (LastCommand, "Displays output from a previous command or the output from a specific task.")
+  val lastGrepBrief =
+    (LastGrepCommand, "Shows lines from the last output for 'key' that match 'pattern'.")
+  val lastGrepDetailed =
+    s"""$LastGrepCommand <pattern>
+	Displays lines from the logging of previous commands that match `pattern`.
+
+$LastGrepCommand <pattern> [key]
+	Displays lines from logging associated with `key` that match `pattern`.  The key typically refers to a task (for example, test:compile).  The logging that is displayed is restricted to the logging for that particular task.
+
+	<pattern> is a regular expression interpreted by java.util.Pattern.  Matching text is highlighted (when highlighting is supported and enabled).
+	See also '$LastCommand'."""
+
+  val lastBrief =
+    (LastCommand, "Displays output from a previous command or the output from a specific task.")
   val lastDetailed =
-    LastCommand + """
+    s"""$LastCommand
 	Prints the logging for the previous command, typically at a more verbose level.
 
-""" + LastCommand + """ <key>
+$LastCommand <key>
 	Prints the logging associated with the provided key.  The key typically refers to a task (for example, test:compile).  The logging that is displayed is restricted to the logging for that particular task.
 
-	See also '""" + LastGrepCommand + "'."
+	See also '$LastGrepCommand'."""
 
-  val exportBrief = (ExportCommand + " <tasks>+", "Executes tasks and displays the equivalent command lines.")
+  val exportBrief =
+    (s"$ExportCommand <tasks>+", "Executes tasks and displays the equivalent command lines.")
   val exportDetailed =
     s"""$ExportCommand [--last] <task>+
 	Runs the specified tasks and prints the equivalent command lines or other exportable information for those runs.
@@ -97,12 +127,17 @@ $ShowCommand <task>
 """
 
   val InspectCommand = "inspect"
-  val inspectBrief = (InspectCommand + " [uses|tree|definitions] <key>", "Prints the value for 'key', the defining scope, delegates, related definitions, and dependencies.")
+  val inspectBrief =
+    (
+      s"$InspectCommand [tree|uses|definitions|actual] <key>",
+      "Prints the value for 'key', the defining scope, delegates, related definitions, and dependencies."
+    )
   val inspectDetailed = s"""
-    |$InspectCommand <key>
+    |$InspectCommand [-] <key>
     |
     |	For a plain setting, the value bound to the key argument is displayed using its toString method.
-    |	Otherwise, the type of task ("Task" or "Input task") is displayed.
+    |	For an alias, the command bound to the alias is displayed.
+    |	Otherwise, the type of the key ("Task" or "Input task") is displayed.
     |
     |	"Dependencies" shows the settings that this setting depends on.
     |
@@ -136,9 +171,10 @@ $ShowCommand <task>
   """.stripMargin.trim
 
   val SetCommand = "set"
-  val setBrief = (s"$SetCommand [every] <setting>", "Evaluates a Setting and applies it to the current project.")
+  val setBrief =
+    (s"$SetCommand [every] <setting>", "Evaluates a Setting and applies it to the current project.")
   val setDetailed =
-    SetCommand + """ [every] <setting-expression>
+    s"""$SetCommand [every] <setting-expression>
 
 	Applies the given setting to the current project:
 	  1) Constructs the expression provided as an argument by compiling and loading it.
@@ -155,68 +191,84 @@ $ShowCommand <task>
 """
 
   def SessionCommand = "session"
-  def sessionBrief = (SessionCommand, "Manipulates session settings.  For details, run 'help " + SessionCommand + "'.")
+
+  def sessionBrief =
+    (SessionCommand, s"Manipulates session settings.  For details, run 'help $SessionCommand'.")
 
   def settingsPreamble = commonPreamble("settings")
-  def tasksPreamble = commonPreamble("tasks") + """
+
+  def tasksPreamble =
+    commonPreamble("tasks") + """
 Tasks produce values.  Use the 'show' command to run the task and print the resulting value."""
 
-  def commonPreamble(label: String) = """
-This is a list of %s defined for the current project.
-It does not list the scopes the %<s are defined in; use the 'inspect' command for that.""".format(label)
+  def commonPreamble(label: String) = s"""
+This is a list of $label defined for the current project.
+It does not list the scopes the $label are defined in; use the 'inspect' command for that."""
+
+  def settingsBrief(label: String) = (label, s"Lists the $label defined for the current project.")
+
+  import BasicCommandStrings.HelpCommand
 
-  def settingsBrief(label: String) = (label, "Lists the " + label + " defined for the current project.")
   def settingsDetailed(label: String) =
-    """
+    s"""
 Syntax summary
-	%s [-(v|-vv|...|-V)] [<filter>]
+	$label [-(v|-vv|...|-V)] [<filter>]
 
-%<s
-	Displays the main %<s defined directly or indirectly for the current project.
+$label
+	Displays the main $label defined directly or indirectly for the current project.
 
 -v
-	Displays additional %<s.  More 'v's increase the number of %<s displayed.
+	Displays additional $label.  More 'v's increase the number of $label displayed.
 
 -V
-	displays all %<s
+	displays all $label
 
 <filter>
-	Restricts the %<s that are displayed.  The names of %<s are searched for an exact match against the filter, in which case only the description of the exact match is displayed.  Otherwise, the filter is interpreted as a regular expression and all %<s whose name or description match the regular expression are displayed.  Note that this is an additional filter on top of the %<s selected by the -v style switches, so you must specify -V to search all %<s.  Use the %s command to search all commands, tasks, and settings at once.
-""".format(label, BasicCommandStrings.HelpCommand)
+	Restricts the $label that are displayed.  The names of $label are searched for
+	an exact match against the filter, in which case only the description of the
+	exact match is displayed.  Otherwise, the filter is interpreted as a regular
+	expression and all $label whose name or description match the regular
+	expression are displayed.  Note that this is an additional filter on top of
+	the $label selected by the -v style switches, so you must specify -V to search
+	all $label.  Use the $HelpCommand command to search all commands, tasks, and
+	settings at once.
+"""
 
-  def moreAvailableMessage(label: String, search: Boolean) =
-    "More %s may be %s by increasing verbosity.  See '%s %s'.\n".format(label, if (search) "searched" else "viewed", BasicCommandStrings.HelpCommand, label)
+  def moreAvailableMessage(label: String, search: Boolean) = {
+    val verb = if (search) "searched" else "viewed"
+    s"More $label may be $verb by increasing verbosity.  See '$HelpCommand $label'\n"
+  }
 
   def aboutBrief = "Displays basic information about sbt and the build."
   def aboutDetailed = aboutBrief
 
-  def projectBrief = (ProjectCommand, "Displays the current project or changes to the provided `project`.")
+  def projectBrief =
+    (ProjectCommand, "Displays the current project or changes to the provided `project`.")
   def projectDetailed =
-    ProjectCommand +
-      """
+    s"""$ProjectCommand
 
 	Displays the name of the current project.
 
-""" + ProjectCommand + """ name
+$ProjectCommand name
 
 	Changes to the project with the provided name.
 	This command fails if there is no project with the given name.
 
-""" + ProjectCommand + """ {uri}
+$ProjectCommand {uri}
 
 	Changes to the root project in the build defined by `uri`.
 	`uri` must have already been declared as part of the build, such as with Project.dependsOn.
 
-""" + ProjectCommand + """ {uri}name
+$ProjectCommand {uri}name
 
 	Changes to the project `name` in the build defined by `uri`.
 	`uri` must have already been declared as part of the build, such as with Project.dependsOn.
 
-""" + ProjectCommand + """ /
+$ProjectCommand /
 
 	Changes to the initial project.
 
-""" + ProjectCommand + """ ..
+$ProjectCommand ..
 
 	Changes to the parent project of the current project.
 	If there is no parent project, the current project is unchanged.
@@ -224,39 +276,37 @@ Syntax summary
 	Use n+1 dots to change to the nth parent.
 	For example, 'project ....' is equivalent to three consecutive 'project ..' commands."""
 
-  def projectsBrief = "Lists the names of available projects or temporarily adds/removes extra builds to the session."
+  def projectsBrief =
+    "Lists the names of available projects or temporarily adds/removes extra builds to the session."
   def projectsDetailed =
-    ProjectsCommand + """
+    s"""$ProjectsCommand
 	List the names of available builds and the projects defined in those builds.
 
-""" + ProjectsCommand + """ add <URI>+
+$ProjectsCommand add <URI>+
 	Adds the builds at the provided URIs to this session.
-	These builds may be selected using the """ + ProjectCommand + """ command.
+	These builds may be selected using the $ProjectCommand command.
 	Alternatively, tasks from these builds may be run using the explicit syntax {URI}project/task
 
-""" + ProjectsCommand + """ remove <URI>+
+$ProjectsCommand remove <URI>+
 	Removes extra builds from this session.
 	Builds explicitly listed in the build definition are not affected by this command.
 """
 
   def sbtrc = ".sbtrc"
 
-  def DefaultsCommand = "add-default-commands"
+  def DefaultsCommand = "addDefaultCommands"
   def DefaultsBrief = (DefaultsCommand, DefaultsDetailed)
   def DefaultsDetailed = "Registers default built-in commands"
 
-  def Load = "load"
-  def LoadLabel = "a project"
-  def LoadCommand = "load-commands"
-  def LoadCommandLabel = "commands"
-
-  def LoadFailed = "load-failed"
+  def LoadFailed = "loadFailed"
+  def OldLoadFailed = "load-failed"
 
   def LoadProjectImpl = "loadp"
   def LoadProject = "reload"
-  def LoadProjectBrief = (LoadProject, "(Re)loads the current project or changes to plugins project or returns from it.")
-  def LoadProjectDetailed = LoadProject +
-    s"""
+  def LoadProjectBrief =
+    (LoadProject, "(Re)loads the current project or changes to plugins project or returns from it.")
+  def LoadProjectDetailed =
+    s"""$LoadProject
 
 \t(Re)loads the project in the current directory.
 
@@ -271,7 +321,7 @@ $LoadProject return
   def InitCommand = "initialize"
   def InitBrief = (InitCommand, "Initializes command processing.")
   def InitDetailed =
-    InitCommand + """
+    s"""$InitCommand
 	Initializes command processing.
 
 Runs the following commands.
@@ -289,7 +339,7 @@ defaults
 
   def sbtRCs(s: State): Seq[File] =
     (Path.userHome / sbtrc) ::
-      (s.baseDir / sbtrc asFile) ::
+      (s.baseDir / sbtrc) ::
       Nil
 
   val CrossCommand = "+"
@@ -351,4 +401,57 @@ $SwitchCommand [<scala-version>=]<scala-home>[!] [-v] [<command>]
 
 	See also `help $CrossCommand`
 """
+
+  val PluginCrossCommand = "^"
+  val PluginSwitchCommand = "^^"
+
+  def pluginCrossHelp: Help = Help.more(PluginCrossCommand, PluginCrossDetailed)
+  def pluginSwitchHelp: Help = Help.more(PluginSwitchCommand, PluginSwitchDetailed)
+
+  def PluginCrossDetailed =
+    s"""$PluginCrossCommand <command>
+  Runs <command> for each sbt version specified for cross-building.
+
+  For each string in `crossSbtVersions` in the current project, this command sets the
+  `sbtVersion in pluginCrossBuild` of all projects to that version, reloads the build,
+  and executes <command>.  When finished, it reloads the build with the original
+  Scala version.
+
+  See also `help $PluginSwitchCommand`
+"""
+
+  def PluginSwitchDetailed =
+    s"""$PluginSwitchCommand <sbt-version> [<command>]
+  Changes the sbt version and runs a command.
+
+  Sets the `sbtVersion in pluginCrossBuild` of all projects to <sbt-version> and
+  reloads the build. If <command> is provided, it is then executed.
+
+  See also `help $CrossCommand`
+"""
+
+  val JavaCrossCommand = "java+"
+  val JavaSwitchCommand = "java++"
+
+  def javaCrossHelp: Help = Help.more(JavaCrossCommand, JavaCrossDetailed)
+  def javaSwitchHelp: Help = Help.more(JavaSwitchCommand, JavaSwitchDetailed)
+
+  def JavaCrossDetailed =
+    s"""$JavaCrossCommand <command>
+  Runs <command> for each JDK version specified for cross-JDK testing.
+  For each string in `crossJavaVersions` in the current project, this command sets the
+  `javaHome` of all projects to the corresponding Java home, reloads the build,
+  and executes <command>.  When finished, it reloads the build with the original
+  `javaHome`.
+  Note that `Test / fork := true` is needed for `javaHome` to be effective.
+  See also `help $JavaSwitchCommand`
+"""
+
+  def JavaSwitchDetailed =
+    s"""$JavaSwitchCommand <java-version>
+  Changes the JDK version and runs a command.
+  Sets the `javaHome` of all projects to <java-version> and
+  reloads the build. If <command> is provided, it is then executed.
+  See also `help $JavaSwitchCommand`
+"""
 }
diff --git a/main/src/main/scala/sbt/internal/CompatParColls.scala b/main/src/main/scala/sbt/internal/CompatParColls.scala
new file mode 100644
index 000000000..00410e7d5
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/CompatParColls.scala
@@ -0,0 +1,25 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import scala.annotation.nowarn
+
+// https://github.com/scala/scala-parallel-collections/issues/22
+private[sbt] object CompatParColls {
+  @nowarn
+  val Converters = {
+    import Compat._
+    {
+      import scala.collection.parallel._
+      CollectionConverters
+    }
+  }
+  object Compat {
+    object CollectionConverters
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/ConsoleProject.scala b/main/src/main/scala/sbt/internal/ConsoleProject.scala
index 803c26da0..b2776b754 100644
--- a/main/src/main/scala/sbt/internal/ConsoleProject.scala
+++ b/main/src/main/scala/sbt/internal/ConsoleProject.scala
@@ -1,37 +1,83 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
+import sbt.SlashSyntax0._
+import sbt.internal.classpath.AlternativeZincUtil
+import sbt.internal.inc.{ ScalaInstance, ZincLmUtil }
+import sbt.internal.util.Terminal
 import sbt.util.Logger
-import sbt.internal.inc.{ ClasspathOptionsUtil, ScalaInstance }
+import xsbti.compile.ClasspathOptionsUtil
 
 object ConsoleProject {
-  def apply(state: State, extra: String, cleanupCommands: String = "", options: Seq[String] = Nil)(implicit log: Logger): Unit = {
+  def apply(state: State, extra: String, cleanupCommands: String = "", options: Seq[String] = Nil)(
+      implicit log: Logger
+  ): Unit = {
     val extracted = Project extract state
     val cpImports = new Imports(extracted, state)
     val bindings = ("currentState" -> state) :: ("extracted" -> extracted) :: ("cpHelpers" -> cpImports) :: Nil
     val unit = extracted.currentUnit
-    val (_, ivyConf) = extracted.runTask(Keys.ivyConfiguration, state)
+    val (state1, dependencyResolution) =
+      extracted.runTask(Keys.dependencyResolution, state)
+    val (_, scalaCompilerBridgeBinaryJar) =
+      extracted.runTask(Keys.consoleProject / Keys.scalaCompilerBridgeBinaryJar, state1)
     val scalaInstance = {
       val scalaProvider = state.configuration.provider.scalaProvider
-      ScalaInstance(scalaProvider.version, scalaProvider.launcher)
+      ScalaInstance(scalaProvider.version, scalaProvider)
+    }
+    val g = BuildPaths.getGlobalBase(state)
+    val zincDir = BuildPaths.getZincDirectory(state, g)
+    val app = state.configuration
+    val launcher = app.provider.scalaProvider.launcher
+    val compiler = scalaCompilerBridgeBinaryJar match {
+      case Some(jar) =>
+        AlternativeZincUtil.scalaCompiler(
+          scalaInstance = scalaInstance,
+          classpathOptions = ClasspathOptionsUtil.repl,
+          compilerBridgeJar = jar,
+          classLoaderCache = state1.get(BasicKeys.classLoaderCache)
+        )
+      case None =>
+        ZincLmUtil.scalaCompiler(
+          scalaInstance = scalaInstance,
+          classpathOptions = ClasspathOptionsUtil.repl,
+          globalLock = launcher.globalLock,
+          componentProvider = app.provider.components,
+          secondaryCacheDir = Option(zincDir),
+          dependencyResolution = dependencyResolution,
+          compilerBridgeSource = extracted.get(Keys.consoleProject / Keys.scalaCompilerBridgeSource),
+          scalaJarsTarget = zincDir,
+          classLoaderCache = state1.get(BasicKeys.classLoaderCache),
+          log = log
+        )
     }
-    val sourcesModule = extracted.get(Keys.scalaCompilerBridgeSource)
-    val compiler = Compiler.scalaCompiler(scalaInstance, ClasspathOptionsUtil.repl, None, ivyConf, sourcesModule)(state.configuration, log)
     val imports = BuildUtil.getImports(unit.unit) ++ BuildUtil.importAll(bindings.map(_._1))
     val importString = imports.mkString("", ";\n", ";\n\n")
     val initCommands = importString + extra
+
+    val terminal = Terminal.get
     // TODO - Hook up dsl classpath correctly...
     (new Console(compiler))(
-      unit.classpath, options, initCommands, cleanupCommands
-    )(Some(unit.loader), bindings)
+      unit.classpath,
+      options,
+      initCommands,
+      cleanupCommands,
+      terminal
+    )(Some(unit.loader), bindings).get
+    ()
   }
+
   /** Conveniences for consoleProject that shouldn't normally be used for builds. */
   final class Imports private[sbt] (extracted: Extracted, state: State) {
     import extracted._
-    implicit def taskKeyEvaluate[T](t: TaskKey[T]): Evaluate[T] = new Evaluate(runTask(t, state)._2)
+    implicit def taskKeyEvaluate[T](t: TaskKey[T]): Evaluate[T] =
+      new Evaluate(runTask(t, state)._2)
     implicit def settingKeyEvaluate[T](s: SettingKey[T]): Evaluate[T] = new Evaluate(get(s))
   }
   final class Evaluate[T] private[sbt] (val eval: T)
diff --git a/main/src/main/scala/sbt/internal/Continuous.scala b/main/src/main/scala/sbt/internal/Continuous.scala
new file mode 100644
index 000000000..c206cb71e
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/Continuous.scala
@@ -0,0 +1,1405 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.{ ByteArrayInputStream, IOException, InputStream, File => _ }
+import java.nio.file.Path
+import java.util.concurrent.{
+  ConcurrentHashMap,
+  CountDownLatch,
+  LinkedBlockingQueue,
+  TimeUnit,
+  TimeoutException
+}
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicInteger }
+
+import sbt.BasicCommandStrings._
+import sbt.Def._
+import sbt.Keys._
+import sbt.SlashSyntax0._
+import sbt.internal.Continuous.{ ContinuousState, FileStampRepository }
+import sbt.internal.LabeledFunctions._
+import sbt.internal.io.WatchState
+import sbt.internal.nio._
+import sbt.internal.ui.UITask
+import sbt.internal.util.JoinThread._
+import sbt.internal.util.complete.DefaultParsers.{ Space, matched }
+import sbt.internal.util.complete.Parser._
+import sbt.internal.util.complete.{ Parser, Parsers }
+import sbt.internal.util._
+import sbt.nio.Keys.{ fileInputs, _ }
+import sbt.nio.Watch.{ Creation, Deletion, ShowOptions, Update }
+import sbt.nio.file.{ FileAttributes, Glob }
+import sbt.nio.{ FileStamp, FileStamper, Watch }
+import sbt.util.{ Level, _ }
+
+import scala.annotation.tailrec
+import scala.collection.mutable
+import scala.concurrent.duration.FiniteDuration.FiniteDurationIsOrdered
+import scala.concurrent.duration._
+import scala.util.{ Failure, Success, Try }
+import scala.util.control.NonFatal
+
+/**
+ * Provides the implementation of the `~` command and `watch` task. The implementation is quite
+ * complex because we have to parse the command string to figure out which tasks we want to run.
+ * Using the tasks, we then have to extract all of the settings for the continuous build. Finally
+ * we have to aggregate the settings for each task into an aggregated watch config that will
+ * sanely watch multiple tasks and respond to file updates and user input in a way that makes
+ * sense for each of the tasks that are being monitored.
+ *
+ * The behavior, on the other hand, should be fairly straightforward. For example, if a user
+ * wants to continuously run the compile task for projects a and b, then we create FileEventMonitor
+ * instances for each product and watch all of the directories that contain compile sources
+ * (as well as the source directories of transitive inter-project classpath dependencies). If
+ * a change is detected in project a, then we should trigger a build for both projects a and b.
+ *
+ * The semantics are flexible and may be adapted. For example, a user may want to watch two
+ * unrelated tasks and only rebuild the task with sources that have been changed. This could be
+ * handled at the `~` level, but it probably makes more sense to build a better task caching
+ * system so that we don't rerun tasks if their inputs have not changed. As of 1.3.0, the
+ * semantics match previous sbt versions as closely as possible while allowing the user more
+ * freedom to adjust the behavior to best suit their use cases.
+ *
+ * For now Continuous extends DeprecatedContinuous to minimize the number of deprecation warnings
+ * produced by this file. In sbt 2.0, the DeprecatedContinuous mixin should be eliminated and
+ * the deprecated apis should no longer be supported.
+ *
+ */
+private[sbt] object Continuous extends DeprecatedContinuous {
+  private type Event = FileEvent[FileAttributes]
+
+  /**
+   * Provides the dynamic inputs to the continuous build callbacks that cannot be stored as
+   * settings. This wouldn't need to exist if there was a notion of a lazy setting in sbt.
+   *
+   * @param logger the Logger
+   * @param inputs the transitive task inputs
+   */
+  private[sbt] final class Arguments private[Continuous] (
+      val logger: Logger,
+      val inputs: Seq[DynamicInput]
+  )
+
+  /**
+   * Create a function from InputStream => [[Watch.Action]] from a [[Parser]]. This is intended
+   * to be used to set the watchInputHandler setting for a task.
+   *
+   * @param parser the parser
+   * @return the function
+   */
+  private def defaultInputHandler(parser: Parser[Watch.Action]): InputStream => Watch.Action = {
+    val builder = new StringBuilder
+    val any = matched(Parsers.any.*)
+    val fullParser = any ~> parser ~ any
+    ((inputStream: InputStream) => parse(inputStream, builder, fullParser))
+      .label("Continuous.defaultInputHandler")
+  }
+
+  /**
+   * Implements continuous execution. It works by first parsing the command and generating a task to
+   * run with each build. It can run multiple commands that are separated by ";" in the command
+   * input. If any of these commands are invalid, the watch will immediately exit.
+   *
+   * @return a Command that can be used by sbt to implement continuous builds.
+   */
+  private[sbt] def continuous: Command =
+    Command(ContinuousExecutePrefix, continuousBriefHelp, continuousDetail)(continuousParser) {
+      case (s, (initialCount, commands)) =>
+        val (s1, channel) = s.currentCommand.flatMap(_.source.map(_.channelName)) match {
+          case Some(c) => s -> c
+          case None    => StandardMain.exchange.run(s) -> ConsoleChannel.defaultName
+        }
+        val ws = ContinuousCommands.setupWatchState(channel, initialCount, commands, s1)
+        s"${ContinuousCommands.runWatch} $channel" :: s"${ContinuousCommands.waitWatch} $channel" :: ws
+    }
+
+  @deprecated("The input task version of watch is no longer available", "1.4.0")
+  private[sbt] def continuousTask: Def.Initialize[InputTask[StateTransform]] =
+    Def.inputTask(StateTransform(identity))
+
+  private[sbt] val dynamicInputs = taskKey[Option[mutable.Set[DynamicInput]]](
+    "The input globs found during task evaluation that are used in watch."
+  )
+
+  private[sbt] def dynamicInputsImpl: Def.Initialize[Task[Option[mutable.Set[DynamicInput]]]] =
+    Def.task(Keys.state.value.get(DynamicInputs))
+
+  private[sbt] val DynamicInputs =
+    AttributeKey[mutable.Set[DynamicInput]](
+      "dynamic-inputs",
+      "Stores the inputs (dynamic and regular) for a task",
+      10000
+    )
+
+  private[this] val continuousParser: State => Parser[(Int, Seq[String])] = {
+    def toInt(s: String): Int = Try(s.toInt).getOrElse(0)
+
+    // This allows us to re-enter the watch with the previous count.
+    val digitParser: Parser[Int] =
+      (Parsers.Space.* ~> matched(Parsers.Digit.+) <~ Parsers.Space.*).map(toInt)
+    state =>
+      val ocp = BasicCommands.multiParserImpl(Some(state)) |
+        BasicCommands.otherCommandParser(state).map(_ :: Nil)
+      (digitParser.? ~ ocp).flatMap {
+        case (i, commands) if commands.exists(_.nonEmpty) =>
+          Parser.success((i.getOrElse(0), commands.filter(_.nonEmpty)))
+        case (_, _) => Parser.failure("Couldn't parse any commands")
+      }
+  }
+
+  /**
+   * Gets the [[Config]] necessary to watch a task. It will extract the internal dependency
+   * configurations for the task (these are the classpath dependencies specified by
+   * [[Project.dependsOn]]). Using these configurations and the settings map, it walks the
+   * dependency graph for the key and extracts all of the transitive globs specified by the
+   * inputs and triggers keys. It also extracts the legacy globs specified by the watchSources key.
+   *
+   * @param state the current [[State]] instance.
+   * @param scopedKey the [[ScopedKey]] instance corresponding to the task we're monitoring
+   * @param compiledMap the map of all of the build settings
+   * @param extracted the [[Extracted]] instance for the build
+   * @param logger a logger that can be used while generating the [[Config]]
+   * @return the [[Config]] instance
+   */
+  private def getConfig(
+      state: State,
+      scopedKey: ScopedKey[_],
+      compiledMap: CompiledMap,
+      dynamicInputs: mutable.Set[DynamicInput],
+  )(implicit extracted: Extracted, logger: Logger): Config = {
+
+    // Extract all of the globs that we will monitor during the continuous build.
+    val inputs = {
+      val configs = scopedKey.get(internalDependencyConfigurations).getOrElse(Nil)
+      import WatchTransitiveDependencies.{ Arguments => DArguments }
+      val args = new DArguments(scopedKey, extracted, compiledMap, logger, configs, state)
+      WatchTransitiveDependencies.transitiveDynamicInputs(args)
+    }
+
+    val repository = getRepository(state)
+    dynamicInputs ++= inputs
+    logger.debug(s"[watch] [${scopedKey.show}] Found inputs: ${inputs.map(_.glob).mkString(",")}")
+    inputs.foreach(i => repository.register(i.glob).foreach(_.close()))
+    val watchSettings = new WatchSettings(scopedKey)
+    new Config(
+      scopedKey.show,
+      dynamicInputs,
+      watchSettings
+    )
+  }
+
+  private def getRepository(state: State): FileTreeRepository[FileAttributes] = {
+    lazy val exception =
+      new IllegalStateException("Tried to access FileTreeRepository for uninitialized state")
+    state
+      .get(globalFileTreeRepository)
+      .getOrElse(throw exception)
+  }
+
+  private[sbt] def validateCommands(state: State, commands: Seq[String]): Unit = {
+    commands.filter(cmd => Parser.parse(cmd, state.combinedParser).isLeft) match {
+      case invalid if invalid.isEmpty =>
+      case invalid =>
+        val msg = s"Invalid commands: ${invalid.mkString("'", "', '", ",")}"
+        throw new IllegalArgumentException(msg)
+    }
+  }
+
+  // This is defined so we can assign a task key to a command to parse the WatchSettings.
+  private[this] val globalWatchSettingKey =
+    taskKey[Unit]("Internal task key. Not actually used.").withRank(KeyRanks.Invisible)
+  private def parseCommand(command: String, state: State): Seq[ScopedKey[_]] = {
+    // Collect all of the scoped keys that are used to delegate the multi commands. These are
+    // necessary to extract all of the transitive globs that we need to monitor during watch.
+    // We have to add the <~ Parsers.any.* to ensure that we're able to extract the input key
+    // from input tasks.
+    val scopedKeyParser: Parser[Seq[ScopedKey[_]]] = Act.aggregatedKeyParser(state) <~ Parsers.any.*
+    @tailrec def impl(current: String): Seq[ScopedKey[_]] = {
+      Parser.parse(current, scopedKeyParser) match {
+        case Right(scopedKeys: Seq[ScopedKey[_]]) => scopedKeys
+        case Left(e) =>
+          val aliases = BasicCommands.allAliases(state)
+          aliases.collectFirst { case (`command`, aliased) => aliased } match {
+            case Some(aliased) => impl(aliased)
+            case None =>
+              Parser.parse(command, state.combinedParser) match {
+                case Right(_) => globalWatchSettingKey.scopedKey :: Nil
+                case _ =>
+                  val msg = s"Error attempting to extract scope from $command: $e."
+                  throw new IllegalStateException(msg)
+              }
+          }
+        case _ => Nil: Seq[ScopedKey[_]]
+      }
+    }
+    impl(command)
+  }
+
+  private def getAllConfigs(
+      state: State,
+      commands: Seq[String],
+      dynamicInputs: mutable.Set[DynamicInput],
+  )(implicit extracted: Extracted, logger: Logger): Seq[Config] = {
+    val commandKeys = commands.map(parseCommand(_, state))
+    val compiledMap = WatchTransitiveDependencies.compile(extracted.structure)
+    commandKeys.flatMap(_.map(getConfig(state, _, compiledMap, dynamicInputs)))
+  }
+
+  private[sbt] class Callbacks(
+      val nextEvent: Int => Watch.Action,
+      val beforeCommand: () => Unit,
+      val onExit: () => Unit,
+      val onStart: Int => Watch.Action,
+      val onTermination: (Watch.Action, String, Int, State) => State
+  )
+
+  private[sbt] def getCallbacks(
+      s: State,
+      channel: CommandChannel,
+      commands: Seq[String],
+      fileStampCache: FileStamp.Cache,
+      dynamicInputs: mutable.Set[DynamicInput],
+      context: LoggerContext
+  ): Callbacks = {
+    implicit val extracted: Extracted = Project.extract(s)
+    implicit val logger: Logger =
+      context.logger(channel.name + "-watch", None, None)
+    validateCommands(s, commands)
+    val configs = getAllConfigs(s, commands, dynamicInputs)
+    val appender = ConsoleAppender(channel.name + "-watch", channel.terminal)
+    val level = configs.minBy(_.watchSettings.logLevel).watchSettings.logLevel
+    context.addAppender(channel.name + "-watch", appender -> level)
+    aggregate(
+      configs,
+      logger,
+      channel,
+      s,
+      isCommand = true,
+      commands,
+      fileStampCache
+    )
+  }
+
+  /**
+   * Aggregates a collection of [[Config]] instances into a single instance of [[Callbacks]].
+   * This allows us to monitor and respond to changes for all of
+   * the inputs and triggers for each of the tasks that we are monitoring in the continuous build.
+   * To monitor all of the inputs and triggers, it creates a monitor for each task
+   * and then aggregates each of the individual monitor instances into an aggregated
+   * instance. It aggregates all of the event callbacks into a single callback that delegates
+   * to each of the individual callbacks. For the callbacks that return a [[Watch.Action]],
+   * the aggregated callback will select the minimum [[Watch.Action]] returned where the ordering
+   * is such that the highest priority [[Watch.Action]] have the lowest values. Finally, to
+   * handle user input, we read from the provided input stream and buffer the result. Each
+   * task's input parser is then applied to the buffered result and, again, we return the minimum
+   * [[Watch.Action]] returned by the parsers (when the parsers fail, they just return
+   * [[Watch.Ignore]], which is the lowest priority [[Watch.Action]].
+   *
+   * @param configs the [[Config]] instances
+   * @param logger the default sbt logger instance
+   * @param state the current state
+   * @param extracted the [[Extracted]] instance for the current build
+   * @return the [[Callbacks]] to pass into [[Watch.apply]]
+   */
+  private def aggregate(
+      configs: Seq[Config],
+      logger: Logger,
+      channel: CommandChannel,
+      state: State,
+      isCommand: Boolean,
+      commands: Seq[String],
+      fileStampCache: FileStamp.Cache
+  )(
+      implicit extracted: Extracted
+  ): Callbacks = {
+    val project = extracted.currentRef
+    val beforeCommand = () => configs.foreach(_.watchSettings.beforeCommand())
+    val onStart: Int => Watch.Action =
+      getOnStart(project, commands, configs, logger, extracted)
+    val (message, parser, altParser) = getWatchInputOptions(configs, extracted)
+    val nextInputEvent: WatchExecutor => Option[Watch.Action] = {
+      parseInputEvents(parser, altParser, state, channel.terminal, logger)
+    }
+    val (nextFileEvent, cleanupFileMonitor): (
+        Int => Option[(Watch.Event, Watch.Action)],
+        () => Unit
+    ) = getFileEvents(configs, logger, state, commands, fileStampCache, channel.name)
+    val executor = new WatchExecutor(channel.name)
+    val nextEvent: Int => Watch.Action =
+      combineInputAndFileEvents(
+        nextInputEvent,
+        nextFileEvent,
+        message,
+        logger,
+        logger,
+        executor,
+        channel
+      )
+    val onExit = () => {
+      cleanupFileMonitor()
+      Util.ignoreResult(executor.close())
+    }
+    val onTermination = getOnTermination(configs, isCommand)
+    new Callbacks(nextEvent, beforeCommand, onExit, onStart, onTermination)
+  }
+
+  private def getOnTermination(
+      configs: Seq[Config],
+      isCommand: Boolean
+  ): (Watch.Action, String, Int, State) => State = {
+    configs.flatMap(_.watchSettings.onTermination).distinct match {
+      case Seq(head, tail @ _*) =>
+        tail.foldLeft(head) {
+          case (onTermination, configOnTermination) =>
+            (action, cmd, count, state) =>
+              configOnTermination(action, cmd, count, onTermination(action, cmd, count, state))
+        }
+      case _ =>
+        if (isCommand) Watch.defaultCommandOnTermination else Watch.defaultTaskOnTermination
+    }
+  }
+
+  private def getWatchInputOptions(
+      configs: Seq[Config],
+      extracted: Extracted
+  ): (String, Parser[Watch.Action], Option[(TaskKey[InputStream], InputStream => Watch.Action)]) = {
+    configs match {
+      case Seq(h) =>
+        val settings = h.watchSettings
+        val parser = settings.inputParser
+        val alt = settings.inputStream.map { k =>
+          k -> settings.inputHandler.getOrElse(defaultInputHandler(parser))
+        }
+        (settings.inputOptionsMessage, parser, alt)
+      case _ =>
+        val options =
+          extracted.getOpt((ThisBuild / watchInputOptions)).getOrElse(Watch.defaultInputOptions)
+        val message = extracted
+          .getOpt((ThisBuild / watchInputOptionsMessage))
+          .getOrElse(Watch.defaultInputOptionsMessage(options))
+        val parser = extracted
+          .getOpt((ThisBuild / watchInputParser))
+          .getOrElse(Watch.defaultInputParser(options))
+        val alt = extracted
+          .getOpt((ThisBuild / watchInputStream))
+          .map { _ =>
+            (ThisBuild / watchInputStream) -> extracted
+              .getOpt((ThisBuild / watchInputHandler))
+              .getOrElse(defaultInputHandler(parser))
+          }
+        (message, parser, alt)
+    }
+  }
+
+  private def getOnStart(
+      project: ProjectRef,
+      commands: Seq[String],
+      configs: Seq[Config],
+      logger: Logger,
+      extracted: Extracted,
+  ): Int => Watch.Action = {
+    val f: Int => Seq[Watch.Action] = count => {
+      configs.map { params =>
+        val ws = params.watchSettings
+        ws.onIteration.map(_(count, project, commands)).getOrElse {
+          if (configs.size == 1) { // Only allow custom start messages for single tasks
+            ws.startMessage match {
+              case Some(Left(sm))  => logger.info(sm(params.watchState(count)))
+              case Some(Right(sm)) => sm(count, project, commands).foreach(logger.info(_))
+              case None =>
+                Watch.defaultStartWatch(count, project, commands).foreach(logger.info(_))
+            }
+          }
+          Watch.Ignore
+        }
+      }
+    }
+    count => {
+      val res = f(count).min
+      // Print the default watch message if there are multiple tasks
+      if (configs.size > 1) {
+        val onStartWatch =
+          extracted.getOpt((project / watchStartMessage)).getOrElse(Watch.defaultStartWatch)
+        onStartWatch(count, project, commands).foreach(logger.info(_))
+      }
+      res
+    }
+  }
+
+  private def getFileEvents(
+      configs: Seq[Config],
+      logger: Logger,
+      state: State,
+      commands: Seq[String],
+      fileStampCache: FileStamp.Cache,
+      channel: String,
+  )(implicit extracted: Extracted): (Int => Option[(Watch.Event, Watch.Action)], () => Unit) = {
+    val trackMetaBuild = configs.forall(_.watchSettings.trackMetaBuild)
+    val buildGlobs =
+      if (trackMetaBuild) extracted.getOpt((checkBuildSources / fileInputs)).getOrElse(Nil)
+      else Nil
+
+    val retentionPeriod = configs.map(_.watchSettings.antiEntropyRetentionPeriod).max
+    val quarantinePeriod = configs.map(_.watchSettings.deletionQuarantinePeriod).max
+    val monitor: FileEventMonitor[Event] = new FileEventMonitor[Event] {
+
+      private implicit class WatchLogger(val l: Logger) extends sbt.internal.nio.WatchLogger {
+        override def debug(msg: Any): Unit = l.debug(msg.toString)
+      }
+
+      private[this] val observers: Observers[Event] = new Observers
+      private[this] val repo = getRepository(state)
+      private[this] val handles = new java.util.ArrayList[AutoCloseable]
+      handles.add(repo.addObserver(observers))
+      private[this] val eventMonitorObservers = new Observers[Event]
+      private[this] val configHandle: AutoCloseable =
+        observers.addObserver { e =>
+          // We only want to create one event per actual source file event. It doesn't matter
+          // which of the config inputs triggers the event because they all will be used in
+          // the onEvent callback above.
+          configs.find(_.inputs().exists(_.glob.matches(e.path))) match {
+            case Some(config) =>
+              val configLogger = logger.withPrefix(config.command)
+              configLogger.debug(s"Accepted event for ${e.path}")
+              eventMonitorObservers.onNext(e)
+            case None =>
+          }
+          if (trackMetaBuild && buildGlobs.exists(_.matches(e.path))) {
+            val metaLogger = logger.withPrefix("build")
+            metaLogger.debug(s"Accepted event for ${e.path}")
+            eventMonitorObservers.onNext(e)
+          }
+        }
+      if (trackMetaBuild) {
+        state.get(CheckBuildSources.CheckBuildSourcesKey).flatMap(_.fileTreeRepository) match {
+          case Some(r) => buildGlobs.foreach(r.register(_).foreach(observers.addObservable))
+          case _       => buildGlobs.foreach(repo.register(_).foreach(_.close()))
+        }
+      }
+
+      private[this] val antiEntropyWindow = configs.map(_.watchSettings.antiEntropy).max
+      private[this] val monitor = FileEventMonitor.antiEntropy(
+        eventMonitorObservers,
+        antiEntropyWindow,
+        logger,
+        quarantinePeriod,
+        retentionPeriod
+      )
+
+      private[this] val antiEntropyPollPeriod =
+        configs.map(_.watchSettings.antiEntropyPollPeriod).max
+      override def poll(duration: Duration, filter: Event => Boolean): Seq[Event] = {
+        monitor.poll(duration, filter) match {
+          case s if s.nonEmpty =>
+            val limit = antiEntropyWindow.fromNow
+            /*
+             * File events may come in bursts so we poll for a short time to see if there
+             * are other changes detected in the burst. As soon as no changes are detected
+             * during the polling window, we return all of the detected events. The polling
+             * period is by default 5 milliseconds which is short enough to detect bursts
+             * induced by commands like git rebase but fast enough to not lead to a noticable
+             * increase in latency.
+             */
+            @tailrec def aggregate(res: Seq[Event]): Seq[Event] =
+              if (limit.isOverdue) res
+              else {
+                monitor.poll(antiEntropyPollPeriod) match {
+                  case s if s.nonEmpty => aggregate(res ++ s)
+                  case _               => res
+                }
+              }
+            aggregate(s)
+          case s => s
+        }
+      }
+
+      override def close(): Unit = {
+        configHandle.close()
+        handles.forEach(_.close())
+        observers.close()
+      }
+    }
+    val watchLogger: WatchLogger = msg => logger.debug(msg.toString)
+    val antiEntropy = configs.map(_.watchSettings.antiEntropy).max
+    val antiEntropyMonitor = FileEventMonitor.antiEntropy(
+      monitor,
+      antiEntropy,
+      watchLogger,
+      quarantinePeriod,
+      retentionPeriod
+    )
+
+    val onEvent: (Int, Event) => Seq[(Watch.Event, Watch.Action)] = (count, event) => {
+      val path = event.path
+
+      def getWatchEvent(forceTrigger: Boolean): Option[Watch.Event] = {
+        if (!event.exists) {
+          Some(Deletion(event))
+          fileStampCache.remove(event.path) match {
+            case null => None
+            case _    => Some(Deletion(event))
+          }
+        } else {
+          fileStampCache.update(path, FileStamper.Hash) match {
+            case (None, Some(_)) => Some(Creation(event))
+            case (Some(_), None) => Some(Deletion(event))
+            case (Some(p), Some(c)) =>
+              if (forceTrigger) {
+                val msg =
+                  s"Creating forced update event for path $path (previous stamp: $p, current stamp: $c)"
+                logger.debug(msg)
+                Some(Update(event))
+              } else if (p == c) {
+                logger.debug(s"Dropping event for unmodified path $path")
+                None
+              } else {
+                val msg =
+                  s"Creating update event for modified $path (previous stamp: $p, current stamp: $c)"
+                logger.debug(msg)
+                Some(Update(event))
+              }
+            case _ => None
+          }
+        }
+      }
+
+      if (buildGlobs.exists(_.matches(path))) {
+        getWatchEvent(forceTrigger = false).flatMap { e =>
+          state.get(CheckBuildSources.CheckBuildSourcesKey) match {
+            case Some(cbs) =>
+              if (cbs.needsReload(state, Exec("", Some(CommandSource(channel)))))
+                Some(e -> Watch.Reload)
+              else None
+            case None =>
+              Some(e -> Watch.Reload)
+          }
+        }.toSeq
+      } else {
+        val acceptedConfigParameters = configs.flatMap { config =>
+          config.inputs().flatMap {
+            case i if i.glob.matches(path) =>
+              Some((i.forceTrigger, i.fileStamper, config.watchSettings.onFileInputEvent))
+            case _ => None
+          }
+        }
+        if (acceptedConfigParameters.nonEmpty) {
+          val useHash = acceptedConfigParameters.exists(_._2 == FileStamper.Hash)
+          val forceTrigger = acceptedConfigParameters.exists(_._1)
+          val watchEvent =
+            if (useHash) getWatchEvent(forceTrigger)
+            else {
+              logger.debug(s"Trigger path detected $path")
+              Some(
+                if (!event.exists) Deletion(event)
+                else if (fileStampCache.get(path).isDefined) Creation(event)
+                else Update(event)
+              )
+            }
+          acceptedConfigParameters.flatMap {
+            case (_, _, callback) =>
+              watchEvent.map(e => e -> callback(count, e))
+          }
+        } else Nil
+      }
+    }
+    /*
+     * This is a callback that will be invoked whenever onEvent returns a Trigger action. The
+     * motivation is to allow the user to specify this callback via setting so that, for example,
+     * they can clear the screen when the build triggers.
+     */
+    val onTrigger: (Int, Watch.Event) => Unit = { (count: Int, event: Watch.Event) =>
+      if (configs.size == 1) {
+        val config = configs.head
+        config.watchSettings.triggerMessage match {
+          case Left(tm)  => logger.info(tm(config.watchState(count)))
+          case Right(tm) => tm(count, event.path, commands).foreach(logger.info(_))
+        }
+      } else {
+        Watch.defaultOnTriggerMessage(count, event.path, commands).foreach(logger.info(_))
+      }
+    }
+
+    ((count: Int) => {
+      val interrupted = new AtomicBoolean(false)
+      def getEvent: Option[(Watch.Event, Watch.Action)] = {
+        val events =
+          try antiEntropyMonitor.poll(Duration.Inf)
+          catch { case _: InterruptedException => interrupted.set(true); Nil }
+        val actions = events.flatMap(onEvent(count, _))
+        if (actions.exists(_._2 != Watch.Ignore)) {
+          val builder = new StringBuilder
+          val min = actions.minBy {
+            case (e, a) =>
+              if (builder.nonEmpty) builder.append(", ")
+              val path = e.path
+              builder.append(path)
+              builder.append(" -> ")
+              builder.append(a.toString)
+              a
+          }
+          logger.debug(s"Received file event actions: $builder. Returning: $min")
+          if (min._2 == Watch.Trigger) onTrigger(count, min._1)
+          if (min._2 == Watch.ShowOptions) None else Some(min)
+        } else None
+      }
+
+      @tailrec def impl(): Option[(Watch.Event, Watch.Action)] = getEvent match {
+        case None =>
+          if (interrupted.get || Thread.interrupted) None
+          else impl()
+        case r => r
+      }
+
+      impl()
+    }, () => monitor.close())
+  }
+
+  private[this] class WatchExecutor(name: String) extends AutoCloseable {
+    val id = new AtomicInteger(0)
+    val threads = new java.util.Vector[Thread]
+    val closed = new AtomicBoolean(false)
+    def submit[R](tag: String, f: => R): WatchExecutor.Future[R] = {
+      if (closed.get) new WatchExecutor.FutureFailed(new IllegalStateException("closed executor"))
+      else {
+        val queue = new LinkedBlockingQueue[Either[Unit, R]]
+        val latch = new CountDownLatch(1)
+        val runnable: Runnable = () => {
+          try {
+            latch.countDown()
+            Util.ignoreResult(queue.offer(if (closed.get) Left(()) else Right(f)))
+          } catch { case _: Exception => Util.ignoreResult(queue.offer(Left(()))) }
+        }
+        val thread = new Thread(runnable, s"sbt-watch-$name-$tag")
+        thread.setDaemon(true)
+        thread.start()
+        threads.add(thread)
+        new WatchExecutor.FutureImpl(thread, queue, this, latch)
+      }
+    }
+    def removeThread(thread: Thread): Unit = Util.ignoreResult(threads.remove(thread))
+    def close(): Unit = if (closed.compareAndSet(false, true)) {
+      var exception: Option[InterruptedException] = None
+      threads.forEach { thread =>
+        try thread.joinFor(1.second)
+        catch { case e: InterruptedException => exception = Some(e) }
+      }
+      threads.clear()
+      exception.foreach(throw _)
+    }
+  }
+  private object WatchExecutor {
+    sealed trait Future[R] extends Any {
+      def waitUntilStart(duration: FiniteDuration): Boolean
+      def cancel(): Unit
+      def result: Try[R]
+    }
+    final class FutureFailed[R](t: Throwable) extends Future[R] {
+      override def waitUntilStart(duration: FiniteDuration): Boolean = false
+      def cancel(): Unit = {}
+      def result: Try[R] = Failure(t)
+    }
+    final class FutureImpl[R](
+        thread: Thread,
+        queue: LinkedBlockingQueue[Either[Unit, R]],
+        executor: WatchExecutor,
+        latch: CountDownLatch,
+    ) extends Future[R] {
+      override def waitUntilStart(duration: FiniteDuration): Boolean =
+        latch.await(duration.toMillis, TimeUnit.MILLISECONDS)
+      def cancel(): Unit = {
+        executor.removeThread(thread)
+        thread.joinFor(1.second)
+      }
+      def result: Try[R] =
+        try queue.take match {
+          case Right(r) => Success(r)
+          case Left(_)  => Failure(new NullPointerException)
+        } catch { case t: InterruptedException => Failure(t) }
+    }
+  }
+
+  /**
+   * Each task has its own input parser that can be used to modify the watch based on the input
+   * read from System.in as well as a custom task-specific input stream that can be used as
+   * an alternative source of control. In this method, we create two functions for each task,
+   * one from `String => Seq[Watch.Action]` and another from `() => Seq[Watch.Action]`.
+   * Each of these functions is invoked to determine the next state transformation for the watch.
+   * The first function is a task specific copy of System.in. For each task we keep a mutable
+   * buffer of the characters previously seen from System.in. Every time we receive new characters
+   * we update the buffer and then try to parse a Watch.Action for each task. Any trailing
+   * characters are captured and can be used for the next trigger. Because each task has a local
+   * copy of the buffer, we do not have to worry about one task breaking parsing of another. We
+   * also provide an alternative per task InputStream that is read in a similar way except that
+   * we don't need to copy the custom InputStream which allows the function to be
+   * `() => Seq[Watch.Action]` which avoids actually exposing the InputStream anywhere.
+   */
+  private def parseInputEvents(
+      parser: Parser[Watch.Action],
+      alternative: Option[(TaskKey[InputStream], InputStream => Watch.Action)],
+      state: State,
+      terminal: Terminal,
+      logger: Logger,
+  )(implicit extracted: Extracted): WatchExecutor => Option[Watch.Action] = {
+    /*
+     * This parses the buffer until all possible actions are extracted. By draining the input
+     * to a state where it does not parse an action, we can wait until we receive new input
+     * to attempt to parse again.
+     */
+    // Transform the Config.watchSettings.inputParser instances to functions of type
+    // String => Watch.Action. The String that is provided will contain any characters that
+    // have been read from stdin. If there are any characters available, then it calls the
+    // parse method with the InputStream set to a ByteArrayInputStream that wraps the input
+    // string. The parse method then appends those bytes to a mutable buffer and attempts to
+    // parse the buffer. To make this work with streaming input, we prefix the parser with any.*.
+    // If the Config.watchSettings.inputStream is set, the same process is applied except that
+    // instead of passing in the wrapped InputStream for the input string, we directly pass
+    // in the inputStream provided by Config.watchSettings.inputStream.
+    val inputHandler: String => Watch.Action = {
+      val any = Parsers.any.*
+      val fullParser = any ~> parser ~ matched(any)
+      // Each parser gets its own copy of System.in that it can modify while parsing.
+      val systemInBuilder = new StringBuilder
+
+      def inputStream(string: String): InputStream = new ByteArrayInputStream(string.getBytes)
+
+      // This string is provided in the closure below by reading from System.in
+      val default: String => Watch.Action =
+        string => parse(inputStream(string), systemInBuilder, fullParser)
+      val alt = alternative
+        .map {
+          case (key, handler) =>
+            val is = extracted.runTask(key, state)._2
+            () => handler(is)
+        }
+        .getOrElse(() => Watch.Ignore)
+      string: String =>
+        ((if (string.nonEmpty) default(string) else Watch.Ignore) :: alt() :: Nil).min
+    }
+    executor => {
+      val interrupted = new AtomicBoolean(false)
+      @tailrec def read(): Int = {
+        if (terminal.name.startsWith("network")) terminal.inputStream.read
+        else if (Terminal.canPollSystemIn || terminal.inputStream.available > 0)
+          terminal.inputStream.read
+        else {
+          Thread.sleep(50)
+          read()
+        }
+      }
+      @tailrec def impl(): Option[Watch.Action] = {
+        val action =
+          try {
+            interrupted.set(false)
+            read() match {
+              case -1   => throw new InterruptedException
+              case 3    => Watch.CancelWatch // ctrl+c on windows
+              case byte => inputHandler(byte.toChar.toString)
+            }
+          } catch {
+            case _: InterruptedException =>
+              interrupted.set(true)
+              Watch.Ignore
+          }
+        action match {
+          case Watch.Ignore =>
+            val stop = interrupted.get || Thread.interrupted
+            if (!stop) impl()
+            else None
+          case r => Some(r)
+        }
+      }
+
+      terminal.withRawInput(impl())
+    }
+  }
+
+  private def combineInputAndFileEvents(
+      nextInputAction: WatchExecutor => Option[Watch.Action],
+      nextFileEvent: Int => Option[(Watch.Event, Watch.Action)],
+      options: String,
+      logger: Logger,
+      rawLogger: Logger,
+      executor: WatchExecutor,
+      channel: CommandChannel
+  ): Int => Watch.Action = count => {
+    val events = new LinkedBlockingQueue[Either[Watch.Action, (Watch.Event, Watch.Action)]]
+
+    val inputJob =
+      executor
+        .submit(s"handle-input-$count", nextInputAction(executor).foreach(a => events.put(Left(a))))
+    val fileJob =
+      executor
+        .submit(s"get-file-events-$count", nextFileEvent(count).foreach(e => events.put(Right(e))))
+    val signalRegistration = channel match {
+      case _: ConsoleChannel => Some(Signals.register(() => events.put(Left(Watch.CancelWatch))))
+      case _                 => None
+    }
+    try {
+      if (!inputJob.waitUntilStart(1.second) || !fileJob.waitUntilStart(1.second)) {
+        inputJob.cancel()
+        fileJob.cancel()
+        new Watch.HandleError(new TimeoutException)
+      } else {
+        val (inputAction: Watch.Action, fileEvent: Option[(Watch.Event, Watch.Action)]) =
+          events.take() match {
+            case Left(a)  => (a, None)
+            case Right(e) => (Watch.Ignore, Some(e))
+          }
+        val min: Watch.Action = (fileEvent.map(_._2).toSeq :+ inputAction).min
+        lazy val inputMessage =
+          s"Received input event: $inputAction." +
+            (if (inputAction != min) s" Dropping in favor of file event: $min" else "")
+        if (inputAction != Watch.Ignore) logger.info(inputMessage)
+        fileEvent
+          .collect {
+            case (event, action) if action != Watch.Ignore =>
+              s"Received file event $action for $event." +
+                (if (action != min) s" Dropping in favor of input event: $min" else "")
+          }
+          .foreach(logger.debug(_))
+        min match {
+          case ShowOptions =>
+            rawLogger.info(options)
+            Watch.Ignore
+          case m => m
+        }
+      }
+    } finally {
+      signalRegistration.foreach(_.remove())
+      inputJob.cancel()
+      fileJob.cancel()
+      ()
+    }
+  }
+
+  @tailrec
+  private final def parse(
+      is: InputStream,
+      builder: StringBuilder,
+      parser: Parser[(Watch.Action, String)]
+  ): Watch.Action = {
+    if (is.available > 0) builder += is.read().toChar
+    Parser.parse(builder.toString, parser) match {
+      case Right((action, rest)) =>
+        builder.clear()
+        builder ++= rest
+        action
+      case _ if is.available > 0 => parse(is, builder, parser)
+      case _                     => Watch.Ignore
+    }
+  }
+
+  private type WatchOnEvent = (Int, Watch.Event) => Watch.Action
+
+  /**
+   * Contains all of the user defined settings that will be used to build a [[Callbacks]]
+   * instance that is used to produce the arguments to [[Watch.apply]]. The
+   * callback settings (e.g. onEvent or onInputEvent) come in two forms: those that return a
+   * function from [[Arguments]] => F for some function type `F` and those that directly return a function, e.g.
+   * `(Int, Boolean) => Watch.Action`. The former are a low level interface that will usually
+   * be unspecified and automatically filled in by [[Continuous.aggregate]]. The latter are
+   * intended to be user configurable and will be scoped to the input [[ScopedKey]]. To ensure
+   * that the scoping makes sense, we first try and extract the setting from the [[ScopedKey]]
+   * instance's task scope, which is the scope with the task axis set to the task key. If that
+   * fails, we fall back on the task axis. To make this concrete, to get the logLevel for
+   * `foo / Compile / compile` (which is a TaskKey with scope `foo / Compile`), we first try and
+   * get the setting in the `foo / Compile / compile` scope. If logLevel is not set at the task
+   * level, then we fall back to the `foo / Compile` scope.
+   *
+   * This has to be done by manually extracting the settings via [[Extracted]] because there is
+   * no good way to automatically add a [[WatchSettings]] setting to every task in the build.
+   * Thankfully these map retrievals are reasonably fast so there is not a significant runtime
+   * performance penalty for creating the [[WatchSettings]] this way. The drawback is that we
+   * have to manually resolve the settings in multiple scopes which may lead to inconsistencies
+   * with scope resolution elsewhere in sbt.
+   *
+   * @param key the [[ScopedKey]] instance that sets the [[Scope]] for the settings we're extracting
+   * @param extracted the [[Extracted]] instance for the build
+   */
+  private final class WatchSettings private[Continuous] (val key: ScopedKey[_])(
+      implicit extracted: Extracted
+  ) {
+    val antiEntropy: FiniteDuration =
+      key.get(watchAntiEntropy).getOrElse(Watch.defaultAntiEntropy)
+    val antiEntropyRetentionPeriod: FiniteDuration =
+      key
+        .get(watchAntiEntropyRetentionPeriod)
+        .getOrElse(Watch.defaultAntiEntropyRetentionPeriod)
+    val deletionQuarantinePeriod: FiniteDuration =
+      key.get(watchDeletionQuarantinePeriod).getOrElse(Watch.defaultDeletionQuarantinePeriod)
+    val inputHandler: Option[InputStream => Watch.Action] = key.get(watchInputHandler)
+    val inputOptions: Seq[Watch.InputOption] =
+      key.get(watchInputOptions).getOrElse(Watch.defaultInputOptions)
+    val inputOptionsMessage: String =
+      key.get(watchInputOptionsMessage).getOrElse(Watch.defaultInputOptionsMessage(inputOptions))
+    val inputParser: Parser[Watch.Action] =
+      key.get(watchInputParser).getOrElse(Watch.defaultInputParser(inputOptions))
+    val logLevel: Level.Value = key.get(watchLogLevel).getOrElse(Level.Info)
+    val beforeCommand: () => Unit = key.get(watchBeforeCommand).getOrElse(() => {})
+    val onFileInputEvent: WatchOnEvent =
+      key.get(watchOnFileInputEvent).getOrElse(Watch.trigger)
+    val onIteration: Option[(Int, ProjectRef, Seq[String]) => Watch.Action] =
+      key.get(watchOnIteration)
+    val onTermination: Option[(Watch.Action, String, Int, State) => State] =
+      key.get(watchOnTermination)
+    val startMessage: StartMessage = getStartMessage(key)
+    val trackMetaBuild: Boolean =
+      key.get(onChangedBuildSource).fold(false)(_ == ReloadOnSourceChanges)
+    val triggerMessage: TriggerMessage = getTriggerMessage(key)
+
+    // Unlike the rest of the settings, InputStream is a TaskKey which means that if it is set,
+    // we have to use Extracted.runTask to get the value. The reason for this is because it is
+    // logical that users may want to use a different InputStream on each task invocation. The
+    // alternative would be SettingKey[() => InputStream], but that doesn't feel right because
+    // one might want the InputStream to depend on other tasks.
+    val inputStream: Option[TaskKey[InputStream]] = key.get(watchInputStream)
+    val antiEntropyPollPeriod: FiniteDuration =
+      key.get(watchAntiEntropyPollPeriod).getOrElse(Watch.defaultAntiEntropyPollPeriod)
+  }
+
+  /**
+   * Container class for all of the components we need to setup a watch for a particular task or
+   * input task.
+   *
+   * @param command       the name of the command/task to run with each iteration
+   * @param inputs        the transitive task inputs (see [[SettingsGraph]])
+   * @param watchSettings the [[WatchSettings]] instance for the task
+   */
+  private final class Config private[internal] (
+      val command: String,
+      val dynamicInputs: mutable.Set[DynamicInput],
+      val watchSettings: WatchSettings
+  ) {
+    def inputs() = dynamicInputs.toSeq.sorted
+    private[sbt] def watchState(count: Int): DeprecatedWatchState =
+      WatchState.empty(inputs().map(_.glob)).withCount(count)
+
+    def arguments(logger: Logger): Arguments = new Arguments(logger, inputs())
+  }
+
+  private def getStartMessage(key: ScopedKey[_])(implicit e: Extracted): StartMessage = Some {
+    lazy val default = key.get(watchStartMessage).getOrElse(Watch.defaultStartWatch)
+    key.get(deprecatedWatchingMessage).map(Left(_)).getOrElse(Right(default))
+  }
+
+  private def getTriggerMessage(
+      key: ScopedKey[_]
+  )(implicit e: Extracted): TriggerMessage = {
+    lazy val default =
+      key.get(watchTriggeredMessage).getOrElse(Watch.defaultOnTriggerMessage)
+    key.get(deprecatedTriggeredMessage).map(Left(_)).getOrElse(Right(default))
+  }
+
+  private implicit class ScopeOps(val scope: Scope) {
+
+    /**
+     * This shows the [[Scope]] in the format that a user would likely type it in a build
+     * or in the sbt console. For example, the key corresponding to the command
+     * foo/Compile/compile will pretty print as "foo / Compile / compile", not
+     * "ProjectRef($URI, foo) / compile / compile", where the ProjectRef part is just noise that
+     * is rarely relevant for debugging.
+     *
+     * @return the pretty printed output.
+     */
+    def show: String = {
+      val mask = ScopeMask(
+        config = scope.config.toOption.isDefined,
+        task = scope.task.toOption.isDefined,
+        extra = scope.extra.toOption.isDefined
+      )
+      Scope
+        .displayMasked(scope, " ", (_: Reference) match {
+          case p: ProjectRef => s"${p.project.trim} /"
+          case _             => "Global /"
+        }, mask)
+        .dropRight(3) // delete trailing "/"
+        .trim
+    }
+  }
+
+  private implicit class ScopedKeyOps(val scopedKey: ScopedKey[_]) extends AnyVal {
+
+    /**
+     * Gets the value for a setting key scoped to the wrapped [[ScopedKey]]. If the task axis is not
+     * set in the [[ScopedKey]], then we first set the task axis and try to extract the setting
+     * from that scope otherwise we fallback on the [[ScopedKey]] instance's scope. We use the
+     * reverse order if the task is set.
+     *
+     * @param settingKey the [[SettingKey]] to extract
+     * @param extracted  the provided [[Extracted]] instance
+     * @tparam T the type of the [[SettingKey]]
+     * @return the optional value of the [[SettingKey]] if it is defined at the input
+     *         [[ScopedKey]] instance's scope or task scope.
+     */
+    def get[T](settingKey: SettingKey[T])(implicit extracted: Extracted): Option[T] = {
+      lazy val taskScope = Project.fillTaskAxis(scopedKey).scope
+      scopedKey.scope match {
+        case scope if scope.task.toOption.isDefined =>
+          extracted.getOpt((scope / settingKey)) orElse extracted.getOpt((taskScope / settingKey))
+        case scope =>
+          extracted.getOpt((taskScope / settingKey)) orElse extracted.getOpt((scope / settingKey))
+      }
+    }
+
+    /**
+     * Gets the [[ScopedKey]] for a task scoped to the wrapped [[ScopedKey]]. If the task axis is
+     * not set in the [[ScopedKey]], then we first set the task axis and try to extract the tak
+     * from that scope otherwise we fallback on the [[ScopedKey]] instance's scope. We use the
+     * reverse order if the task is set.
+     *
+     * @param taskKey   the [[TaskKey]] to extract
+     * @param extracted the provided [[Extracted]] instance
+     * @tparam T the type of the [[SettingKey]]
+     * @return the optional value of the [[SettingKey]] if it is defined at the input
+     *         [[ScopedKey]] instance's scope or task scope.
+     */
+    def get[T](taskKey: TaskKey[T])(implicit extracted: Extracted): Option[TaskKey[T]] = {
+      lazy val taskScope = Project.fillTaskAxis(scopedKey).scope
+      scopedKey.scope match {
+        case scope if scope.task.toOption.isDefined =>
+          if (extracted.getOpt((scope / taskKey)).isDefined) Some((scope / taskKey))
+          else if (extracted.getOpt((taskScope / taskKey)).isDefined) Some((taskScope / taskKey))
+          else None
+        case scope =>
+          if (extracted.getOpt((taskScope / taskKey)).isDefined) Some((taskScope / taskKey))
+          else if (extracted.getOpt((scope / taskKey)).isDefined) Some((scope / taskKey))
+          else None
+      }
+    }
+
+    /**
+     * This shows the [[ScopedKey[_]] in the format that a user would likely type it in a build
+     * or in the sbt console. For example, the key corresponding to the command
+     * foo/Compile/compile will pretty print as "foo / Compile / compile", not
+     * "ProjectRef($URI, foo) / compile / compile", where the ProjectRef part is just noise that
+     * is rarely relevant for debugging.
+     *
+     * @return the pretty printed output.
+     */
+    def show: String = s"${scopedKey.scope.show} / ${scopedKey.key}"
+  }
+
+  private implicit class LoggerOps(val logger: Logger) extends AnyVal {
+
+    /**
+     * Creates a logger that adds a prefix to the messages that it logs. The motivation is so that
+     * we can tell from which FileEventMonitor an event originated.
+     *
+     * @param prefix the string to prefix the message with
+     * @return the wrapped Logger.
+     */
+    def withPrefix(prefix: String): Logger = new Logger {
+      override def trace(t: => Throwable): Unit = logger.trace(t)
+
+      override def success(message: => String): Unit = logger.success(message)
+
+      override def log(level: Level.Value, message: => String): Unit =
+        logger.log(level, s"$prefix - $message")
+    }
+  }
+
+  private[sbt] class FileStampRepository(
+      fileStampCache: FileStamp.Cache,
+      underlying: FileTreeRepository[FileAttributes]
+  ) extends FileTreeRepository[FileAttributes] {
+    def putIfAbsent(path: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) =
+      fileStampCache.putIfAbsent(path, stamper)
+    override def list(path: Path): Seq[(Path, FileAttributes)] = underlying.list(path)
+    override def addObserver(observer: Observer[FileEvent[FileAttributes]]): AutoCloseable =
+      underlying.addObserver(observer)
+    override def register(glob: Glob): Either[IOException, Observable[FileEvent[FileAttributes]]] =
+      underlying.register(glob)
+    override def close(): Unit = underlying.close()
+  }
+
+  private[sbt] final class ContinuousState(
+      val count: Int,
+      val commands: Seq[String],
+      beforeCommandImpl: (State, mutable.Set[DynamicInput]) => State,
+      val afterCommand: State => State,
+      val afterWatch: State => State,
+      val callbacks: Callbacks,
+      val dynamicInputs: mutable.Set[DynamicInput],
+      val pending: Boolean,
+  ) {
+    def beforeCommand(state: State): State = beforeCommandImpl(state, dynamicInputs)
+    def incremented: ContinuousState = withCount(count + 1)
+    def withPending(p: Boolean) =
+      new ContinuousState(
+        count,
+        commands,
+        beforeCommandImpl,
+        afterCommand,
+        afterWatch,
+        callbacks,
+        dynamicInputs,
+        p
+      )
+    private def withCount(c: Int): ContinuousState =
+      new ContinuousState(
+        c,
+        commands,
+        beforeCommandImpl,
+        afterCommand,
+        afterWatch,
+        callbacks,
+        dynamicInputs,
+        pending
+      )
+  }
+}
+
+private[sbt] object ContinuousCommands {
+  private[sbt] def value: Seq[Command] = Vector(
+    failWatchCommand,
+    preWatchCommand,
+    postWatchCommand,
+    runWatchCommand,
+    stopWatchCommand,
+  )
+  private[sbt] val watchStateCallbacks =
+    AttributeKey[java.util.Map[String, (State => State, State => State)]](
+      "sbt-watch-state-callbacks",
+      "",
+      Int.MaxValue
+    )
+  private[this] val watchStates =
+    AttributeKey[Map[String, ContinuousState]]("sbt-watch-states", Int.MaxValue)
+  private[sbt] val runWatch = networkExecPrefix + "runWatch"
+  private[sbt] val preWatch = networkExecPrefix + "preWatch"
+  private[sbt] val postWatch = networkExecPrefix + "postWatch"
+  private[sbt] val stopWatch = networkExecPrefix + "stopWatch"
+  private[sbt] val failWatch = networkExecPrefix + "failWatch"
+  private[sbt] val waitWatch = networkExecPrefix + "waitWatch"
+  private[this] def noComplete[T](p: Parser[T]): Parser[T] = p.examples()
+  private[this] val space = noComplete(Space)
+  private[this] def cmdParser(s: String): Parser[String] = noComplete(matched(s)) <~ space
+  private[this] def channelParser: Parser[String] =
+    noComplete(matched(charClass(c => c.isLetterOrDigit || c == '-').+))
+
+  private[this] val stashedRepo = AttributeKey[FileTreeRepository[FileAttributes]](
+    "stashed-file-tree-repository",
+    "",
+    Int.MaxValue
+  )
+  private[sbt] val setupWatchState: (String, Int, Seq[String], State) => State =
+    (channelName, count, commands, state) => {
+      state.get(watchStates).flatMap(_.get(channelName)) match {
+        case None =>
+          val extracted = Project.extract(state)
+          val repo = state.get(globalFileTreeRepository) match {
+            case Some(r) => localRepo(r)
+            case _ =>
+              throw new IllegalStateException(s"No file tree repository was found for $state")
+          }
+          val cache = new FileStamp.Cache
+          repo.addObserver(t => cache.invalidate(t.path))
+          val persistFileStamps = extracted.get(watchPersistFileStamps)
+          val cachingRepo: FileTreeRepository[FileAttributes] =
+            if (persistFileStamps) repo else new FileStampRepository(cache, repo)
+          val channel = StandardMain.exchange
+            .channelForName(channelName)
+            .getOrElse(throw new IllegalStateException(s"No channel with name $channelName"))
+          val dynamicInputs = mutable.Set.empty[DynamicInput]
+          val context = LoggerContext(useLog4J = state.get(Keys.useLog4J.key).getOrElse(false))
+          def cb: Continuous.Callbacks =
+            Continuous.getCallbacks(state, channel, commands, cache, dynamicInputs, context)
+
+          val s = new ContinuousState(
+            count = count,
+            commands = commands,
+            beforeCommandImpl = (state, dynamicInputs) => {
+              val original = state
+                .get(globalFileTreeRepository)
+                .getOrElse(
+                  throw new IllegalStateException(
+                    s"No global file tree repository for state $state"
+                  )
+                )
+              val stateWithRepo =
+                state.put(globalFileTreeRepository, cachingRepo).put(stashedRepo, original)
+              val stateWithCache =
+                if (persistFileStamps) stateWithRepo.put(persistentFileStampCache, cache)
+                else stateWithRepo
+              stateWithCache.put(Continuous.DynamicInputs, dynamicInputs)
+            },
+            afterCommand = state => {
+              val newWatchState = state.get(watchStates) match {
+                case None => state
+                case Some(ws) =>
+                  ws.get(channelName) match {
+                    case None     => state
+                    case Some(cs) => state.put(watchStates, ws + (channelName -> cs.incremented))
+                  }
+              }
+              val restoredState = newWatchState.get(stashedRepo) match {
+                case None    => throw new IllegalStateException(s"No stashed repository for $state")
+                case Some(r) => newWatchState.put(globalFileTreeRepository, r)
+              }
+              restoredState.remove(persistentFileStampCache).remove(Continuous.DynamicInputs)
+            },
+            afterWatch = state => {
+              context.clearAppenders(channelName + "-watch")
+              repo.close()
+              context.close()
+              state.get(watchStates) match {
+                case None     => state
+                case Some(ws) => state.put(watchStates, ws - channelName)
+              }
+            },
+            callbacks = cb,
+            dynamicInputs = dynamicInputs,
+            pending = false,
+          )
+          state.get(watchStates) match {
+            case None     => state.put(watchStates, Map(channelName -> s))
+            case Some(ws) => state.put(watchStates, ws + (channelName -> s))
+          }
+        case Some(cs) =>
+          val cmd = cs.commands.mkString("; ")
+          val msg =
+            s"Tried to start new watch while channel, '$channelName', was already watching '$cmd'"
+          throw new IllegalStateException(msg)
+      }
+    }
+  private[this] def watchCommand(
+      name: String
+  )(updateState: (String, State) => State): Command =
+    Command.arb { state =>
+      (cmdParser(name) ~> channelParser).map(channel => () => updateState(channel, state))
+    } { case (_, newState) => newState() }
+  private[sbt] val runWatchCommand = watchCommand(runWatch) { (channel, state) =>
+    state.get(watchStates).flatMap(_.get(channel)) match {
+      case None => state
+      case Some(cs) =>
+        val pre = StashOnFailure :: s"$preWatch $channel" :: Nil
+        val post = FailureWall :: PopOnFailure :: s"$postWatch $channel" :: Nil
+        pre ::: cs.commands.toList ::: post ::: state
+    }
+  }
+  private[sbt] def watchUITaskFor(state: State, channel: CommandChannel): Option[UITask] =
+    state.get(watchStates).flatMap(_.get(channel.name)).map(new WatchUITask(channel, _, state))
+  private[sbt] def isInWatch(state: State, channel: CommandChannel): Boolean =
+    state.get(watchStates).exists(_.contains(channel.name))
+  private[sbt] def isPending(state: State, channel: CommandChannel): Boolean =
+    state.get(watchStates).exists(_.get(channel.name).exists(_.pending))
+  private[this] class WatchUITask(
+      override private[sbt] val channel: CommandChannel,
+      cs: ContinuousState,
+      state: State
+  ) extends Thread(s"sbt-${channel.name}-watch-ui-thread")
+      with UITask {
+    override private[sbt] lazy val reader: UITask.Reader = () => {
+      def stop = Right(s"${ContinuousCommands.stopWatch} ${channel.name}")
+      val exitAction: Watch.Action = {
+        Watch.apply(
+          cs.count,
+          _ => (),
+          cs.callbacks.onStart,
+          cs.callbacks.nextEvent,
+          recursive = false
+        )
+      }
+      val ws = state.get(watchStates) match {
+        case None => throw new IllegalStateException("no watch states")
+        case Some(ws) =>
+          ws.get(channel.name)
+            .getOrElse(throw new IllegalStateException(s"no watch state for ${channel.name}"))
+      }
+      exitAction match {
+        // Use a Left so that the client can immediately exit watch via <enter>
+        case Watch.CancelWatch => Left(s"$stopWatch ${channel.name}")
+        case Watch.Trigger     => Right(s"$runWatch ${channel.name}")
+        case Watch.Reload =>
+          val rewatch = s"$ContinuousExecutePrefix ${ws.count} ${cs.commands mkString "; "}"
+          stop.map(_ :: "reload" :: rewatch :: Nil mkString "; ")
+        case Watch.Prompt => stop.map(_ :: s"$PromptChannel ${channel.name}" :: Nil mkString ";")
+        case Watch.Run(commands) =>
+          stop.map(_ +: commands.map(_.commandLine).filter(_.nonEmpty) mkString "; ")
+        case Watch.HandleError(_) =>
+          stop.map(_ :: s"$failWatch ${channel.name}" :: Nil mkString "; ")
+        case _ => stop
+      }
+    }
+  }
+  @inline
+  private[this] def watchState(state: State, channel: String): ContinuousState =
+    state.get(watchStates).flatMap(_.get(channel)) match {
+      case None    => throw new IllegalStateException(s"no watch state for $channel")
+      case Some(s) => s
+    }
+
+  private[sbt] val preWatchCommand = watchCommand(preWatch) { (channel, state) =>
+    val ws = watchState(state, channel)
+    val newState = ws.beforeCommand(state)
+    ws.callbacks.beforeCommand()
+    newState
+  }
+  private[sbt] val postWatchCommand = watchCommand(postWatch) { (channel, state) =>
+    val cs = watchState(state, channel)
+    StandardMain.exchange.channelForName(channel).foreach { c =>
+      c.terminal.setPrompt(Prompt.Pending)
+    }
+    val postState = state.get(watchStates) match {
+      case None     => state
+      case Some(ws) => state.put(watchStates, ws + (channel -> cs.withPending(false)))
+    }
+    cs.afterCommand(postState)
+  }
+  private[sbt] val stopWatchCommand = watchCommand(stopWatch) { (channel, state) =>
+    state.get(watchStates).flatMap(_.get(channel)) match {
+      case Some(cs) =>
+        val afterWatchState = cs.afterWatch(state)
+        cs.callbacks.onExit()
+        StandardMain.exchange
+          .channelForName(channel)
+          .foreach { c =>
+            c.terminal.setPrompt(Prompt.Pending)
+            c.unprompt(ConsoleUnpromptEvent(Some(CommandSource(channel))))
+          }
+        afterWatchState.get(watchStates) match {
+          case None    => afterWatchState
+          case Some(w) => afterWatchState.put(watchStates, w - channel)
+        }
+      case _ => state
+    }
+  }
+  private[sbt] val failWatchCommand = watchCommand(failWatch) { (channel, state) =>
+    state.fail
+  }
+  /*
+   * Creates a FileTreeRepository where it is safe to call close without inadvertently cancelling
+   * still active watches.
+   */
+  private[this] def localRepo[T](r: FileTreeRepository[T]): FileTreeRepository[T] =
+    new FileTreeRepository[T] {
+      private[this] val closeables = ConcurrentHashMap.newKeySet[AutoCloseable]
+      override def addObserver(observer: Observer[FileEvent[T]]): AutoCloseable = {
+        val ac = r.addObserver(observer)
+        val safeCloseable: AutoCloseable = () =>
+          try ac.close()
+          catch { case NonFatal(_) => }
+        closeables.add(safeCloseable)
+        () => {
+          closeables.remove(safeCloseable)
+          safeCloseable.close()
+        }
+      }
+
+      override def register(glob: Glob): Either[IOException, Observable[FileEvent[T]]] =
+        r.register(glob)
+      override def close(): Unit = closeables.forEach { c =>
+        try c.close()
+        catch { case NonFatal(_) => }
+      }
+      override def list(path: Path): Seq[(Path, T)] = r.list(path)
+    }
+
+}
diff --git a/main/src/main/scala/sbt/internal/CrossJava.scala b/main/src/main/scala/sbt/internal/CrossJava.scala
new file mode 100644
index 000000000..4764fc829
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/CrossJava.scala
@@ -0,0 +1,527 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.File
+import scala.collection.immutable.ListMap
+import scala.annotation.tailrec
+import scala.util.{ Try, Success, Failure }
+import sbt.io.Path
+import sbt.io.syntax._
+import sbt.Cross._
+import sbt.Def.{ ScopedKey, Setting }
+import sbt.SlashSyntax0._
+import sbt.internal.util.complete.DefaultParsers._
+import sbt.internal.util.AttributeKey
+import sbt.internal.util.complete.{ DefaultParsers, Parser }
+import sbt.internal.CommandStrings.{
+  JavaCrossCommand,
+  JavaSwitchCommand,
+  javaCrossHelp,
+  javaSwitchHelp
+}
+
+private[sbt] object CrossJava {
+  // parses jabba style version number adopt@1.8
+  def parseJavaVersion(version: String): JavaVersion = {
+    val Num = """([0-9]+)""".r
+    def splitDot(s: String): Vector[Long] =
+      Option(s) match {
+        case Some(x) =>
+          x.split('.').toVector collect {
+            case Num(n) => n.toLong
+          }
+        case _ => Vector()
+      }
+    def splitDash(str: String): Vector[String] =
+      Option(str).fold(Vector.empty[String])(_.split('-').toVector)
+    def splitAt(s: String): Vector[String] =
+      Option(s).fold(Vector.empty[String])(_.split('@').toVector)
+    def parse0(str: String): JavaVersion =
+      splitDash(str) match {
+        case Vector()  => sys.error(s"Invalid JavaVersion: $version")
+        case Vector(h) => JavaVersion(splitDot(h), Vector(), None)
+        case xs        => JavaVersion(splitDot(xs.head), xs.tail, None)
+      }
+    splitAt(version) match {
+      case Vector(vendor, rest) => parse0(rest).withVendor(vendor)
+      case Vector(rest)         => parse0(rest)
+      case _                    => sys.error(s"Invalid JavaVersion: $version")
+    }
+  }
+
+  def parseSdkmanString(version: String): Try[JavaVersion] = Try {
+    val Num = """([0-9]+)""".r
+    def splitDash(str: String): Vector[String] =
+      Option(str).fold(Vector.empty[String])(_.split('-').toVector)
+    def splitDot(str: String): Vector[String] =
+      Option(str) match {
+        case Some(x) => x.split('.').toVector.filterNot(_ == "")
+        case _       => Vector()
+      }
+    splitDash(version) match {
+      case xs if xs.size < 2 => sys.error(s"Invalid SDKMAN Java version: $version")
+      case xs =>
+        val first = xs.init.head
+        val ds =
+          if (!first.contains(".") && first.contains("u")) splitDot(first.replaceFirst("u", ".0."))
+          else splitDot(first)
+        val nums = ds.takeWhile(
+          _ match {
+            case Num(_) => true
+            case _      => false
+          }
+        ) map { _.toLong }
+        if (nums.isEmpty) {
+          sys.error(s"Invalid SDKMAN Java version: $version")
+        }
+        val nonNum = ds.drop(nums.size).mkString("")
+        // last dash indicates vendor code
+        val (vnd0, tag0) = (xs.last, nonNum) match {
+          case ("adpt", "hs") => ("adpt", "")
+          case ("adpt", "j9") => ("adopt-openj9", "")
+          case (v, t)         => (v, t)
+        }
+        val vnd = vnd0 match {
+          case "adpt" => "adopt"
+          case "open" => "openjdk"
+          case "grl"  => "graalvm"
+          case "amzn" => "corretto"
+          case _      => vnd0
+        }
+        val tag1: String = xs.init.tail.mkString("")
+        val tags = (if (tag0 == "") Vector.empty[String] else Vector(tag0)) ++
+          (if (tag1 == "") Vector.empty[String] else Vector(tag1))
+        JavaVersion().withNumbers(nums).withVendor(vnd).withTags(tags)
+    }
+  }
+
+  def lookupJavaHome(jv: String, mappings: Map[String, File]): File = {
+    val ms = mappings map { case (k, v) => (JavaVersion(k), v) }
+    lookupJavaHome(JavaVersion(jv), ms)
+  }
+
+  def lookupJavaHome(jv: JavaVersion, mappings: Map[JavaVersion, File]): File = {
+    mappings.get(jv) match {
+      case Some(dir) => dir
+
+      // when looking for "10" it should match "openjdk@10"
+      case None if jv.vendor.isEmpty =>
+        val noVendors: Map[JavaVersion, File] = mappings map {
+          case (k, v) => k.withVendor(None) -> v
+        }
+        noVendors.get(jv).getOrElse(javaHomeNotFound(jv, mappings))
+      case _ => javaHomeNotFound(jv, mappings)
+    }
+  }
+
+  private def javaHomeNotFound(version: JavaVersion, mappings: Map[JavaVersion, File]): Nothing = {
+    sys.error(s"""Java home for $version was not found in $mappings
+                 |
+                 |use Global / javaHomes += JavaVersion("$version") -> file(...)""".stripMargin)
+  }
+
+  private case class SwitchTarget(version: Option[JavaVersion], home: Option[File], force: Boolean)
+  private case class SwitchJavaHome(target: SwitchTarget, verbose: Boolean, command: Option[String])
+
+  private def switchParser(state: State): Parser[SwitchJavaHome] = {
+    import DefaultParsers._
+    def versionAndCommand(spacePresent: Boolean) = {
+      val x = Project.extract(state)
+      import x._
+      val javaHomes = getJavaHomesTyped(x, currentRef)
+      val knownVersions = javaHomes.keysIterator.map(_.numberStr).toVector
+      val version: Parser[SwitchTarget] =
+        (token(
+          (StringBasic <~ "@").? ~ ((NatBasic) ~ ("." ~> NatBasic).*)
+            .examples(knownVersions: _*) ~ "!".?
+        ) || token(StringBasic))
+          .map {
+            case Left(((vendor, (v1, vs)), bang)) =>
+              val force = bang.isDefined
+              val versionArg = (Vector(v1) ++ vs) map { _.toLong }
+              SwitchTarget(Option(JavaVersion(versionArg, vendor)), None, force)
+            case Right(home) =>
+              SwitchTarget(None, Option(new File(home)), true)
+          }
+      val spacedVersion =
+        if (spacePresent) version
+        else version & spacedFirst(JavaSwitchCommand)
+      val verbose = Parser.opt(token(Space ~> "-v"))
+      val optionalCommand = Parser.opt(token(Space ~> matched(state.combinedParser)))
+      (spacedVersion ~ verbose ~ optionalCommand).map {
+        case v ~ verbose ~ command =>
+          SwitchJavaHome(v, verbose.isDefined, command)
+      }
+    }
+    token(JavaSwitchCommand ~> OptSpace) flatMap { sp =>
+      versionAndCommand(sp.nonEmpty)
+    }
+  }
+
+  private def getJavaHomes(
+      extracted: Extracted,
+      proj: ResolvedReference
+  ): Map[String, File] = {
+    import extracted._
+    ((proj / Keys.fullJavaHomes) get structure.data).get
+  }
+
+  private def getJavaHomesTyped(
+      extracted: Extracted,
+      proj: ResolvedReference
+  ): Map[JavaVersion, File] = {
+    getJavaHomes(extracted, proj) map { case (k, v) => (JavaVersion(k), v) }
+  }
+
+  private def getCrossJavaVersions(
+      extracted: Extracted,
+      proj: ResolvedReference
+  ): Seq[String] = {
+    import extracted._
+    import Keys._
+    ((proj / crossJavaVersions) get structure.data).getOrElse(Nil)
+  }
+
+  private def getCrossJavaHomes(extracted: Extracted, proj: ResolvedReference): Seq[File] = {
+    import extracted._
+    import Keys._
+    val fjh = ((proj / fullJavaHomes) get structure.data).get
+    ((proj / crossJavaVersions) get structure.data) map { jvs =>
+      jvs map { jv =>
+        lookupJavaHome(jv, fjh)
+      }
+    } getOrElse Vector()
+  }
+
+  private def switchCommandImpl(state: State, switch: SwitchJavaHome): State = {
+    val extracted = Project.extract(state)
+    import extracted._
+    import Keys.javaHome
+
+    // filter out subprojects based on switch target e.g. "10" vs what's in crossJavaVersions
+    // for the subproject. Only if crossJavaVersions is non-empty, and does NOT include "10"
+    // it will skip the subproject.
+    val projects: Seq[(ResolvedReference, Seq[String])] = {
+      val projectJavaVersions =
+        structure.allProjectRefs.map(proj => proj -> getCrossJavaVersions(extracted, proj))
+      if (switch.target.force) projectJavaVersions
+      else
+        switch.target.version match {
+          case None => projectJavaVersions
+          case Some(v) =>
+            projectJavaVersions flatMap {
+              case (proj, versions) =>
+                if (versions.isEmpty || versions.contains[String](v.toString))
+                  Vector(proj -> versions)
+                else Vector()
+            }
+        }
+    }
+
+    def setJavaHomeForProjects: State = {
+      val newSettings = projects.flatMap {
+        case (proj, javaVersions) =>
+          val fjh = getJavaHomesTyped(extracted, proj)
+          val home = switch.target match {
+            case SwitchTarget(Some(v), _, _) => lookupJavaHome(v, fjh)
+            case SwitchTarget(_, Some(h), _) => h
+            case _                           => sys.error(s"unexpected ${switch.target}")
+          }
+          val scope = Scope(Select(proj), Zero, Zero, Zero)
+          Seq(
+            (scope / javaHome) := Some(home)
+          )
+      }
+
+      val filterKeys: Set[AttributeKey[_]] = Set(javaHome).map(_.key)
+
+      val projectsContains: Reference => Boolean = projects.map(_._1).toSet[Reference].contains(_)
+
+      // Filter out any old javaHome version settings that were added, this is just for hygiene.
+      val filteredRawAppend = session.rawAppend.filter(_.key match {
+        case ScopedKey(Scope(Select(ref), Zero, Zero, Zero), key)
+            if filterKeys.contains(key) && projectsContains(ref) =>
+          false
+        case _ => true
+      })
+
+      val newSession = session.copy(rawAppend = filteredRawAppend ++ newSettings)
+
+      BuiltinCommands.reapply(newSession, structure, state)
+    }
+
+    setJavaHomeForProjects
+  }
+
+  def switchJavaHome: Command =
+    Command.arb(requireSession(switchParser), javaSwitchHelp)(switchCommandImpl)
+
+  def crossJavaHome: Command =
+    Command.arb(requireSession(crossParser), javaCrossHelp)(crossJavaHomeCommandImpl)
+
+  private case class CrossArgs(command: String, verbose: Boolean)
+
+  /**
+   * Parse the given command into either an aggregate command or a command for a project
+   */
+  private def crossParser(state: State): Parser[CrossArgs] =
+    token(JavaCrossCommand <~ OptSpace) flatMap { _ =>
+      (token(Parser.opt("-v" <~ Space)) ~ token(matched(state.combinedParser))).map {
+        case (verbose, command) => CrossArgs(command, verbose.isDefined)
+      } & spacedFirst(JavaCrossCommand)
+    }
+
+  private def crossJavaHomeCommandImpl(state: State, args: CrossArgs): State = {
+    val x = Project.extract(state)
+    import x._
+    val (aggs, aggCommand) = Cross.parseSlashCommand(x)(args.command)
+    val projCrossVersions = aggs map { proj =>
+      proj -> getCrossJavaHomes(x, proj)
+    }
+    // if we support javaHome, projVersions should be cached somewhere since
+    // running ++2.11.1 is at the root level is going to mess with the scalaVersion for the aggregated subproj
+    val projVersions = (projCrossVersions flatMap {
+      case (proj, versions) => versions map { proj.project -> _ }
+    }).toList
+
+    val verbose = ""
+    // println(s"projVersions $projVersions")
+
+    if (projVersions.isEmpty) {
+      state
+    } else {
+      // Detect whether a task or command has been issued
+      val allCommands = Parser.parse(aggCommand, Act.aggregatedKeyParser(x)) match {
+        case Left(_) =>
+          // It's definitely not a task, check if it's a valid command, because we don't want to emit the warning
+          // message below for typos.
+          val validCommand = Parser.parse(aggCommand, state.combinedParser).isRight
+
+          val distinctCrossConfigs = projCrossVersions.map(_._2.toSet).distinct
+          if (validCommand && distinctCrossConfigs.size > 1) {
+            state.log.warn(
+              "Issuing a Java cross building command, but not all sub projects have the same cross build " +
+                "configuration. This could result in subprojects cross building against Java versions that they are " +
+                "not compatible with. Try issuing cross building command with tasks instead, since sbt will be able " +
+                "to ensure that cross building is only done using configured project and Java version combinations " +
+                "that are configured."
+            )
+            state.log.debug("Java versions configuration is:")
+            projCrossVersions.foreach {
+              case (project, versions) => state.log.debug(s"$project: $versions")
+            }
+          }
+
+          // Execute using a blanket switch
+          projCrossVersions.toMap.apply(currentRef).flatMap { version =>
+            // Force scala version
+            Seq(s"$JavaSwitchCommand $verbose $version!", aggCommand)
+          }
+
+        case Right(_) =>
+          // We have a key, we're likely to be able to cross build this using the per project behaviour.
+
+          // Group all the projects by scala version
+          projVersions.groupBy(_._2).mapValues(_.map(_._1)).toSeq.flatMap {
+            case (version, Seq(project)) =>
+              // If only one project for a version, issue it directly
+              Seq(s"$JavaSwitchCommand $verbose $version", s"$project/$aggCommand")
+            case (version, projects) if aggCommand.contains(" ") =>
+              // If the command contains a space, then the `all` command won't work because it doesn't support issuing
+              // commands with spaces, so revert to running the command on each project one at a time
+              s"$JavaSwitchCommand $verbose $version" :: projects
+                .map(project => s"$project/$aggCommand")
+            case (version, projects) =>
+              // First switch scala version, then use the all command to run the command on each project concurrently
+              Seq(
+                s"$JavaSwitchCommand $verbose $version",
+                projects.map(_ + "/" + aggCommand).mkString("all ", " ", "")
+              )
+          }
+      }
+
+      allCommands.toList ::: captureCurrentSession(state, x)
+    }
+  }
+
+  private val JavaCapturedSession = AttributeKey[Seq[Setting[_]]]("javaCrossCapturedSession")
+
+  private def captureCurrentSession(state: State, extracted: Extracted): State = {
+    state.put(JavaCapturedSession, extracted.session.rawAppend)
+  }
+
+  def discoverJavaHomes: ListMap[String, File] = {
+    ListMap(JavaDiscoverConfig.configs flatMap { _.javaHomes } sortWith (versionOrder): _*)
+  }
+
+  sealed trait JavaDiscoverConf {
+    def javaHomes: Vector[(String, File)]
+  }
+
+  def versionOrder(left: (_, File), right: (_, File)): Boolean =
+    versionOrder(left._2.getName, right._2.getName)
+
+  // Sort version strings, considering 1.8.0 < 1.8.0_45 < 1.8.0_212
+  @tailrec
+  def versionOrder(left: String, right: String): Boolean = {
+    val Pattern = """.*?([0-9]+)(.*)""".r
+    left match {
+      case Pattern(leftNumber, leftRest) =>
+        right match {
+          case Pattern(rightNumber, rightRest) =>
+            if (Integer.parseInt(leftNumber) < Integer.parseInt(rightNumber)) true
+            else if (Integer.parseInt(leftNumber) > Integer.parseInt(rightNumber)) false
+            else versionOrder(leftRest, rightRest)
+          case _ =>
+            false
+        }
+      case _ =>
+        true
+    }
+  }
+
+  object JavaDiscoverConfig {
+    object JavaHomeDir {
+      private val regex = """(\w+-)?(java-|(?:adoptopen)?jdk-?)(bin-)?(1\.)?([0-9]+).*""".r
+      def unapply(s: CharSequence): Option[String] = {
+        s match {
+          case regex(vendor, _, _, m, n) => Some(JavaVersion(nullBlank(m) + n).toString)
+          case _                         => None
+        }
+      }
+    }
+
+    class LinuxDiscoverConfig(base: File) extends JavaDiscoverConf {
+      def candidates() = wrapNull(base.list())
+
+      def javaHomes: Vector[(String, File)] =
+        candidates()
+          .collect {
+            case dir @ JavaHomeDir(version) =>
+              version -> (base / dir)
+          }
+    }
+
+    class MacOsDiscoverConfig extends JavaDiscoverConf {
+      val base: File = file("/Library") / "Java" / "JavaVirtualMachines"
+
+      def javaHomes: Vector[(String, File)] =
+        wrapNull(base.list())
+          .collect {
+            case dir @ JavaHomeDir(version) =>
+              version -> (base / dir / "Contents" / "Home")
+          }
+    }
+
+    class JabbaDiscoverConfig extends JavaDiscoverConf {
+      val base: File = Path.userHome / ".jabba" / "jdk"
+      val JabbaJavaHomeDir = """([\w\-]+)\@(1\.)?([0-9]+).*""".r
+
+      def javaHomes: Vector[(String, File)] =
+        wrapNull(base.list())
+          .collect {
+            case dir @ JabbaJavaHomeDir(vendor, m, n) =>
+              val v = JavaVersion(nullBlank(m) + n).withVendor(vendor).toString
+              if ((base / dir / "Contents" / "Home").exists) v -> (base / dir / "Contents" / "Home")
+              else v -> (base / dir)
+          }
+    }
+
+    class SdkmanDiscoverConfig extends JavaDiscoverConf {
+      val base: File = Path.userHome / ".sdkman" / "candidates" / "java"
+      def candidates(): Vector[String] = wrapNull(base.list())
+      def javaHomes: Vector[(String, File)] =
+        candidates.collect {
+          case dir if dir.contains("-") =>
+            CrossJava.parseSdkmanString(dir) match {
+              case Success(v) => Some(v.toString -> (base / dir))
+              case Failure(_) => None
+            }
+        }.flatten
+    }
+
+    class WindowsDiscoverConfig(base: File) extends JavaDiscoverConf {
+
+      def candidates() = wrapNull(base.list())
+
+      def javaHomes: Vector[(String, File)] =
+        candidates()
+          .collect {
+            case dir @ JavaHomeDir(version) =>
+              version -> (base / dir)
+          }
+    }
+
+    class JavaHomeDiscoverConfig extends JavaDiscoverConf {
+      def home() = sys.env.get("JAVA_HOME")
+
+      def javaHomes: Vector[(String, File)] =
+        home()
+          .map(new java.io.File(_))
+          .flatMap { javaHome =>
+            val base = javaHome.getParentFile
+            javaHome.getName match {
+              case dir @ JavaHomeDir(version) =>
+                Some(version -> (base / dir))
+              case _ => None
+            }
+          }
+          .toVector
+    }
+
+    val configs = Vector(
+      new JabbaDiscoverConfig,
+      new SdkmanDiscoverConfig,
+      new LinuxDiscoverConfig(file("/usr") / "java"),
+      new LinuxDiscoverConfig(file("/usr") / "lib" / "jvm"),
+      new MacOsDiscoverConfig,
+      new WindowsDiscoverConfig(file("C://Program Files/Java")),
+      new WindowsDiscoverConfig(file("C://Program Files (x86)/Java")),
+      new JavaHomeDiscoverConfig,
+    )
+  }
+
+  def nullBlank(s: String): String =
+    if (s eq null) ""
+    else s
+
+  def expandJavaHomes(hs: Map[String, File]): Map[String, File] = {
+    val parsed = hs map {
+      case (k, v) => JavaVersion(k) -> v
+    }
+    // first ignore vnd
+    val withAndWithoutVnd = parsed flatMap {
+      case (k, v) =>
+        if (k.vendor.isDefined) Vector(k -> v, k.withVendor(None) -> v)
+        else Vector(k -> v)
+    }
+    val normalizeNumbers = withAndWithoutVnd flatMap {
+      case (k, v) =>
+        k.numbers match {
+          case Vector(1L, minor, _*) =>
+            Vector(k -> v, k.withNumbers(Vector(minor)) -> v)
+          case Vector(major) if major > 1 =>
+            Vector(k -> v, k.withNumbers(Vector(1L, major)) -> v)
+          case Vector(major, minor, _*) if major > 1 =>
+            Vector(k -> v, k.withNumbers(Vector(major)) -> v, k.withNumbers(Vector(1L, major)) -> v)
+          case _ =>
+            Vector(k -> v)
+        }
+    }
+    val result: Map[String, File] = normalizeNumbers map {
+      case (k, v) => (k.toString -> v)
+    }
+    result
+  }
+
+  def wrapNull(a: Array[String]): Vector[String] =
+    if (a eq null) Vector()
+    else a.toVector
+}
diff --git a/main/src/main/scala/sbt/internal/CustomHttp.scala b/main/src/main/scala/sbt/internal/CustomHttp.scala
new file mode 100644
index 000000000..bc9a12ae2
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/CustomHttp.scala
@@ -0,0 +1,25 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import sbt.internal.librarymanagement.{ CustomHttp => LMCustomHttp }
+import okhttp3._
+
+import sbt.BuildSyntax._
+import sbt.KeyRanks._
+
+object CustomHttp {
+  val okhttpClientBuilder =
+    settingKey[OkHttpClient.Builder]("Builder for the HTTP client.").withRank(CSetting)
+  val okhttpClient =
+    settingKey[OkHttpClient]("HTTP client used for library management.").withRank(CSetting)
+
+  def defaultHttpClientBuilder: OkHttpClient.Builder = {
+    LMCustomHttp.defaultHttpClientBuilder
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/DefaultBackgroundJobService.scala b/main/src/main/scala/sbt/internal/DefaultBackgroundJobService.scala
new file mode 100644
index 000000000..b9effa8a9
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/DefaultBackgroundJobService.scala
@@ -0,0 +1,535 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.{ Closeable, File, FileInputStream, IOException }
+import java.nio.file.attribute.BasicFileAttributes
+import java.nio.file.{ FileVisitResult, Files, Path, SimpleFileVisitor }
+import java.security.{ DigestInputStream, MessageDigest }
+import java.util.concurrent.{ ConcurrentHashMap, TimeUnit }
+import java.util.concurrent.atomic.{ AtomicLong, AtomicReference }
+
+import sbt.Def.{ Classpath, ScopedKey, Setting }
+import sbt.Scope.GlobalScope
+import sbt.SlashSyntax0._
+import sbt.internal.inc.classpath.ClasspathFilter
+import sbt.internal.util.{ Attributed, ManagedLogger }
+import sbt.io.syntax._
+import sbt.io.{ Hash, IO }
+import sbt.util.Logger
+
+import scala.concurrent.ExecutionContext
+import scala.concurrent.duration._
+import scala.util.Try
+import sbt.util.LoggerContext
+import java.util.concurrent.TimeoutException
+
+/**
+ * Interface between sbt and a thing running in the background.
+ */
+private[sbt] abstract class BackgroundJob {
+  def humanReadableName: String
+  @deprecated("Use awaitTermination that takes a duration argument", "1.4.0")
+  final def awaitTermination(): Unit = awaitTermination(Duration.Inf)
+  def awaitTermination(duration: Duration): Unit
+
+  /** This waits till the job ends, and returns inner error via `Try`. */
+  @deprecated("Use awaitTerminationTry that takes a duration argument", "1.4.0")
+  final def awaitTerminationTry(): Try[Unit] = {
+    // This implementation is provided only for backward compatibility.
+    Try(awaitTermination(Duration.Inf))
+  }
+
+  /** This waits till the job ends, and returns inner error via `Try`. */
+  def awaitTerminationTry(duration: Duration): Try[Unit] = {
+    // This implementation is provided only for backward compatibility.
+    Try(awaitTermination(duration))
+  }
+
+  def shutdown(): Unit
+
+  // this should be true on construction and stay true until
+  // the job is complete
+  def isRunning(): Boolean
+
+  // called after stop or on spontaneous exit, closing the result
+  // removes the listener
+  def onStop(listener: () => Unit)(implicit ex: ExecutionContext): Closeable
+
+  // do we need this or is the spawning task good enough?
+  // def tags: SomeType
+}
+
+private[sbt] abstract class AbstractJobHandle extends JobHandle {
+  override def toString =
+    s"JobHandle(${id}, ${humanReadableName}, ${Def.showFullKey.show(spawningTask)})"
+}
+
+private[sbt] abstract class AbstractBackgroundJobService extends BackgroundJobService {
+  private val nextId = new AtomicLong(1)
+  private val pool = new BackgroundThreadPool()
+
+  private[sbt] def serviceTempDirBase: File
+  private[sbt] def useLog4J: Boolean
+  private val serviceTempDirRef = new AtomicReference[File]
+  private def serviceTempDir: File = serviceTempDirRef.synchronized {
+    serviceTempDirRef.get match {
+      case null =>
+        val dir = IO.createUniqueDirectory(serviceTempDirBase)
+        serviceTempDirRef.set(dir)
+        dir
+      case s => s
+    }
+  }
+  // hooks for sending start/stop events
+  protected def onAddJob(@deprecated("unused", "") job: JobHandle): Unit = ()
+  protected def onRemoveJob(@deprecated("unused", "") job: JobHandle): Unit = ()
+  private val context = LoggerContext(useLog4J)
+
+  // this mutable state could conceptually go on State except
+  // that then every task that runs a background job would have
+  // to be a command, so not sure what to do here.
+  @volatile
+  private final var jobSet = Set.empty[ThreadJobHandle]
+  private def addJob(job: ThreadJobHandle): Unit = synchronized {
+    onAddJob(job)
+    jobSet += job
+  }
+
+  private def removeJob(job: ThreadJobHandle): Unit = synchronized {
+    onRemoveJob(job)
+    jobSet -= job
+  }
+  override def jobs: Vector[ThreadJobHandle] = jobSet.toVector
+
+  final class ThreadJobHandle(
+      override val id: Long,
+      override val spawningTask: ScopedKey[_],
+      val logger: ManagedLogger,
+      val workingDirectory: File,
+      val job: BackgroundJob
+  ) extends AbstractJobHandle {
+    // EC for onStop handler below
+    implicit val executionContext: ExecutionContext =
+      ExecutionContext.fromExecutor(pool.executor)
+
+    def humanReadableName: String = job.humanReadableName
+
+    job.onStop { () =>
+      // TODO: Fix this
+      // logger.close()
+      removeJob(this)
+      IO.delete(workingDirectory)
+      context.clearAppenders(logger.name)
+      context.close()
+    }
+    addJob(this)
+    override final def equals(other: Any): Boolean = other match {
+      case handle: JobHandle if handle.id == id => true
+      case _                                    => false
+    }
+    override final def hashCode(): Int = id.hashCode
+  }
+
+  private val unknownTask = TaskKey[Unit]("unknownTask", "Dummy value")
+  // we use this if we deserialize a handle for a job that no longer exists
+  private final class DeadHandle(override val id: Long, override val humanReadableName: String)
+      extends AbstractJobHandle {
+    override val spawningTask: ScopedKey[_] = unknownTask
+  }
+
+  protected def makeContext(id: Long, spawningTask: ScopedKey[_], state: State): ManagedLogger
+
+  def doRunInBackground(
+      spawningTask: ScopedKey[_],
+      state: State,
+      start: (Logger, File) => BackgroundJob
+  ): JobHandle = {
+    val id = nextId.getAndIncrement()
+    val logger = makeContext(id, spawningTask, state)
+    val workingDir = serviceTempDir / s"job-$id"
+    IO.createDirectory(workingDir)
+    val job = try {
+      new ThreadJobHandle(id, spawningTask, logger, workingDir, start(logger, workingDir))
+    } catch {
+      case e: Throwable =>
+        // TODO: Fix this
+        // logger.close()
+        throw e
+    }
+    job
+  }
+
+  override def runInBackground(spawningTask: ScopedKey[_], state: State)(
+      start: (Logger, File) => Unit
+  ): JobHandle = {
+    pool.run(this, spawningTask, state)(start)
+  }
+
+  override private[sbt] def runInBackgroundWithLoader(spawningTask: ScopedKey[_], state: State)(
+      start: (Logger, File) => (Option[ClassLoader], () => Unit)
+  ): JobHandle = {
+    pool.runWithLoader(this, spawningTask, state)(start)
+  }
+
+  override final def close(): Unit = shutdown()
+  override def shutdown(): Unit = {
+    val deadline = 10.seconds.fromNow
+    while (jobSet.nonEmpty && !deadline.isOverdue) {
+      jobSet.headOption.foreach {
+        case handle: ThreadJobHandle @unchecked =>
+          if (handle.job.isRunning) {
+            handle.job.shutdown()
+            handle.job.awaitTerminationTry(10.seconds)
+          }
+          jobSet = jobSet - handle
+        case _ => //
+      }
+    }
+    pool.close()
+    Option(serviceTempDirRef.get).foreach(IO.delete)
+  }
+
+  private def withHandle(job: JobHandle)(f: ThreadJobHandle => Unit): Unit = job match {
+    case handle: ThreadJobHandle @unchecked => f(handle)
+    case _: DeadHandle @unchecked           => () // nothing to stop or wait for
+    case other =>
+      sys.error(
+        s"BackgroundJobHandle does not originate with the current BackgroundJobService: $other"
+      )
+  }
+
+  override def stop(job: JobHandle): Unit =
+    withHandle(job)(_.job.shutdown())
+
+  override def waitFor(job: JobHandle): Unit =
+    withHandle(job)(_.job.awaitTermination(Duration.Inf))
+
+  override def toString(): String = s"BackgroundJobService(jobs=${jobs.map(_.id).mkString})"
+
+  /**
+   *
+   * Copies products to the working directory, and the rest to the serviceTempDir of this service,
+   * both wrapped in a stamp of the file contents.
+   * This is intended to minimize the file copying and accumulation of the unused JAR file.
+   * Since working directory is wiped out when the background job ends, the product JAR is deleted too.
+   * Meanwhile, the rest of the dependencies are cached for the duration of this service.
+   *
+   * @param products the portion of the classpath that is generated by the task
+   * @param full the entire classpath of the task
+   * @param workingDirectory the directory into which jars and class files are copied
+   * @param hashFileContents toggles whether or not the contents of each files should be hashed
+   *                         to determine whether it has changed. When false, the last modified
+   *                         time is used instead.
+   *
+   * @return a classpath pointing to jar and class files in the working directory
+   */
+  override private[sbt] def copyClasspath(
+      products: Classpath,
+      full: Classpath,
+      workingDirectory: File,
+      hashFileContents: Boolean
+  ): Classpath = {
+    def syncTo(dir: File)(source0: Attributed[File]): Attributed[File] = {
+      val source = source0.data
+      val hash8 = Hash.toHex(Hash(source.toString)).take(8)
+      val id: File => String = if (hashFileContents) hash else lastModified
+      val dest = dir / hash8 / id(source) / source.getName
+      if (!dest.exists) {
+        if (source.isDirectory) IO.copyDirectory(source, dest)
+        else IO.copyFile(source, dest)
+      }
+      Attributed.blank(dest)
+    }
+    val xs = (products.toVector map { syncTo(workingDirectory / "target") }) ++
+      ((full diff products) map { syncTo(serviceTempDir / "target") })
+    xs
+  }
+
+  /** An alternative to sbt.io.Hash that handles java.io.File being a directory. */
+  private def hash(f: File): String = {
+    val digest = MessageDigest.getInstance("SHA")
+    val buffer = new Array[Byte](8192)
+    Files.walkFileTree(
+      f.toPath,
+      new SimpleFileVisitor[Path]() {
+        override def visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult = {
+          val dis = new DigestInputStream(new FileInputStream(file.toFile), digest)
+          try {
+            while (dis.read(buffer) >= 0) ()
+            FileVisitResult.CONTINUE
+          } catch {
+            case _: IOException => FileVisitResult.TERMINATE
+          } finally dis.close()
+        }
+      }
+    )
+    Hash.toHex(Hash(digest.digest)).take(8)
+  }
+
+  /**
+   * Computes the last modified time of a file or the maximum last file of the contents of a
+   * directory.
+   *
+   * @param f the file or directory for which we calculate the last modified time
+   * @return the last modified time of the file or the maximum last modified time of the contents
+   *         of the directory.
+   */
+  private def lastModified(f: File): String = {
+    var lastModified = 0L
+    Files.walkFileTree(
+      f.toPath,
+      new SimpleFileVisitor[Path]() {
+        override def visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult = {
+          val lm = attrs.lastModifiedTime.toMillis
+          if (lm > lastModified) lastModified = lm
+          FileVisitResult.CONTINUE
+        }
+      }
+    )
+    lastModified.toString
+  }
+
+  /** Copies classpath to temporary directories. */
+  override def copyClasspath(
+      products: Classpath,
+      full: Classpath,
+      workingDirectory: File
+  ): Classpath =
+    copyClasspath(products, full, workingDirectory, hashFileContents = true)
+}
+
+private[sbt] object BackgroundThreadPool {
+  sealed trait Status
+  case object Waiting extends Status
+  final case class Running(thread: Thread) extends Status
+  // the oldThread is None if we never ran
+  final case class Stopped(oldThread: Option[Thread]) extends Status
+}
+
+private[sbt] class BackgroundThreadPool extends java.io.Closeable {
+
+  private val nextThreadId = new java.util.concurrent.atomic.AtomicInteger(1)
+  private val threadGroup = Thread.currentThread.getThreadGroup()
+
+  private val threadFactory = new java.util.concurrent.ThreadFactory() {
+    override def newThread(runnable: Runnable): Thread = {
+      val thread =
+        new Thread(threadGroup, runnable, s"sbt-bg-threads-${nextThreadId.getAndIncrement}")
+      // Do NOT setDaemon because then the code in TaskExit.scala in sbt will insta-kill
+      // the backgrounded process, at least for the case of the run task.
+      thread
+    }
+  }
+
+  private[internal] val executor = new java.util.concurrent.ThreadPoolExecutor(
+    0, /* corePoolSize */
+    32, /* maxPoolSize, max # of bg tasks */
+    2,
+    java.util.concurrent.TimeUnit.SECONDS,
+    /* keep alive unused threads this long (if corePoolSize < maxPoolSize) */
+    new java.util.concurrent.SynchronousQueue[Runnable](),
+    threadFactory
+  )
+
+  private class BackgroundRunnable(val taskName: String, body: () => Unit)
+      extends BackgroundJob
+      with Runnable {
+    import BackgroundThreadPool._
+    private val finishedLatch = new java.util.concurrent.CountDownLatch(1)
+    // synchronize to read/write this, no sync to just read
+    @volatile
+    private var status: Status = Waiting
+
+    // This is used to capture exceptions that are caught in this background job.
+    private var exitTry: Option[Try[Unit]] = None
+
+    // double-finally for extra paranoia that we will finishedLatch.countDown
+    override def run() =
+      try {
+        val go = synchronized {
+          status match {
+            case Waiting =>
+              status = Running(Thread.currentThread())
+              true
+            case Stopped(_) =>
+              false
+            case Running(_) =>
+              throw new RuntimeException("Impossible status of bg thread")
+          }
+        }
+        try {
+          if (go) {
+            exitTry = Option(Try(body()))
+          }
+        } finally cleanup()
+      } finally finishedLatch.countDown()
+
+    private class StopListener(val callback: () => Unit, val executionContext: ExecutionContext)
+        extends Closeable {
+      override def close(): Unit = removeListener(this)
+      override def hashCode: Int = System.identityHashCode(this)
+      override def equals(other: Any): Boolean = other match {
+        case r: AnyRef => this eq r
+        case _         => false
+      }
+    }
+
+    // access is synchronized
+    private var stopListeners = Set.empty[StopListener]
+
+    private def removeListener(listener: StopListener): Unit = synchronized {
+      stopListeners -= listener
+    }
+
+    def cleanup(): Unit = {
+      // avoid holding any lock while invoking callbacks, and
+      // handle callbacks being added by other callbacks, just
+      // to be all fancy.
+      while (synchronized { stopListeners.nonEmpty }) {
+        val listeners = synchronized {
+          val list = stopListeners.toList
+          stopListeners = Set.empty
+          list
+        }
+        listeners.foreach { l =>
+          l.executionContext.execute(() => l.callback())
+        }
+      }
+    }
+
+    override def onStop(listener: () => Unit)(implicit ex: ExecutionContext): Closeable =
+      synchronized {
+        val result = new StopListener(listener, ex)
+        stopListeners += result
+        result
+      }
+    override def awaitTermination(duration: Duration): Unit = {
+      val finished = duration match {
+        case fd: FiniteDuration => finishedLatch.await(fd.toMillis, TimeUnit.MILLISECONDS)
+        case _                  => finishedLatch.await(); true
+      }
+      exitTry.foreach(_.fold(e => throw e, identity))
+      if (!finished) throw new TimeoutException
+    }
+
+    override def humanReadableName: String = taskName
+    override def isRunning(): Boolean =
+      status match {
+        case Waiting               => true // we start as running from BackgroundJob perspective
+        case Running(thread)       => thread.isAlive()
+        case Stopped(threadOption) => threadOption.map(_.isAlive()).getOrElse(false)
+      }
+    override def shutdown(): Unit =
+      synchronized {
+        status match {
+          case Waiting =>
+            status = Stopped(None) // makes run() not run the body
+          case Running(thread) =>
+            status = Stopped(Some(thread))
+            thread.interrupt()
+          case Stopped(threadOption) =>
+            // sleep to avoid consuming a lot of CPU
+            try {
+              Thread.sleep(10)
+            } catch {
+              case e: InterruptedException =>
+                Thread.currentThread().interrupt();
+            }
+            // try to interrupt again! woot!
+            threadOption.foreach(_.interrupt())
+        }
+      }
+  }
+  private class BackgroundRunnableWithLoader(
+      val loader: Option[ClassLoader],
+      taskName: String,
+      body: () => Unit
+  ) extends BackgroundRunnable(taskName, body) {
+    override def awaitTermination(duration: Duration): Unit = {
+      try super.awaitTermination(duration)
+      finally loader.foreach {
+        case ac: AutoCloseable   => ac.close()
+        case cp: ClasspathFilter => cp.close()
+        case _                   =>
+      }
+    }
+  }
+
+  def run(manager: AbstractBackgroundJobService, spawningTask: ScopedKey[_], state: State)(
+      work: (Logger, File) => Unit
+  ): JobHandle = {
+    def start(logger: Logger, workingDir: File): BackgroundJob = {
+      val runnable = new BackgroundRunnable(spawningTask.key.label, { () =>
+        work(logger, workingDir)
+      })
+      executor.execute(runnable)
+      runnable
+    }
+    manager.doRunInBackground(spawningTask, state, start _)
+  }
+
+  private[sbt] def runWithLoader(
+      manager: AbstractBackgroundJobService,
+      spawningTask: ScopedKey[_],
+      state: State
+  )(
+      getWork: (Logger, File) => (Option[ClassLoader], () => Unit)
+  ): JobHandle = {
+    def start(logger: Logger, workingDir: File): BackgroundJob = {
+      val (loader, work) = getWork(logger, workingDir)
+      val runnable = new BackgroundRunnableWithLoader(loader, spawningTask.key.label, work)
+      executor.execute(runnable)
+      runnable
+    }
+    manager.doRunInBackground(spawningTask, state, start _)
+  }
+
+  override def close(): Unit = {
+    executor.shutdown()
+  }
+}
+
+private[sbt] class DefaultBackgroundJobService(
+    private[sbt] val serviceTempDirBase: File,
+    override private[sbt] val useLog4J: Boolean
+) extends AbstractBackgroundJobService {
+  @deprecated("Use the constructor that specifies the background job temporary directory", "1.4.0")
+  def this() = this(IO.createTemporaryDirectory, false)
+  override def makeContext(id: Long, spawningTask: ScopedKey[_], state: State): ManagedLogger = {
+    val extracted = Project.extract(state)
+    LogManager.constructBackgroundLog(extracted.structure.data, state)(spawningTask)
+  }
+}
+private[sbt] object DefaultBackgroundJobService {
+
+  private[this] val backgroundJobServices = new ConcurrentHashMap[File, DefaultBackgroundJobService]
+  private[sbt] def shutdown(): Unit = {
+    backgroundJobServices.values.forEach(_.shutdown())
+    backgroundJobServices.clear()
+  }
+  private[sbt] lazy val backgroundJobServiceSetting: Setting[_] =
+    (GlobalScope / Keys.bgJobService) := {
+      val path = (GlobalScope / sbt.Keys.bgJobServiceDirectory).value
+      val useLog4J = (GlobalScope / Keys.useLog4J).value
+      val newService = new DefaultBackgroundJobService(path, useLog4J)
+      backgroundJobServices.putIfAbsent(path, newService) match {
+        case null => newService
+        case s =>
+          newService.shutdown()
+          s
+      }
+    }
+  private[sbt] lazy val backgroundJobServiceSettings: Seq[Def.Setting[_]] = Def.settings(
+    (GlobalScope / Keys.bgJobServiceDirectory) := {
+      sbt.Keys.appConfiguration.value.baseDirectory / "target" / "bg-jobs"
+    },
+    backgroundJobServiceSetting
+  )
+}
diff --git a/main/src/main/scala/sbt/internal/DeprecatedContinuous.scala b/main/src/main/scala/sbt/internal/DeprecatedContinuous.scala
new file mode 100644
index 000000000..7d344aab9
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/DeprecatedContinuous.scala
@@ -0,0 +1,70 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.nio.file.Path
+import java.util.concurrent.atomic.AtomicReference
+
+import sbt.{ ProjectRef, State, Watched }
+import sbt.internal.io.{ EventMonitor, Source, WatchState => WS }
+import sbt.internal.util.AttributeKey
+import sbt.nio.file.Glob
+
+import scala.annotation.nowarn
+
+@nowarn
+private[internal] trait DeprecatedContinuous {
+  protected type StartMessage =
+    Option[Either[WS => String, (Int, ProjectRef, Seq[String]) => Option[String]]]
+  protected type TriggerMessage = Either[WS => String, (Int, Path, Seq[String]) => Option[String]]
+  protected type DeprecatedWatchState = WS
+  protected val deprecatedWatchingMessage = sbt.Keys.watchingMessage
+  protected val deprecatedTriggeredMessage = sbt.Keys.triggeredMessage
+  protected def watchState(globs: Seq[Glob], count: Int): WS = {
+    WS.empty(globs).withCount(count)
+  }
+  private[this] val legacyWatchState =
+    AttributeKey[AtomicReference[WS]]("legacy-watch-state", Int.MaxValue)
+  private[sbt] def addLegacyWatchSetting(state: State): State = {
+    val legacyState = new AtomicReference[WS](WS.empty(Nil).withCount(1))
+    state
+      .put(
+        Watched.ContinuousEventMonitor,
+        new EventMonitor {
+
+          /** Block indefinitely until the monitor receives a file event or the user stops the watch. */
+          override def awaitEvent(): Boolean = false
+
+          /** A snapshot of the WatchState that includes the number of build triggers and watch sources. */
+          override def state(): WS = legacyState.get()
+          override def close(): Unit = ()
+        }
+      )
+      .put(legacyWatchState, legacyState)
+      .put(Watched.Configuration, new Watched {
+        override def watchSources(s: State): Seq[Source] =
+          s.get(legacyWatchState).map(_.get.sources).getOrElse(Nil)
+      })
+  }
+  def updateLegacyWatchState(state: State, globs: Seq[Glob], count: Int): Unit = {
+    state.get(legacyWatchState).foreach { ref =>
+      val ws = WS.empty(globs).withCount(count)
+      ref.set(ws)
+    }
+  }
+}
+
+@nowarn
+private[sbt] object DeprecatedContinuous {
+  private[sbt] val taskDefinitions: Seq[Def.Setting[_]] = Seq(
+    sbt.Keys.watchTransitiveSources := sbt.Defaults.watchTransitiveSourcesTask.value,
+    sbt.Keys.watch := sbt.Defaults.watchSetting.value,
+    sbt.nio.Keys.watchTasks := Continuous.continuousTask.evaluated,
+  )
+}
diff --git a/main/src/main/scala/sbt/internal/DslAst.scala b/main/src/main/scala/sbt/internal/DslEntry.scala
similarity index 74%
rename from main/src/main/scala/sbt/internal/DslAst.scala
rename to main/src/main/scala/sbt/internal/DslEntry.scala
index 338c86f8c..9da26a9b2 100644
--- a/main/src/main/scala/sbt/internal/DslAst.scala
+++ b/main/src/main/scala/sbt/internal/DslEntry.scala
@@ -1,14 +1,22 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
-import sbt.internal.util.{ Eval, RangePosition }
+import sbt.internal.util.RangePosition
 
 import sbt.librarymanagement.Configuration
 
 import Def._
 
-/** This reprsents a `Setting` expression configured by the sbt DSL. */
+/** This represents a `Setting` expression configured by the sbt DSL. */
 sealed trait DslEntry {
+
   /** Called by the parser.  Sets the position where this entry was defined in the build.sbt file. */
   def withPos(pos: RangePosition): DslEntry
 }
@@ -47,22 +55,32 @@ object DslEntry {
   /** this represents an actually Setting[_] or Seq[Setting[_]] configured by the sbt DSL. */
   case class DslSetting(settings: SettingsDefinition) extends ProjectSettings {
     def toSettings = settings.settings
-    final def withPos(pos: RangePosition): DslEntry = DslSetting(settings.settings.map(_.withPos(pos)))
+    final def withPos(pos: RangePosition): DslEntry =
+      DslSetting(settings.settings.map(_.withPos(pos)))
   }
+
   /** this represents an `enablePlugins()` in the sbt DSL */
   case class DslEnablePlugins(plugins: Seq[AutoPlugin]) extends ProjectManipulation {
     override val toFunction: Project => Project = _.enablePlugins(plugins: _*)
   }
+
   /** this represents an `disablePlugins()` in the sbt DSL */
   case class DslDisablePlugins(plugins: Seq[AutoPlugin]) extends ProjectManipulation {
     override val toFunction: Project => Project = _.disablePlugins(plugins: _*)
   }
+
+  /** Represents registering an internal dependency for the current project */
+  case class DslDependsOn(cs: Seq[ClasspathDep[ProjectReference]]) extends ProjectManipulation {
+    override val toFunction: Project => Project = _.dependsOn(cs: _*)
+  }
+
   /** Represents registering a set of configurations with the current project. */
   case class DslConfigs(cs: Seq[Configuration]) extends ProjectManipulation {
     override val toFunction: Project => Project = _.configs(cs: _*)
   }
-  /** this represents an `aggregate()` in the sbt DSL */
-  case class DslAggregate(refs: Seq[Eval[ProjectReference]]) extends ProjectManipulation {
+
+  /** this represents an `aggregateProjects()` in the sbt DSL */
+  case class DslAggregate(refs: Seq[ProjectReference]) extends ProjectManipulation {
     override val toFunction: Project => Project = _.aggregate(refs: _*)
   }
 }
diff --git a/main/src/main/scala/sbt/internal/DynamicInput.scala b/main/src/main/scala/sbt/internal/DynamicInput.scala
new file mode 100644
index 000000000..36260e6c0
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/DynamicInput.scala
@@ -0,0 +1,45 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.nio.file.{ WatchService => _ }
+
+import sbt.nio.FileStamper
+import sbt.nio.file.Glob
+
+private[sbt] final case class DynamicInput(
+    glob: Glob,
+    fileStamper: FileStamper,
+    forceTrigger: Boolean
+)
+private[sbt] object DynamicInput {
+  implicit object ordering extends Ordering[DynamicInput] {
+    private implicit val globOrdering: Ordering[Glob] = Glob.ordering
+    private implicit object fileStamperOrdering extends Ordering[FileStamper] {
+      override def compare(left: FileStamper, right: FileStamper): Int = left match {
+        case FileStamper.Hash =>
+          right match {
+            case FileStamper.Hash => 0
+            case _                => -1
+          }
+        case FileStamper.LastModified =>
+          right match {
+            case FileStamper.LastModified => 0
+            case _                        => 1
+          }
+      }
+    }
+    override def compare(left: DynamicInput, right: DynamicInput): Int = {
+      globOrdering.compare(left.glob, right.glob) match {
+        case 0 => fileStamperOrdering.compare(left.fileStamper, right.fileStamper)
+        case i => i
+      }
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala b/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala
index 1adb76d2e..9986629e5 100644
--- a/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala
+++ b/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala
@@ -1,19 +1,32 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
-import sbt.internal.util.{ complete, AttributeEntry, AttributeKey, LineRange, MessageOnlyException, RangePosition, Settings }
+import sbt.internal.util.{
+  AttributeEntry,
+  AttributeKey,
+  LineRange,
+  MessageOnlyException,
+  RangePosition,
+  Settings
+}
 
 import java.io.File
 import compiler.{ Eval, EvalImports }
-import complete.DefaultParsers.validID
+import sbt.internal.util.complete.DefaultParsers.validID
 import Def.{ ScopedKey, Setting }
 import Scope.GlobalScope
+import sbt.SlashSyntax0._
 import sbt.internal.parser.SbtParser
 
 import sbt.io.IO
+import scala.collection.JavaConverters._
 
 /**
  *  This file is responsible for compiling the .sbt files used to configure sbt builds.
@@ -23,8 +36,6 @@ import sbt.io.IO
  *  1. Parsing high-level constructs (definitions, settings, imports)
  *  2. Compiling scala code into local .class files
  *  3. Evaluating the expressions and obtaining in-memory objects of the results (Setting[_] instances, or val references).
- *
- *
  */
 private[sbt] object EvaluateConfigurations {
 
@@ -35,7 +46,11 @@ private[sbt] object EvaluateConfigurations {
   /**
    * This represents the parsed expressions in a build sbt, as well as where they were defined.
    */
-  private[this] final class ParsedFile(val imports: Seq[(String, Int)], val definitions: Seq[(String, LineRange)], val settings: Seq[(String, LineRange)])
+  private[this] final class ParsedFile(
+      val imports: Seq[(String, Int)],
+      val definitions: Seq[(String, LineRange)],
+      val settings: Seq[(String, LineRange)]
+  )
 
   /** The keywords we look for when classifying a string as a definition. */
   private[this] val DefinitionKeywords = Seq("lazy val ", "def ", "val ")
@@ -46,19 +61,26 @@ private[sbt] object EvaluateConfigurations {
    *  return a parsed, compiled + evaluated [[LoadedSbtFile]].   The result has
    *  raw sbt-types that can be accessed and used.
    */
-  @deprecated("We no longer merge build.sbt files together unless they are in the same directory.", "0.13.6")
-  def apply(eval: Eval, srcs: Seq[File], imports: Seq[String]): LazyClassLoaded[LoadedSbtFile] =
-    {
-      val loadFiles = srcs.sortBy(_.getName) map { src => evaluateSbtFile(eval, src, IO.readLines(src), imports, 0) }
-      loader => (LoadedSbtFile.empty /: loadFiles) { (loaded, load) => loaded merge load(loader) }
+  def apply(eval: Eval, srcs: Seq[File], imports: Seq[String]): LazyClassLoaded[LoadedSbtFile] = {
+    val loadFiles = srcs.sortBy(_.getName) map { src =>
+      evaluateSbtFile(eval, src, IO.readLines(src), imports, 0)
     }
+    loader =>
+      loadFiles.foldLeft(LoadedSbtFile.empty) { (loaded, load) =>
+        loaded merge load(loader)
+      }
+  }
 
   /**
    * Reads a given .sbt file and evaluates it into a sequence of setting values.
    *
    * Note: This ignores any non-Setting[_] values in the file.
    */
-  def evaluateConfiguration(eval: Eval, src: File, imports: Seq[String]): LazyClassLoaded[Seq[Setting[_]]] =
+  def evaluateConfiguration(
+      eval: Eval,
+      src: File,
+      imports: Seq[String]
+  ): LazyClassLoaded[Seq[Setting[_]]] =
     evaluateConfiguration(eval, src, IO.readLines(src), imports, 0)
 
   /**
@@ -67,13 +89,19 @@ private[sbt] object EvaluateConfigurations {
    *
    * @param builtinImports  The set of import statements to add to those parsed in the .sbt file.
    */
-  private[this] def parseConfiguration(file: File, lines: Seq[String], builtinImports: Seq[String], offset: Int): ParsedFile =
-    {
-      val (importStatements, settingsAndDefinitions) = splitExpressions(file, lines)
-      val allImports = builtinImports.map(s => (s, -1)) ++ addOffset(offset, importStatements)
-      val (definitions, settings) = splitSettingsDefinitions(addOffsetToRange(offset, settingsAndDefinitions))
-      new ParsedFile(allImports, definitions, settings)
-    }
+  private[this] def parseConfiguration(
+      file: File,
+      lines: Seq[String],
+      builtinImports: Seq[String],
+      offset: Int
+  ): ParsedFile = {
+    val (importStatements, settingsAndDefinitions) = splitExpressions(file, lines)
+    val allImports = builtinImports.map(s => (s, -1)) ++ addOffset(offset, importStatements)
+    val (definitions, settings) = splitSettingsDefinitions(
+      addOffsetToRange(offset, settingsAndDefinitions)
+    )
+    new ParsedFile(allImports, definitions, settings)
+  }
 
   /**
    * Evaluates a  parsed sbt configuration file.
@@ -81,15 +109,20 @@ private[sbt] object EvaluateConfigurations {
    * @param eval    The evaluating scala compiler instance we use to handle evaluating scala configuration.
    * @param file    The file we've parsed
    * @param imports The default imports to use in this .sbt configuration
-   * @param lines   The lines of the configurtion we'd like to evaluate.
+   * @param lines   The lines of the configuration we'd like to evaluate.
    *
    * @return Just the Setting[_] instances defined in the .sbt file.
    */
-  def evaluateConfiguration(eval: Eval, file: File, lines: Seq[String], imports: Seq[String], offset: Int): LazyClassLoaded[Seq[Setting[_]]] =
-    {
-      val l = evaluateSbtFile(eval, file, lines, imports, offset)
-      loader => l(loader).settings
-    }
+  def evaluateConfiguration(
+      eval: Eval,
+      file: File,
+      lines: Seq[String],
+      imports: Seq[String],
+      offset: Int
+  ): LazyClassLoaded[Seq[Setting[_]]] = {
+    val l = evaluateSbtFile(eval, file, lines, imports, offset)
+    loader => l(loader).settings
+  }
 
   /**
    * Evaluates a parsed sbt configuration file.
@@ -101,54 +134,70 @@ private[sbt] object EvaluateConfigurations {
    * @return A function which can take an sbt classloader and return the raw types/configuration
    *         which was compiled/parsed for the given file.
    */
-  private[sbt] def evaluateSbtFile(eval: Eval, file: File, lines: Seq[String], imports: Seq[String], offset: Int): LazyClassLoaded[LoadedSbtFile] =
-    {
-      // TODO - Store the file on the LoadedSbtFile (or the parent dir) so we can accurately do
-      //        detection for which project project manipulations should be applied.
-      val name = file.getPath
-      val parsed = parseConfiguration(file, lines, imports, offset)
-      val (importDefs, definitions) =
-        if (parsed.definitions.isEmpty) (Nil, DefinedSbtValues.empty) else {
-          val definitions = evaluateDefinitions(eval, name, parsed.imports, parsed.definitions, Some(file))
-          val imp = BuildUtil.importAllRoot(definitions.enclosingModule :: Nil)
-          (imp, DefinedSbtValues(definitions))
-        }
-      val allImports = importDefs.map(s => (s, -1)) ++ parsed.imports
-      val dslEntries = parsed.settings map {
-        case (dslExpression, range) =>
-          evaluateDslEntry(eval, name, allImports, dslExpression, range)
-      }
-      eval.unlinkDeferred()
-      // Tracks all the files we generated from evaluating the sbt file.
-      val allGeneratedFiles = (definitions.generated ++ dslEntries.flatMap(_.generated))
-      loader => {
-        val projects =
-          definitions.values(loader).collect {
-            case p: Project => resolveBase(file.getParentFile, p)
-          }
-        val (settingsRaw, manipulationsRaw) =
-          dslEntries map (_.result apply loader) partition {
-            case DslEntry.ProjectSettings(_) => true
-            case _                           => false
-          }
-        val settings = settingsRaw flatMap {
-          case DslEntry.ProjectSettings(settings) => settings
-          case _                                  => Nil
-        }
-        val manipulations = manipulationsRaw map {
-          case DslEntry.ProjectManipulation(f) => f
-        }
-        // TODO -get project manipulations.
-        new LoadedSbtFile(settings, projects, importDefs, manipulations, definitions, allGeneratedFiles)
+  private[sbt] def evaluateSbtFile(
+      eval: Eval,
+      file: File,
+      lines: Seq[String],
+      imports: Seq[String],
+      offset: Int
+  ): LazyClassLoaded[LoadedSbtFile] = {
+    // TODO - Store the file on the LoadedSbtFile (or the parent dir) so we can accurately do
+    //        detection for which project project manipulations should be applied.
+    val name = file.getPath
+    val parsed = parseConfiguration(file, lines, imports, offset)
+    val (importDefs, definitions) =
+      if (parsed.definitions.isEmpty) (Nil, DefinedSbtValues.empty)
+      else {
+        val definitions =
+          evaluateDefinitions(eval, name, parsed.imports, parsed.definitions, Some(file))
+        val imp = BuildUtil.importAllRoot(definitions.enclosingModule :: Nil)
+        (imp, DefinedSbtValues(definitions))
       }
+    val allImports = importDefs.map(s => (s, -1)) ++ parsed.imports
+    val dslEntries = parsed.settings map {
+      case (dslExpression, range) =>
+        evaluateDslEntry(eval, name, allImports, dslExpression, range)
     }
+    eval.unlinkDeferred()
+    // Tracks all the files we generated from evaluating the sbt file.
+    val allGeneratedFiles = (definitions.generated ++ dslEntries.flatMap(_.generated))
+    loader => {
+      val projects = {
+        val compositeProjects = definitions.values(loader).collect {
+          case p: CompositeProject => p
+        }
+        CompositeProject.expand(compositeProjects).map(resolveBase(file.getParentFile, _))
+      }
+      val (settingsRaw, manipulationsRaw) =
+        dslEntries map (_.result apply loader) partition {
+          case DslEntry.ProjectSettings(_) => true
+          case _                           => false
+        }
+      val settings = settingsRaw flatMap {
+        case DslEntry.ProjectSettings(settings) => settings
+        case _                                  => Nil
+      }
+      val manipulations = manipulationsRaw map {
+        case DslEntry.ProjectManipulation(f) => f
+      }
+      // TODO -get project manipulations.
+      new LoadedSbtFile(
+        settings,
+        projects,
+        importDefs,
+        manipulations,
+        definitions,
+        allGeneratedFiles
+      )
+    }
+  }
+
   /** move a project to be relative to this file after we've evaluated it. */
   private[this] def resolveBase(f: File, p: Project) = p.copy(base = IO.resolve(f, p.base))
-  @deprecated("Will no longer be public.", "0.13.6")
-  def flatten(mksettings: Seq[ClassLoader => Seq[Setting[_]]]): ClassLoader => Seq[Setting[_]] =
-    loader => mksettings.flatMap(_ apply loader)
+
   def addOffset(offset: Int, lines: Seq[(String, Int)]): Seq[(String, Int)] =
     lines.map { case (s, i) => (s, i + offset) }
+
   def addOffsetToRange(offset: Int, ranges: Seq[(String, LineRange)]): Seq[(String, LineRange)] =
     ranges.map { case (s, r) => (s, r shift offset) }
 
@@ -172,20 +221,34 @@ private[sbt] object EvaluateConfigurations {
    * @return A method that given an sbt classloader, can return the actual [[sbt.internal.DslEntry]] defined by
    *         the expression, and the sequence of .class files generated.
    */
-  private[sbt] def evaluateDslEntry(eval: Eval, name: String, imports: Seq[(String, Int)], expression: String, range: LineRange): TrackedEvalResult[DslEntry] = {
+  private[sbt] def evaluateDslEntry(
+      eval: Eval,
+      name: String,
+      imports: Seq[(String, Int)],
+      expression: String,
+      range: LineRange
+  ): TrackedEvalResult[DslEntry] = {
     // TODO - Should we try to namespace these between.sbt files?  IF they hash to the same value, they may actually be
     // exactly the same setting, so perhaps we don't care?
     val result = try {
-      eval.eval(expression, imports = new EvalImports(imports, name), srcName = name, tpeName = Some(SettingsDefinitionName), line = range.start)
+      eval.eval(
+        expression,
+        imports = new EvalImports(imports, name),
+        srcName = name,
+        tpeName = Some(SettingsDefinitionName),
+        line = range.start
+      )
     } catch {
       case e: sbt.compiler.EvalException => throw new MessageOnlyException(e.getMessage)
     }
     // TODO - keep track of configuration classes defined.
-    TrackedEvalResult(result.generated,
+    TrackedEvalResult(
+      result.generated,
       loader => {
         val pos = RangePosition(name, range shift 1)
         result.getValue(loader).asInstanceOf[DslEntry].withPos(pos)
-      })
+      }
+    )
   }
 
   /**
@@ -201,79 +264,136 @@ private[sbt] object EvaluateConfigurations {
    * @return A method that given an sbt classloader, can return the actual Seq[Setting[_]] defined by
    *         the expression.
    */
-  @deprecated("Build DSL now includes non-Setting[_] type settings.", "0.13.6") // Note: This method is used by the SET command, so we may want to evaluate that sucker a bit.
-  def evaluateSetting(eval: Eval, name: String, imports: Seq[(String, Int)], expression: String, range: LineRange): LazyClassLoaded[Seq[Setting[_]]] =
-    {
-      evaluateDslEntry(eval, name, imports, expression, range).result andThen {
-        case DslEntry.ProjectSettings(values) => values
-        case _                                => Nil
-      }
+  // Build DSL now includes non-Setting[_] type settings.
+  // Note: This method is used by the SET command, so we may want to evaluate that sucker a bit.
+  def evaluateSetting(
+      eval: Eval,
+      name: String,
+      imports: Seq[(String, Int)],
+      expression: String,
+      range: LineRange
+  ): LazyClassLoaded[Seq[Setting[_]]] =
+    evaluateDslEntry(eval, name, imports, expression, range).result andThen {
+      case DslEntry.ProjectSettings(values) => values
+      case _                                => Nil
     }
 
   /**
    * Splits a set of lines into (imports, expressions).  That is,
    * anything on the right of the tuple is a scala expression (definition or setting).
    */
-  private[sbt] def splitExpressions(file: File, lines: Seq[String]): (Seq[(String, Int)], Seq[(String, LineRange)]) =
-    {
-      val split = SbtParser(file, lines)
-      // TODO - Look at pulling the parsed expression trees from the SbtParser and stitch them back into a different
-      // scala compiler rather than re-parsing.
-      (split.imports, split.settings)
-    }
+  private[sbt] def splitExpressions(
+      file: File,
+      lines: Seq[String]
+  ): (Seq[(String, Int)], Seq[(String, LineRange)]) = {
+    val split = SbtParser(file, lines)
+    // TODO - Look at pulling the parsed expression trees from the SbtParser and stitch them back into a different
+    // scala compiler rather than re-parsing.
+    (split.imports, split.settings)
+  }
+
+  private[this] def splitSettingsDefinitions(
+      lines: Seq[(String, LineRange)]
+  ): (Seq[(String, LineRange)], Seq[(String, LineRange)]) =
+    lines partition { case (line, _) => isDefinition(line) }
+
+  private[this] def isDefinition(line: String): Boolean = {
+    val trimmed = line.trim
+    DefinitionKeywords.exists(trimmed startsWith _)
+  }
 
-  private[this] def splitSettingsDefinitions(lines: Seq[(String, LineRange)]): (Seq[(String, LineRange)], Seq[(String, LineRange)]) =
-    lines partition { case (line, range) => isDefinition(line) }
-  private[this] def isDefinition(line: String): Boolean =
-    {
-      val trimmed = line.trim
-      DefinitionKeywords.exists(trimmed startsWith _)
-    }
   private[this] def extractedValTypes: Seq[String] =
-    Seq(classOf[Project], classOf[InputKey[_]], classOf[TaskKey[_]], classOf[SettingKey[_]]).map(_.getName)
-  private[this] def evaluateDefinitions(eval: Eval, name: String, imports: Seq[(String, Int)], definitions: Seq[(String, LineRange)], file: Option[File]): compiler.EvalDefinitions =
-    {
-      val convertedRanges = definitions.map { case (s, r) => (s, r.start to r.end) }
-      eval.evalDefinitions(convertedRanges, new EvalImports(imports, name), name, file, extractedValTypes)
-    }
+    Seq(
+      classOf[CompositeProject],
+      classOf[InputKey[_]],
+      classOf[TaskKey[_]],
+      classOf[SettingKey[_]]
+    ).map(_.getName)
+
+  private[this] def evaluateDefinitions(
+      eval: Eval,
+      name: String,
+      imports: Seq[(String, Int)],
+      definitions: Seq[(String, LineRange)],
+      file: Option[File]
+  ): compiler.EvalDefinitions = {
+    val convertedRanges = definitions.map { case (s, r) => (s, r.start to r.end) }
+    eval.evalDefinitions(
+      convertedRanges,
+      new EvalImports(imports, name),
+      name,
+      file,
+      extractedValTypes
+    )
+  }
 }
+
 object Index {
-  def taskToKeyMap(data: Settings[Scope]): Map[Task[_], ScopedKey[Task[_]]] =
-    {
-      // AttributeEntry + the checked type test 'value: Task[_]' ensures that the cast is correct.
-      //  (scalac couldn't determine that 'key' is of type AttributeKey[Task[_]] on its own and a type match still required the cast)
-      val pairs = for (scope <- data.scopes; AttributeEntry(key, value: Task[_]) <- data.data(scope).entries) yield (value, ScopedKey(scope, key.asInstanceOf[AttributeKey[Task[_]]])) // unclear why this cast is needed even with a type test in the above filter
-      pairs.toMap[Task[_], ScopedKey[Task[_]]]
+  def taskToKeyMap(data: Settings[Scope]): Map[Task[_], ScopedKey[Task[_]]] = {
+
+    val pairs = data.scopes flatMap (
+        scope =>
+          data.data(scope).entries collect {
+            case AttributeEntry(key, value: Task[_]) =>
+              (value, ScopedKey(scope, key.asInstanceOf[AttributeKey[Task[_]]]))
+          }
+      )
+
+    pairs.toMap[Task[_], ScopedKey[Task[_]]]
+  }
+
+  def allKeys(settings: Seq[Setting[_]]): Set[ScopedKey[_]] = {
+    val result = new java.util.HashSet[ScopedKey[_]]
+    settings.foreach { s =>
+      if (!s.key.key.isLocal && result.add(s.key)) {
+        s.dependencies.foreach(k => if (!k.key.isLocal) result.add(s.key))
+      }
     }
-  def allKeys(settings: Seq[Setting[_]]): Set[ScopedKey[_]] =
-    settings.flatMap(s => if (s.key.key.isLocal) Nil else s.key +: s.dependencies).filter(!_.key.isLocal).toSet
+    result.asScala.toSet
+  }
+
   def attributeKeys(settings: Settings[Scope]): Set[AttributeKey[_]] =
     settings.data.values.flatMap(_.keys).toSet[AttributeKey[_]]
+
   def stringToKeyMap(settings: Set[AttributeKey[_]]): Map[String, AttributeKey[_]] =
     stringToKeyMap0(settings)(_.label)
 
-  private[this] def stringToKeyMap0(settings: Set[AttributeKey[_]])(label: AttributeKey[_] => String): Map[String, AttributeKey[_]] =
-    {
-      val multiMap = settings.groupBy(label)
-      val duplicates = multiMap collect { case (k, xs) if xs.size > 1 => (k, xs.map(_.manifest)) } collect { case (k, xs) if xs.size > 1 => (k, xs) }
-      if (duplicates.isEmpty)
-        multiMap.collect { case (k, v) if validID(k) => (k, v.head) } toMap
-      else
-        sys.error(duplicates map { case (k, tps) => "'" + k + "' (" + tps.mkString(", ") + ")" } mkString ("Some keys were defined with the same name but different types: ", ", ", ""))
-    }
-  private[this]type TriggerMap = collection.mutable.HashMap[Task[_], Seq[Task[_]]]
-  def triggers(ss: Settings[Scope]): Triggers[Task] =
-    {
-      val runBefore = new TriggerMap
-      val triggeredBy = new TriggerMap
-      for ((_, amap) <- ss.data; AttributeEntry(_, value: Task[_]) <- amap.entries) {
-        val as = value.info.attributes
-        update(runBefore, value, as get Keys.runBefore)
-        update(triggeredBy, value, as get Keys.triggeredBy)
+  private[this] def stringToKeyMap0(
+      settings: Set[AttributeKey[_]]
+  )(label: AttributeKey[_] => String): Map[String, AttributeKey[_]] = {
+    val multiMap = settings.groupBy(label)
+    val duplicates = multiMap.iterator
+      .collect { case (k, xs) if xs.size > 1 => (k, xs.map(_.manifest)) }
+      .collect {
+        case (k, xs) if xs.size > 1 => (k, xs)
       }
-      val onComplete = Keys.onComplete in GlobalScope get ss getOrElse { () => () }
-      new Triggers[Task](runBefore, triggeredBy, map => { onComplete(); map })
-    }
+      .toVector
+    if (duplicates.isEmpty)
+      multiMap.collect { case (k, v) if validID(k) => (k, v.head) } toMap
+    else
+      sys.error(
+        duplicates map { case (k, tps) => "'" + k + "' (" + tps.mkString(", ") + ")" } mkString ("Some keys were defined with the same name but different types: ", ", ", "")
+      )
+  }
+
+  private[this] type TriggerMap = collection.mutable.HashMap[Task[_], Seq[Task[_]]]
+
+  def triggers(ss: Settings[Scope]): Triggers[Task] = {
+    val runBefore = new TriggerMap
+    val triggeredBy = new TriggerMap
+    ss.data.values foreach (
+      _.entries foreach {
+        case AttributeEntry(_, value: Task[_]) =>
+          val as = value.info.attributes
+          update(runBefore, value, as get Keys.runBefore)
+          update(triggeredBy, value, as get Keys.triggeredBy)
+        case _ => ()
+      }
+    )
+    val onComplete = (GlobalScope / Keys.onComplete) get ss getOrElse (() => ())
+    new Triggers[Task](runBefore, triggeredBy, map => { onComplete(); map })
+  }
+
   private[this] def update(map: TriggerMap, base: Task[_], tasksOpt: Option[Seq[Task[_]]]): Unit =
     for (tasks <- tasksOpt; task <- tasks)
       map(task) = base +: map.getOrElse(task, Nil)
diff --git a/main/src/main/scala/sbt/internal/FastTrackCommands.scala b/main/src/main/scala/sbt/internal/FastTrackCommands.scala
new file mode 100644
index 000000000..13774fe7c
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/FastTrackCommands.scala
@@ -0,0 +1,52 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import BasicCommandStrings._
+import BasicCommands._
+import BuiltinCommands.{ shell, waitCmd }
+import ContinuousCommands._
+
+import sbt.internal.util.complete.Parser
+
+/** This is used to speed up command parsing. */
+private[sbt] object FastTrackCommands {
+  private def fromCommand(
+      cmd: String,
+      command: Command,
+      arguments: Boolean = true,
+  ): (State, String) => Option[State] =
+    (s, c) =>
+      Parser.parse(if (arguments) c else "", command.parser(s)) match {
+        case Right(newState) => Some(newState())
+        case l               => None
+      }
+  private val commands = Map[String, (State, String) => Option[State]](
+    FailureWall -> { case (s, c) => if (c == FailureWall) Some(s) else None },
+    StashOnFailure -> fromCommand(StashOnFailure, stashOnFailure, arguments = false),
+    PopOnFailure -> fromCommand(PopOnFailure, popOnFailure, arguments = false),
+    Shell -> fromCommand(Shell, shell),
+    failWatch -> fromCommand(failWatch, failWatchCommand),
+    preWatch -> fromCommand(preWatch, preWatchCommand),
+    postWatch -> fromCommand(postWatch, postWatchCommand),
+    runWatch -> fromCommand(runWatch, runWatchCommand),
+    stopWatch -> fromCommand(stopWatch, stopWatchCommand),
+    waitWatch -> fromCommand(waitWatch, waitCmd),
+  )
+  private[sbt] def evaluate(state: State, cmd: String): Option[State] = {
+    cmd.trim.split(" ") match {
+      case Array(h, _*) =>
+        commands.get(h) match {
+          case Some(command) => command(state, cmd)
+          case _             => None
+        }
+      case _ => None
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/FileChangesMacro.scala b/main/src/main/scala/sbt/internal/FileChangesMacro.scala
new file mode 100644
index 000000000..0b60b53cc
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/FileChangesMacro.scala
@@ -0,0 +1,104 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.nio.file.{ Path => NioPath }
+
+import sbt.nio.Keys._
+import sbt.nio.{ FileChanges, FileStamp }
+
+import scala.annotation.compileTimeOnly
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox
+
+/**
+ * Provides extension methods to `TaskKey[T]` that can be use to fetch the input and output file
+ * dependency changes for a task. Nothing in this object is intended to be called directly but,
+ * because there are macro definitions, some of the definitions must be public.
+ *
+ */
+object FileChangesMacro {
+  private[sbt] sealed abstract class TaskOps[T](val taskKey: TaskKey[T]) {
+    @compileTimeOnly(
+      "`inputFileChanges` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task."
+    )
+    def inputFileChanges: FileChanges = macro changedInputFilesImpl[T]
+    @compileTimeOnly(
+      "`outputFileChanges` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task."
+    )
+    def outputFileChanges: FileChanges = macro changedOutputFilesImpl[T]
+    @compileTimeOnly(
+      "`inputFiles` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task."
+    )
+    def inputFiles: Seq[NioPath] = macro inputFilesImpl[T]
+    @compileTimeOnly(
+      "`outputFiles` can only be called on a task within a task definition macro, such as :=, +=, ++=, or Def.task."
+    )
+    def outputFiles: Seq[NioPath] = macro outputFilesImpl[T]
+  }
+  def changedInputFilesImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[FileChanges] = {
+    impl[T](c)(
+      c.universe.reify(allInputFiles),
+      c.universe.reify(changedInputFiles),
+      c.universe.reify(inputFileStamps)
+    )
+  }
+  def changedOutputFilesImpl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  ): c.Expr[FileChanges] = {
+    impl[T](c)(
+      c.universe.reify(allOutputFiles),
+      c.universe.reify(changedOutputFiles),
+      c.universe.reify(outputFileStamps)
+    )
+  }
+  def rescope[T](left: TaskKey[_], right: TaskKey[T]): TaskKey[T] =
+    Scoped.scopedTask(left.scope.copy(task = Select(left.key)), right.key)
+  def rescope[T](left: Scope, right: TaskKey[T]): TaskKey[T] =
+    Scoped.scopedTask(left, right.key)
+  private def impl[T: c.WeakTypeTag](
+      c: blackbox.Context
+  )(
+      currentKey: c.Expr[TaskKey[Seq[NioPath]]],
+      changeKey: c.Expr[TaskKey[Seq[(NioPath, FileStamp)] => FileChanges]],
+      mapKey: c.Expr[TaskKey[Seq[(NioPath, FileStamp)]]]
+  ): c.Expr[FileChanges] = {
+    import c.universe._
+    val taskScope = getTaskScope(c)
+    reify {
+      val changes = rescope(taskScope.splice, changeKey.splice).value
+      val current = rescope(taskScope.splice, currentKey.splice).value
+      import sbt.nio.FileStamp.Formats._
+      val previous = Previous.runtimeInEnclosingTask(rescope(taskScope.splice, mapKey.splice)).value
+      previous.map(changes).getOrElse(FileChanges.noPrevious(current))
+    }
+  }
+  def inputFilesImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Seq[NioPath]] = {
+    val taskKey = getTaskScope(c)
+    c.universe.reify(rescope(taskKey.splice, allInputFiles).value)
+  }
+  def outputFilesImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Seq[NioPath]] = {
+    val taskKey = getTaskScope(c)
+    c.universe.reify(rescope(taskKey.splice, allOutputFiles).value)
+  }
+  private def getTaskScope[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[sbt.Scope] = {
+    import c.universe._
+    val taskTpe = c.weakTypeOf[TaskKey[T]]
+    lazy val err = "Couldn't expand file change macro."
+    c.macroApplication match {
+      case Select(Apply(_, k :: Nil), _) if k.tpe <:< taskTpe =>
+        val expr = c.Expr[TaskKey[T]](k)
+        c.universe.reify {
+          if (expr.splice.scope.task.toOption.isDefined) expr.splice.scope
+          else expr.splice.scope.copy(task = sbt.Select(expr.splice.key))
+        }
+      case _ => c.abort(c.enclosingPosition, err)
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/GCMonitor.scala b/main/src/main/scala/sbt/internal/GCMonitor.scala
new file mode 100644
index 000000000..aacd8fac3
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/GCMonitor.scala
@@ -0,0 +1,94 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import javax.management.{ NotificationEmitter, NotificationListener }
+import java.lang.management.ManagementFactory
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.atomic.AtomicReference
+import scala.concurrent.duration._
+import scala.collection.JavaConverters._
+import scala.util.Try
+import sbt.util.Logger
+
+trait GCMonitorBase {
+  protected def window: FiniteDuration
+
+  protected def ratio: Double
+
+  protected val queue = new LinkedBlockingQueue[(FiniteDuration, Long)]
+  protected val queueScala = queue.asScala
+  private[this] val lastWarned = new AtomicReference(Deadline(Int.MinValue.millis))
+
+  protected def emitWarning(total: Long, over: Option[Long]): Unit
+
+  val startTime = System.currentTimeMillis()
+
+  private[internal] def totalCollectionTimeChanged(
+      nowMillis: Long,
+      collectionTime: Long,
+      collectionTimeStore: AtomicReference[(FiniteDuration, Long)]
+  ): Unit = {
+    val now = nowMillis.millis
+    val (lastTimestamp, lastCollectionTime) = collectionTimeStore.getAndSet(now -> collectionTime)
+    val elapsed = collectionTime - lastCollectionTime
+    queue.removeIf { case (whenEventHappened, _) => now > whenEventHappened + window }
+    queue.add(lastTimestamp -> elapsed)
+    val total = queueScala.foldLeft(0L) { case (total, (_, t)) => total + t }
+    val over = queueScala.headOption.map(nowMillis - _._1.toMillis)
+    if ((total > window.toMillis * ratio) && (lastWarned.get + window).time <= now) {
+      lastWarned.set(Deadline(now))
+      emitWarning(total, over)
+    }
+  }
+}
+
+class GCMonitor(logger: Logger) extends GCMonitorBase with AutoCloseable {
+  override protected def window =
+    Try(System.getProperty("sbt.gc.monitor.window", "10").toInt).getOrElse(10).seconds
+
+  override protected def ratio =
+    Try(System.getProperty("sbt.gc.monitor.ratio", "0.5").toDouble).getOrElse(0.5)
+
+  final val GB = 1024 * 1024 * 1024.0
+  val runtime = Runtime.getRuntime
+  def gbString(n: Long) = f"${n / GB}%.2fGB"
+
+  override protected def emitWarning(total: Long, over: Option[Long]): Unit = {
+    val totalSeconds = total / 1000.0
+    val amountMsg = over.fold(totalSeconds + " seconds") { d =>
+      "In the last " + (d / 1000.0).ceil.toInt + f" seconds, $totalSeconds (${total.toDouble / d * 100}%.1f%%)"
+    }
+    val msg = s"$amountMsg were spent in GC. " +
+      s"[Heap: ${gbString(runtime.freeMemory())} free " +
+      s"of ${gbString(runtime.totalMemory())}, " +
+      s"max ${gbString(runtime.maxMemory())}] " +
+      "Consider increasing the JVM heap using `-Xmx` or try " +
+      "a different collector, e.g. `-XX:+UseG1GC`, for better performance."
+    logger.warn(msg)
+  }
+
+  val removers = ManagementFactory.getGarbageCollectorMXBeans.asScala.flatMap {
+    case bean: NotificationEmitter =>
+      val collectionTimeStore =
+        new AtomicReference(System.currentTimeMillis().millis -> bean.getCollectionTime)
+      val listener: NotificationListener =
+        (notification, _) =>
+          totalCollectionTimeChanged(
+            notification.getTimeStamp,
+            bean.getCollectionTime,
+            collectionTimeStore
+          )
+      bean.addNotificationListener(listener, null, null)
+      Some(() => bean.removeNotificationListener(listener))
+    case _ => None
+  }
+  override def close(): Unit = {
+    removers.foreach(_.apply())
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/GCUtil.scala b/main/src/main/scala/sbt/internal/GCUtil.scala
index c8793335c..821ea7022 100644
--- a/main/src/main/scala/sbt/internal/GCUtil.scala
+++ b/main/src/main/scala/sbt/internal/GCUtil.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -10,19 +17,18 @@ private[sbt] object GCUtil {
   // Returns the default force garbage collection flag,
   // as specified by system properties.
   val defaultForceGarbageCollection: Boolean = true
-  val defaultMinForcegcInterval: Duration = 60.seconds
-  val lastGcCheck: AtomicLong = new AtomicLong(0L)
+  val defaultMinForcegcInterval: Duration = 10.minutes
+  val lastGcCheck: AtomicLong = new AtomicLong(System.currentTimeMillis)
 
-  def forceGcWithInterval(minForcegcInterval: Duration, log: Logger): Unit =
-    {
-      val now = System.currentTimeMillis
-      val last = lastGcCheck.get
-      // This throttles System.gc calls to interval
-      if (now - last > minForcegcInterval.toMillis) {
-        lastGcCheck.lazySet(now)
-        forceGc(log)
-      }
+  def forceGcWithInterval(minForcegcInterval: Duration, log: Logger): Unit = {
+    val now = System.currentTimeMillis
+    val last = lastGcCheck.get
+    // This throttles System.gc calls to interval
+    if (now - last > minForcegcInterval.toMillis) {
+      lastGcCheck.lazySet(now)
+      forceGc(log)
     }
+  }
 
   def forceGc(log: Logger): Unit =
     try {
diff --git a/main/src/main/scala/sbt/internal/GlobalPlugin.scala b/main/src/main/scala/sbt/internal/GlobalPlugin.scala
index 56587a572..285f15910 100644
--- a/main/src/main/scala/sbt/internal/GlobalPlugin.scala
+++ b/main/src/main/scala/sbt/internal/GlobalPlugin.scala
@@ -1,14 +1,30 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
-import sbt.librarymanagement.{ Configuration, Configurations, ModuleID, Resolver, SbtArtifacts, UpdateReport }
+import sbt.librarymanagement.{
+  Configuration,
+  Configurations,
+  ModuleID,
+  Resolver,
+  SbtArtifacts,
+  UpdateReport
+}
 import sbt.internal.util.Attributed
 import Def.{ ScopedKey, Setting }
 import Keys._
 import Configurations.{ Compile, Runtime }
+import sbt.SlashSyntax0._
 import java.io.File
 import org.apache.ivy.core.module.{ descriptor, id }
 import descriptor.ModuleDescriptor, id.ModuleRevisionId
+import scala.annotation.nowarn
 
 object GlobalPlugin {
   // constructs a sequence of settings that may be appended to a project's settings to
@@ -27,61 +43,95 @@ object GlobalPlugin {
       injectInternalClasspath(Runtime, gp.internalClasspath),
       injectInternalClasspath(Compile, gp.internalClasspath)
     )
-  private[this] def injectInternalClasspath(config: Configuration, cp: Seq[Attributed[File]]): Setting[_] =
-    internalDependencyClasspath in config ~= { prev => (prev ++ cp).distinct }
+  private[this] def injectInternalClasspath(
+      config: Configuration,
+      cp: Seq[Attributed[File]]
+  ): Setting[_] =
+    (config / internalDependencyClasspath) ~= { prev =>
+      (prev ++ cp).distinct
+    }
 
-  def build(base: File, s: State, config: LoadBuildConfiguration): (BuildStructure, State) =
-    {
-      val newInject = config.injectSettings.copy(global = config.injectSettings.global ++ globalPluginSettings)
-      val globalConfig = config.copy(injectSettings = newInject, pluginManagement = config.pluginManagement.forGlobalPlugin)
-      val (eval, structure) = Load(base, s, globalConfig)
-      val session = Load.initialSession(structure, eval)
-      (structure, Project.setProject(session, structure, s))
-    }
-  def load(base: File, s: State, config: LoadBuildConfiguration): GlobalPlugin =
-    {
-      val (structure, state) = build(base, s, config)
-      val (newS, data) = extract(state, structure)
-      Project.runUnloadHooks(newS) // discard state
-      GlobalPlugin(data, structure, inject(data), base)
-    }
-  def extract(state: State, structure: BuildStructure): (State, GlobalPluginData) =
-    {
-      import structure.{ data, root, rootProject }
-      val p: Scope = Scope.GlobalScope in ProjectRef(root, rootProject(root))
+  def build(base: File, s: State, config: LoadBuildConfiguration): (BuildStructure, State) = {
+    val newInject =
+      config.injectSettings.copy(global = config.injectSettings.global ++ globalPluginSettings)
+    val globalConfig = config.copy(
+      injectSettings = newInject,
+      pluginManagement = config.pluginManagement.forGlobalPlugin
+    )
+    val (eval, structure) = Load(base, s, globalConfig)
+    val session = Load.initialSession(structure, eval)
+    (structure, Project.setProject(session, structure, s))
+  }
+  def load(base: File, s: State, config: LoadBuildConfiguration): GlobalPlugin = {
+    val (structure, state) = build(base, s, config)
+    val (newS, data) = extract(state, structure)
+    Project.runUnloadHooks(newS) // discard state
+    GlobalPlugin(data, structure, inject(data), base)
+  }
 
-      val taskInit = Def.task {
-        val intcp = (internalDependencyClasspath in Runtime).value
-        val prods = (exportedProducts in Runtime).value
-        val depMap = projectDescriptors.value + ivyModule.value.dependencyMapping(state.log)
-        // If we reference it directly (if it's an executionRoot) then it forces an update, which is not what we want.
-        val updateReport = Def.taskDyn { Def.task { update.value } }.value
+  @nowarn
+  def extract(state: State, structure: BuildStructure): (State, GlobalPluginData) = {
+    import structure.{ data, root, rootProject }
+    val p: Scope = Scope.GlobalScope in ProjectRef(root, rootProject(root))
 
-        GlobalPluginData(projectID.value, projectDependencies.value, depMap, resolvers.value, (fullClasspath in Runtime).value,
-          (prods ++ intcp).distinct)(updateReport)
-      }
-      val resolvedTaskInit = taskInit mapReferenced Project.mapScope(Scope replaceThis p)
-      val task = resolvedTaskInit evaluate data
-      val roots = resolvedTaskInit.dependencies
-      evaluate(state, structure, task, roots)
+    val taskInit = Def.task {
+      val intcp = (Runtime / internalDependencyClasspath).value
+      val prods = (Runtime / exportedProducts).value
+      val depMap = projectDescriptors.value + ivyModule.value.dependencyMapping(state.log)
+      // If we reference it directly (if it's an executionRoot) then it forces an update, which is not what we want.
+      val updateReport = Def.taskDyn { Def.task { update.value } }.value
+
+      GlobalPluginData(
+        projectID.value,
+        projectDependencies.value,
+        depMap,
+        resolvers.value.toVector,
+        (Runtime / fullClasspath).value,
+        (prods ++ intcp).distinct
+      )(updateReport)
     }
-  def evaluate[T](state: State, structure: BuildStructure, t: Task[T], roots: Seq[ScopedKey[_]]): (State, T) =
-    {
-      import EvaluateTask._
-      withStreams(structure, state) { str =>
-        val nv = nodeView(state, str, roots)
-        val config = EvaluateTask.extractedTaskConfig(Project.extract(state), structure, state)
-        val (newS, result) = runTask(t, state, str, structure.index.triggers, config)(nv)
-        (newS, processResult(result, newS.log))
-      }
+    val resolvedTaskInit = taskInit mapReferenced Project.mapScope(Scope replaceThis p)
+    val task = resolvedTaskInit evaluate data
+    val roots = resolvedTaskInit.dependencies
+    evaluate(state, structure, task, roots)
+  }
+  def evaluate[T](
+      state: State,
+      structure: BuildStructure,
+      t: Task[T],
+      roots: Seq[ScopedKey[_]]
+  ): (State, T) = {
+    import EvaluateTask._
+    withStreams(structure, state) { str =>
+      val nv = nodeView(state, str, roots)
+      val config = EvaluateTask.extractedTaskConfig(Project.extract(state), structure, state)
+      val (newS, result) = runTask(t, state, str, structure.index.triggers, config)(nv)
+      (newS, processResult2(result))
     }
-  val globalPluginSettings = Project.inScope(Scope.GlobalScope in LocalRootProject)(Seq(
-    organization := SbtArtifacts.Organization,
-    onLoadMessage := Keys.baseDirectory("Loading global plugins from " + _).value,
-    name := "global-plugin",
-    sbtPlugin := true,
-    version := "0.0"
-  ))
+  }
+
+  @nowarn
+  val globalPluginSettings = Project.inScope(Scope.GlobalScope in LocalRootProject)(
+    Seq(
+      organization := SbtArtifacts.Organization,
+      onLoadMessage := Keys.baseDirectory("loading global plugins from " + _).value,
+      name := "global-plugin",
+      sbtPlugin := true,
+      version := "0.0"
+    )
+  )
 }
-final case class GlobalPluginData(projectID: ModuleID, dependencies: Seq[ModuleID], descriptors: Map[ModuleRevisionId, ModuleDescriptor], resolvers: Seq[Resolver], fullClasspath: Classpath, internalClasspath: Classpath)(val updateReport: UpdateReport)
-final case class GlobalPlugin(data: GlobalPluginData, structure: BuildStructure, inject: Seq[Setting[_]], base: File)
+final case class GlobalPluginData(
+    projectID: ModuleID,
+    dependencies: Seq[ModuleID],
+    descriptors: Map[ModuleRevisionId, ModuleDescriptor],
+    resolvers: Vector[Resolver],
+    fullClasspath: Classpath,
+    internalClasspath: Classpath
+)(val updateReport: UpdateReport)
+final case class GlobalPlugin(
+    data: GlobalPluginData,
+    structure: BuildStructure,
+    inject: Seq[Setting[_]],
+    base: File
+)
diff --git a/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala b/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala
index defaf7ed3..af67e69bd 100644
--- a/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala
+++ b/main/src/main/scala/sbt/internal/GroupedAutoPlugins.scala
@@ -1,19 +1,30 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
 import Def.Setting
 import java.net.URI
 
-private[sbt] final class GroupedAutoPlugins(val all: Seq[AutoPlugin], val byBuild: Map[URI, Seq[AutoPlugin]]) {
+private[sbt] final class GroupedAutoPlugins(
+    val all: Seq[AutoPlugin],
+    val byBuild: Map[URI, Seq[AutoPlugin]]
+) {
   def globalSettings: Seq[Setting[_]] = all.flatMap(_.globalSettings)
-  def buildSettings(uri: URI): Seq[Setting[_]] = byBuild.getOrElse(uri, Nil).flatMap(_.buildSettings)
+  def buildSettings(uri: URI): Seq[Setting[_]] =
+    byBuild.getOrElse(uri, Nil).flatMap(_.buildSettings)
 }
 
 private[sbt] object GroupedAutoPlugins {
-  private[sbt] def apply(units: Map[URI, LoadedBuildUnit]): GroupedAutoPlugins =
-    {
-      val byBuild: Map[URI, Seq[AutoPlugin]] = units.mapValues(unit => unit.defined.values.flatMap(_.autoPlugins).toSeq.distinct).toMap
-      val all: Seq[AutoPlugin] = byBuild.values.toSeq.flatten.distinct
-      new GroupedAutoPlugins(all, byBuild)
-    }
+  private[sbt] def apply(units: Map[URI, LoadedBuildUnit]): GroupedAutoPlugins = {
+    val byBuild: Map[URI, Seq[AutoPlugin]] =
+      units.mapValues(unit => unit.projects.flatMap(_.autoPlugins).toSeq.distinct).toMap
+    val all: Seq[AutoPlugin] = byBuild.values.toSeq.flatten.distinct
+    new GroupedAutoPlugins(all, byBuild)
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/InMemoryCacheStore.scala b/main/src/main/scala/sbt/internal/InMemoryCacheStore.scala
new file mode 100644
index 000000000..58eeeb5ef
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/InMemoryCacheStore.scala
@@ -0,0 +1,132 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.io.IOException
+import java.lang.Math.toIntExact
+import java.nio.file.attribute.BasicFileAttributes
+import java.nio.file.{ Files, Path }
+import java.util.concurrent.atomic.AtomicReference
+
+import com.github.benmanes.caffeine.cache.{ Cache, Caffeine, Weigher }
+import sbt.io.IO
+import sbt.util.{ CacheStore, CacheStoreFactory, DirectoryStoreFactory }
+import sjsonnew.{ JsonReader, JsonWriter }
+
+private[sbt] object InMemoryCacheStore {
+  private[this] class InMemoryCacheStore(maxSize: Long) extends AutoCloseable {
+    private[this] val weigher: Weigher[Path, (Any, Long, Int)] = { case (_, (_, _, size)) => size }
+    private[this] val files: Cache[Path, (Any, Long, Int)] = Caffeine
+      .newBuilder()
+      .maximumWeight(maxSize)
+      .weigher(weigher)
+      .build()
+    def get[T](path: Path): Option[(T, Long)] = {
+      files.getIfPresent(path) match {
+        case null                                   => None
+        case (value: T @unchecked, lastModified, _) => Some((value, lastModified))
+      }
+    }
+    def put(path: Path, value: Any, lastModified: Long): Unit = {
+      try {
+        if (lastModified > 0) {
+          val attributes = Files.readAttributes(path, classOf[BasicFileAttributes])
+          files.put(path, (value, lastModified, toIntExact(attributes.size)))
+        }
+      } catch {
+        case _: IOException | _: ArithmeticException => files.invalidate(path)
+      }
+    }
+    def remove(path: Path): Unit = files.invalidate(path)
+
+    override def close(): Unit = {
+      files.invalidateAll()
+      files.cleanUp()
+    }
+  }
+
+  private[this] class CacheStoreImpl(path: Path, store: InMemoryCacheStore, cacheStore: CacheStore)
+      extends CacheStore {
+    override def delete(): Unit = cacheStore.delete()
+    override def read[T]()(implicit reader: JsonReader[T]): T = {
+      val lastModified = IO.getModifiedTimeOrZero(path.toFile)
+      store.get[T](path) match {
+        case Some((value, `lastModified`)) => value
+        case _                             => cacheStore.read[T]()
+      }
+    }
+    override def write[T](value: T)(implicit writer: JsonWriter[T]): Unit = {
+      /*
+       * This may be inefficient if multiple threads are concurrently modifying the file.
+       * There is an assumption that there will be little to no concurrency at the file level
+       * of this cache. If this assumption is invalidated, we may need to do something more
+       * complicated.
+       */
+      val lastModified = IO.getModifiedTimeOrZero(path.toFile)
+      store.get[T](path) match {
+        case Some((v, `lastModified`)) if v == value => // nothing has changed
+        case _ =>
+          store.remove(path)
+          cacheStore.write(value)
+          val newLastModified = System.currentTimeMillis
+          IO.setModifiedTimeOrFalse(path.toFile, newLastModified)
+          store.put(path, value, newLastModified)
+      }
+    }
+    override def close(): Unit = {
+      store.remove(path)
+      cacheStore.close()
+    }
+  }
+  private[this] def factory(
+      store: InMemoryCacheStore,
+      path: Path
+  ): CacheStoreFactory = {
+    val delegate = new DirectoryStoreFactory(path.toFile)
+    new CacheStoreFactory {
+      override def make(identifier: String): CacheStore =
+        new CacheStoreImpl(path.resolve(identifier), store, delegate.make(identifier))
+      override def sub(identifier: String): CacheStoreFactory =
+        factory(store, path.resolve(identifier))
+    }
+  }
+  private[sbt] trait CacheStoreFactoryFactory extends AutoCloseable {
+    def apply(path: Path): CacheStoreFactory
+  }
+  private[this] class CacheStoreFactoryFactoryImpl(size: Long) extends CacheStoreFactoryFactory {
+    private[this] val storeRef = new AtomicReference[InMemoryCacheStore]
+    override def close(): Unit = Option(storeRef.get).foreach(_.close())
+    def apply(
+        path: Path,
+    ): CacheStoreFactory = {
+      val store = storeRef.get match {
+        case null =>
+          storeRef.synchronized {
+            storeRef.get match {
+              case null =>
+                val s = new InMemoryCacheStore(size)
+                storeRef.set(s)
+                s
+              case s => s
+            }
+          }
+        case s => s
+      }
+      factory(store, path)
+    }
+  }
+  private[this] object DirectoryFactory extends CacheStoreFactoryFactory {
+    override def apply(
+        path: Path,
+    ): CacheStoreFactory = new DirectoryStoreFactory(path.toFile)
+    override def close(): Unit = {}
+  }
+  def factory(size: Long): CacheStoreFactoryFactory =
+    if (size > 0) new CacheStoreFactoryFactoryImpl(size)
+    else DirectoryFactory
+}
diff --git a/main/src/main/scala/sbt/internal/Inspect.scala b/main/src/main/scala/sbt/internal/Inspect.scala
index 0d1e9ff6a..ecc84b5b3 100644
--- a/main/src/main/scala/sbt/internal/Inspect.scala
+++ b/main/src/main/scala/sbt/internal/Inspect.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -8,6 +15,7 @@ import DefaultParsers._
 import Def.ScopedKey
 import Types.idFun
 import java.io.File
+import Scope.Global
 
 object Inspect {
   sealed trait Mode
@@ -19,40 +27,76 @@ object Inspect {
   val Uses: Mode = UsesMode
   val Definitions: Mode = DefinitionsMode
 
-  def parser: State => Parser[(Inspect.Mode, ScopedKey[_])] = (s: State) => spacedModeParser(s) flatMap {
-    case opt @ (UsesMode | DefinitionsMode)      => allKeyParser(s).map(key => (opt, Def.ScopedKey(Global, key)))
-    case opt @ (DependencyTreeMode | Details(_)) => spacedKeyParser(s).map(key => (opt, key))
-  }
-  val spacedModeParser: (State => Parser[Mode]) = (s: State) => {
+  def parser: State => Parser[() => String] =
+    (s: State) =>
+      spacedModeParser(s) flatMap { mode =>
+        commandHandler(s, mode) | keyHandler(s)(mode)
+      }
+  val spacedModeParser: State => Parser[Mode] = (_: State) => {
+    val default = "-" ^^^ Details(false)
     val actual = "actual" ^^^ Details(true)
     val tree = "tree" ^^^ DependencyTree
     val uses = "uses" ^^^ Uses
     val definitions = "definitions" ^^^ Definitions
-    token(Space ~> (tree | actual | uses | definitions)) ?? Details(false)
+    token(Space ~> (default | tree | actual | uses | definitions)) ?? Details(false)
   }
 
-  def allKeyParser(s: State): Parser[AttributeKey[_]] =
-    {
-      val keyMap = Project.structure(s).index.keyMap
-      token(Space ~> (ID !!! "Expected key" examples keyMap.keySet)) flatMap { key => Act.getKey(keyMap, key, idFun) }
+  def allKeyParser(s: State): Parser[AttributeKey[_]] = {
+    val keyMap = Project.structure(s).index.keyMap
+    token(Space ~> (ID !!! "Expected key" examples keyMap.keySet)) flatMap { key =>
+      Act.getKey(keyMap, key, idFun)
     }
-  val spacedKeyParser: State => Parser[ScopedKey[_]] = (s: State) => Act.requireSession(s, token(Space) ~> Act.scopedKeyParser(s))
+  }
+  val spacedKeyParser: State => Parser[ScopedKey[_]] = (s: State) =>
+    Act.requireSession(s, token(Space) ~> Act.scopedKeyParser(s))
 
-  def output(s: State, option: Mode, sk: Def.ScopedKey[_]): String =
-    {
-      val extracted = Project.extract(s)
-      import extracted._
-      option match {
-        case Details(actual) =>
-          Project.details(structure, actual, sk.scope, sk.key)
-        case DependencyTreeMode =>
-          val basedir = new File(Project.session(s).current.build)
-          Project.settingGraph(structure, basedir, sk).dependsAscii
-        case UsesMode =>
-          Project.showUses(Project.usedBy(structure, true, sk.key))
-        case DefinitionsMode =>
-          Project.showDefinitions(sk.key, Project.definitions(structure, true, sk.key))
-      }
+  def keyHandler(s: State): Mode => Parser[() => String] = {
+    case opt @ (UsesMode | DefinitionsMode) =>
+      allKeyParser(s).map(key => () => keyOutput(s, opt, Def.ScopedKey(Global, key)))
+    case opt @ (DependencyTreeMode | Details(_)) =>
+      spacedKeyParser(s).map(key => () => keyOutput(s, opt, key))
+  }
+
+  def commandHandler(s: State, mode: Mode): Parser[() => String] = {
+    Space ~> commandParser(s).flatMap {
+      case (name, cmd) =>
+        cmd.tags.get(BasicCommands.CommandAliasKey) match {
+          case Some((_, aliasFor)) =>
+            def header = s"Alias for: $aliasFor"
+            Parser
+              .parse(" " ++ aliasFor, keyHandler(s)(mode))
+              .fold(
+                // If we can't find a task key for the alias target
+                // we don't display anymore information
+                _ => success(() => header),
+                success
+              )
+          case None =>
+            success(() => s"Command: $name")
+        }
     }
+  }
+
+  def commandParser: State => Parser[(String, Command)] = { s =>
+    oneOf(s.definedCommands.map(cmd => cmd -> cmd.nameOption) collect {
+      case (cmd, Some(name)) => DefaultParsers.literal(name).map(_ -> cmd)
+    })
+  }
+
+  def keyOutput(s: State, option: Mode, sk: Def.ScopedKey[_]): String = {
+    val extracted = Project.extract(s)
+    import extracted._
+    option match {
+      case Details(actual) =>
+        Project.details(structure, actual, sk.scope, sk.key)
+      case DependencyTreeMode =>
+        val basedir = new File(Project.session(s).current.build)
+        Project.settingGraph(structure, basedir, sk).dependsAscii(get(sbt.Keys.asciiGraphWidth))
+      case UsesMode =>
+        Project.showUses(Project.usedBy(structure, true, sk.key))
+      case DefinitionsMode =>
+        Project.showDefinitions(sk.key, Project.definitions(structure, true, sk.key))
+    }
+  }
 
 }
diff --git a/main/src/main/scala/sbt/internal/InstallSbtn.scala b/main/src/main/scala/sbt/internal/InstallSbtn.scala
new file mode 100644
index 000000000..271a9a0cf
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/InstallSbtn.scala
@@ -0,0 +1,226 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import Def._
+import Keys.{ sbtVersion, state, terminal }
+
+import java.io.{ File, FileInputStream, FileOutputStream, InputStream, IOException }
+import java.net.URL
+import java.nio.file.{ Files, Path }
+import java.util.zip.ZipInputStream
+import sbt.io.IO
+import sbt.io.Path.userHome
+import sbt.io.syntax._
+import scala.util.{ Properties, Try }
+
+private[sbt] object InstallSbtn {
+  private[sbt] val installSbtn =
+    Def.inputKey[Unit]("install sbtn and tab completions").withRank(KeyRanks.BTask)
+  private[sbt] def installSbtnImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val inputVersion = Def.spaceDelimited("version").parsed.headOption
+    val version = inputVersion.getOrElse(sbtVersion.value.replaceAllLiterally("-SNAPSHOT", ""))
+    val term = terminal.value
+    term.setMode(canonical = false, echo = false)
+    val baseDirectory = BuildPaths.getGlobalBase(state.value).toPath
+    val tmp = Files.createTempFile(s"sbt-$version", "zip")
+    val sbtn = if (Properties.isWin) "sbtn.exe" else "sbtn"
+    try extractSbtn(term, version, tmp, baseDirectory.resolve("bin").resolve(sbtn))
+    finally {
+      Files.deleteIfExists(tmp)
+      ()
+    }
+    val shell = if (System.console != null) getShell(term) else "none"
+    shell match {
+      case "none" =>
+      case s =>
+        val completion = shellCompletions(s)
+        val completionLocation = baseDirectory.resolve("completions").resolve(completion)
+        downloadCompletion(completion, version, completionLocation)
+        s match {
+          case "bash"       => setupBash(baseDirectory, term)
+          case "fish"       => setupFish(baseDirectory, term)
+          case "zsh"        => setupZsh(baseDirectory, term)
+          case "powershell" => setupPowershell(baseDirectory, term)
+          case _            => // should be unreachable
+        }
+        val msg = s"Successfully installed sbtn for $s. You may need to restart $s for the " +
+          "changes to take effect."
+        term.printStream.println(msg)
+    }
+    ()
+  }
+
+  private[sbt] def extractSbtn(term: Terminal, version: String, sbtZip: Path, sbtn: Path): Unit = {
+    downloadRelease(term, version, sbtZip)
+    Files.createDirectories(sbtn.getParent)
+    val bin =
+      if (Properties.isWin) "pc-win32.exe"
+      else if (Properties.isLinux) "pc-linux"
+      else "apple-darwin"
+    val sbtnName = s"sbt/bin/sbtn-x86_64-$bin"
+    val fis = new FileInputStream(sbtZip.toFile)
+    val zipInputStream = new ZipInputStream(fis)
+    var foundBinary = false
+    try {
+      var entry = zipInputStream.getNextEntry
+      while (entry != null) {
+        if (entry.getName == sbtnName) {
+          foundBinary = true
+          term.printStream.println(s"extracting $sbtZip!$sbtnName to $sbtn")
+          transfer(zipInputStream, sbtn)
+          sbtn.toFile.setExecutable(true)
+          entry = null
+        } else {
+          entry = zipInputStream.getNextEntry
+        }
+      }
+      if (!foundBinary) throw new IllegalStateException(s"couldn't find $sbtnName in $sbtZip")
+    } finally {
+      fis.close()
+      zipInputStream.close()
+    }
+    ()
+  }
+  private[this] def downloadRelease(term: Terminal, version: String, location: Path): Unit = {
+    val zip = s"https://github.com/sbt/sbt/releases/download/v$version/sbt-$version.zip"
+    val url = new URL(zip)
+    term.printStream.println(s"downloading $zip to $location")
+    transfer(url.openStream(), location)
+  }
+  private[this] def transfer(inputStream: InputStream, path: Path): Unit =
+    try {
+      val os = new FileOutputStream(path.toFile)
+      try {
+        val result = new Array[Byte](1024 * 1024)
+        var bytesRead = -1
+        do {
+          bytesRead = inputStream.read(result)
+          if (bytesRead > 0) os.write(result, 0, bytesRead)
+        } while (bytesRead > 0)
+      } finally os.close()
+    } finally inputStream.close()
+  private[this] def getShell(term: Terminal): String = {
+    term.printStream.print(s"""Setup sbtn for shell:
+      | [1] bash
+      | [2] fish
+      | [3] powershell
+      | [4] zsh
+      | [5] none
+      |Enter option: """.stripMargin)
+    term.printStream.flush()
+    val key = term.inputStream.read
+    term.printStream.println(key.toChar)
+    key match {
+      case 49 => "bash"
+      case 50 => "fish"
+      case 51 => "powershell"
+      case 52 => "zsh"
+      case _  => "none"
+    }
+  }
+  private[this] def downloadCompletion(completion: String, version: String, target: Path): Unit = {
+    Files.createDirectories(target.getParent)
+    val comp = s"https://raw.githubusercontent.com/sbt/sbt/v$version/client/completions/$completion"
+    transfer(new URL(comp).openStream, target)
+  }
+  private[this] def setupShell(
+      shell: String,
+      baseDirectory: Path,
+      term: Terminal,
+      configFile: File,
+      setPath: Path => String,
+      setCompletions: Path => String,
+  ): Unit = {
+    val bin = baseDirectory.resolve("bin")
+    val export = setPath(bin)
+    val completions = baseDirectory.resolve("completions")
+    val sourceCompletions = setCompletions(completions)
+    val contents = try IO.read(configFile)
+    catch { case _: IOException => "" }
+    if (!contents.contains(export)) {
+      term.printStream.print(s"Add $bin to PATH in $configFile? y/n (y default): ")
+      term.printStream.flush()
+      term.inputStream.read() match {
+        case 110 => term.printStream.println()
+        case c =>
+          term.printStream.println(c.toChar)
+          // put the export at the bottom so that the ~/.sbt/1.0/bin/sbtn is least preferred
+          // but still on the path
+          IO.write(configFile, s"$contents\n$export")
+      }
+    }
+    val newContents = try IO.read(configFile)
+    catch { case _: IOException => "" }
+    if (!newContents.contains(sourceCompletions)) {
+      term.printStream.print(s"Add tab completions to $configFile? y/n (y default): ")
+      term.printStream.flush()
+      term.inputStream.read() match {
+        case 110 =>
+        case c =>
+          term.printStream.println(c.toChar)
+          if (shell == "zsh") {
+            // delete the .zcompdump file because it can prevent the new completions from
+            // being recognized
+            Files.deleteIfExists((userHome / ".zcompdump").toPath)
+            // put the completions at the top because it is effectively just a source
+            // so the order in the file doesn't really matter but we want to make sure
+            // that we set fpath before any autoload command in zsh
+            IO.write(configFile, s"$sourceCompletions\n$newContents")
+          } else {
+            IO.write(configFile, s"$newContents\n$sourceCompletions")
+          }
+      }
+      term.printStream.println()
+    }
+  }
+  private[this] def setupBash(baseDirectory: Path, term: Terminal): Unit =
+    setupShell(
+      "bash",
+      baseDirectory,
+      term,
+      userHome / ".bashrc",
+      bin => s"export PATH=$$PATH:$bin",
+      completions => s"source $completions/sbtn.bash"
+    )
+  private[this] def setupZsh(baseDirectory: Path, term: Terminal): Unit = {
+    val comp = (completions: Path) => {
+      "# The following two lines were added by the sbt installSbtn task:\n" +
+        s"fpath=($$fpath $completions)\nautoload -Uz compinit; compinit"
+    }
+    setupShell("zsh", baseDirectory, term, userHome / ".zshrc", bin => s"path=($$path $bin)", comp)
+  }
+  private[this] def setupFish(baseDirectory: Path, term: Terminal): Unit = {
+    val comp = (completions: Path) => s"source $completions/sbtn.fish"
+    val path = (bin: Path) => s"set PATH $$PATH $bin"
+    val config = userHome / ".config" / "fish" / "config.fish"
+    setupShell("fish", baseDirectory, term, config, path, comp)
+  }
+  private[this] def setupPowershell(baseDirectory: Path, term: Terminal): Unit = {
+    val comp = (completions: Path) => s""". "$completions\\sbtn.ps1""""
+    val path = (bin: Path) => s"""$$env:Path += ";$bin""""
+    import scala.sys.process._
+    Try(Seq("pwsh", "-Command", "echo $PROFILE").!!).foreach { output =>
+      output.linesIterator.toSeq.headOption.foreach { l =>
+        setupShell("pwsh", baseDirectory, term, new File(l), path, comp)
+      }
+    }
+    Try(Seq("powershell", "-Command", "echo $PROFILE").!!).foreach { output =>
+      output.linesIterator.toSeq.headOption.foreach { l =>
+        setupShell("pwsh", baseDirectory, term, new File(l), path, comp)
+      }
+    }
+  }
+  private[this] val shellCompletions = Map(
+    "bash" -> "sbtn.bash",
+    "fish" -> "sbtn.fish",
+    "powershell" -> "sbtn.ps1",
+    "zsh" -> "_sbtn",
+  )
+}
diff --git a/main/src/main/scala/sbt/internal/InternalDependencies.scala b/main/src/main/scala/sbt/internal/InternalDependencies.scala
new file mode 100644
index 000000000..6808f5e6a
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/InternalDependencies.scala
@@ -0,0 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import sbt.Keys._
+
+private[sbt] object InternalDependencies {
+  def configurations: Def.Initialize[Seq[(ProjectRef, Set[String])]] = Def.setting {
+    val allConfigs = Classpaths.allConfigs(configuration.value).map(_.name).toSet
+    val ref = thisProjectRef.value
+    val projectDependencies = buildDependencies.value.classpath.get(ref).toSeq.flatten
+    val applicableConfigs = allConfigs + "*"
+    ((ref -> allConfigs) +:
+      projectDependencies.flatMap {
+        case ResolvedClasspathDependency(p, rawConfigs) =>
+          val configs = rawConfigs.getOrElse("*->compile").split(";").flatMap { config =>
+            config.split("->") match {
+              case Array(n, c) if applicableConfigs.contains(n) => Some(c)
+              case Array(n) if applicableConfigs.contains(n)    =>
+                // "test" is equivalent to "compile->test"
+                Some("compile")
+              case _ => None
+            }
+          }
+          if (configs.isEmpty) None else Some(p -> configs.toSet)
+      }).distinct
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/IvyConsole.scala b/main/src/main/scala/sbt/internal/IvyConsole.scala
index 3d8eda23e..ec61b1dda 100644
--- a/main/src/main/scala/sbt/internal/IvyConsole.scala
+++ b/main/src/main/scala/sbt/internal/IvyConsole.scala
@@ -1,18 +1,31 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
 import sbt.internal.util.Attributed
 import sbt.util.{ Level, Logger }
 
-import sbt.librarymanagement.{ Configurations, CrossVersion, MavenRepository, ModuleID, Resolver }
+import sbt.librarymanagement.{
+  Configurations,
+  CrossVersion,
+  Disabled,
+  MavenRepository,
+  ModuleID,
+  Resolver
+}
 
 import java.io.File
 import Configurations.Compile
 import Def.Setting
 import Keys._
+import Scope.Global
+import sbt.SlashSyntax0._
 
 import sbt.io.IO
 
@@ -20,7 +33,9 @@ object IvyConsole {
   final val Name = "ivy-console"
   lazy val command =
     Command.command(Name) { state =>
-      val Dependencies(managed, repos, unmanaged) = parseDependencies(state.remainingCommands, state.log)
+      val Dependencies(managed, repos, unmanaged) = parseDependencies(state.remainingCommands map {
+        _.commandLine
+      }, state.log)
       val base = new File(CommandUtil.bootDirectory(state), Name)
       IO.createDirectory(base)
 
@@ -31,20 +46,30 @@ object IvyConsole {
 
       val depSettings: Seq[Setting[_]] = Seq(
         libraryDependencies ++= managed.reverse,
-        resolvers ++= repos.reverse,
-        unmanagedJars in Compile ++= Attributed blankSeq unmanaged.reverse,
-        logLevel in Global := Level.Warn,
-        showSuccess in Global := false
+        resolvers ++= repos.reverse.toVector,
+        Compile / unmanagedJars ++= Attributed blankSeq unmanaged.reverse,
+        Global / logLevel := Level.Warn,
+        Global / showSuccess := false
+      )
+      val append = Load.transformSettings(
+        Load.projectScope(currentRef),
+        currentRef.build,
+        rootProject,
+        depSettings
       )
-      val append = Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, depSettings)
 
       val newStructure = Load.reapply(session.original ++ append, structure)
-      val newState = state.copy(remainingCommands = "console-quick" :: Nil)
+      val newState = state.copy(remainingCommands = Exec(Keys.consoleQuick.key.label, None) :: Nil)
       Project.setProject(session, newStructure, newState)
     }
 
-  final case class Dependencies(managed: Seq[ModuleID], resolvers: Seq[Resolver], unmanaged: Seq[File])
-  def parseDependencies(args: Seq[String], log: Logger): Dependencies = (Dependencies(Nil, Nil, Nil) /: args)(parseArgument(log))
+  final case class Dependencies(
+      managed: Seq[ModuleID],
+      resolvers: Seq[Resolver],
+      unmanaged: Seq[File]
+  )
+  def parseDependencies(args: Seq[String], log: Logger): Dependencies =
+    args.foldLeft(Dependencies(Nil, Nil, Nil))(parseArgument(log))
   def parseArgument(log: Logger)(acc: Dependencies, arg: String): Dependencies =
     arg match {
       case _ if arg contains " at " => acc.copy(resolvers = parseResolver(arg) +: acc.resolvers)
@@ -52,18 +77,17 @@ object IvyConsole {
       case _                        => acc.copy(managed = parseManaged(arg, log) ++ acc.managed)
     }
 
-  private[this] def parseResolver(arg: String): MavenRepository =
-    {
-      val Array(name, url) = arg.split(" at ")
-      new MavenRepository(name.trim, url.trim)
-    }
+  private[this] def parseResolver(arg: String): MavenRepository = {
+    val Array(name, url) = arg.split(" at ")
+    MavenRepository(name.trim, url.trim)
+  }
 
   val DepPattern = """([^%]+)%(%?)([^%]+)%([^%]+)""".r
   def parseManaged(arg: String, log: Logger): Seq[ModuleID] =
     arg match {
       case DepPattern(group, cross, name, version) =>
-        val crossV = if (cross.trim.isEmpty) CrossVersion.Disabled else CrossVersion.binary
-        ModuleID(group.trim, name.trim, version.trim, crossVersion = crossV) :: Nil
+        val crossV = if (cross.trim.isEmpty) Disabled() else CrossVersion.binary
+        ModuleID(group.trim, name.trim, version.trim).withCrossVersion(crossV) :: Nil
       case _ => log.warn("Ignoring invalid argument '" + arg + "'"); Nil
     }
 }
diff --git a/main/src/main/scala/sbt/internal/JarClassPath.scala b/main/src/main/scala/sbt/internal/JarClassPath.scala
new file mode 100644
index 000000000..93ed22690
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/JarClassPath.scala
@@ -0,0 +1,55 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.io.File
+
+import sbt.io.IO
+
+private[internal] object JarClassPath {
+  class Snapshot private[internal] (val file: File, val lastModified: Long)
+      extends Comparable[JarClassPath.Snapshot] {
+    private[this] val _hash = (file.hashCode * 31) ^ java.lang.Long.valueOf(lastModified).hashCode()
+    def this(file: File) = this(file, IO.getModifiedTimeOrZero(file))
+    override def equals(obj: Any): Boolean = obj match {
+      case that: JarClassPath.Snapshot =>
+        this.lastModified == that.lastModified && this.file == that.file
+      case _ => false
+    }
+    override def hashCode: Int = _hash
+    override def compareTo(that: JarClassPath.Snapshot): Int = this.file.compareTo(that.file)
+    override def toString: String =
+      "Snapshot(path = " + file + ", lastModified = " + lastModified + ")"
+  }
+}
+private[internal] final class JarClassPath(val jars: Seq[File]) {
+  private[this] def isSnapshot(file: File): Boolean = file.getName contains "-SNAPSHOT"
+  private val jarSet = jars.toSet
+  val (snapshotJars, regularJars) = jars.partition(isSnapshot)
+  private val snapshots = snapshotJars.map(new JarClassPath.Snapshot(_))
+
+  override def equals(obj: Any): Boolean = obj match {
+    case that: JarClassPath => this.jarSet == that.jarSet
+    case _                  => false
+  }
+  // The memoization is because codacy isn't smart enough to identify that
+  // `override lazy val hashCode: Int = jarSet.hashCode` does actually override hashCode and it
+  // complains that equals and hashCode were not implemented together.
+  private[this] lazy val _hashCode: Int = jarSet.hashCode
+  override def hashCode: Int = _hashCode
+  override def toString: String =
+    s"JarClassPath(\n  jars =\n    ${regularJars.mkString(",\n    ")}" +
+      s",  snapshots =\n${snapshots.mkString(",\n    ")}\n)"
+
+  /*
+   * This is a stricter equality requirement than equals that we can use for cache invalidation.
+   */
+  private[internal] def strictEquals(that: JarClassPath): Boolean = {
+    this.equals(that) && !this.snapshots.view.zip(that.snapshots).exists { case (l, r) => l != r }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/KeyIndex.scala b/main/src/main/scala/sbt/internal/KeyIndex.scala
index 6f8cebdf9..dd803de33 100644
--- a/main/src/main/scala/sbt/internal/KeyIndex.scala
+++ b/main/src/main/scala/sbt/internal/KeyIndex.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
@@ -9,58 +13,126 @@ import Def.ScopedKey
 import sbt.internal.util.complete.DefaultParsers.validID
 import sbt.internal.util.Types.some
 import sbt.internal.util.{ AttributeKey, Relation }
+import sbt.librarymanagement.Configuration
+import scala.annotation.nowarn
 
 object KeyIndex {
   def empty: ExtendableKeyIndex = new KeyIndex0(emptyBuildIndex)
-  def apply(known: Iterable[ScopedKey[_]], projects: Map[URI, Set[String]]): ExtendableKeyIndex =
-    (base(projects) /: known) { _ add _ }
-  def aggregate(known: Iterable[ScopedKey[_]], extra: BuildUtil[_], projects: Map[URI, Set[String]]): ExtendableKeyIndex =
-    (base(projects) /: known) { (index, key) => index.addAggregated(key, extra) }
-  private[this] def base(projects: Map[URI, Set[String]]): ExtendableKeyIndex =
-    {
-      val data = for ((uri, ids) <- projects) yield {
-        val data = ids.map(id => Option(id) -> new ConfigIndex(Map.empty))
-        Option(uri) -> new ProjectIndex(data.toMap)
-      }
-      new KeyIndex0(new BuildIndex(data.toMap))
+
+  @nowarn
+  def apply(
+      known: Iterable[ScopedKey[_]],
+      projects: Map[URI, Set[String]],
+      configurations: Map[String, Seq[Configuration]]
+  ): ExtendableKeyIndex = {
+    import sbt.internal.CompatParColls.Converters._
+    known.par.foldLeft(base(projects, configurations)) { _ add _ }
+  }
+
+  @nowarn
+  def aggregate(
+      known: Iterable[ScopedKey[_]],
+      extra: BuildUtil[_],
+      projects: Map[URI, Set[String]],
+      configurations: Map[String, Seq[Configuration]]
+  ): ExtendableKeyIndex = {
+    /*
+     * Used to be:
+     * (base(projects, configurations) /: known) { (index, key) =>
+     *   index.addAggregated(key, extra)
+     * }
+     * This was a significant serial bottleneck during project loading that we can work around by
+     * computing the aggregations in parallel and then bulk adding them to the index.
+     */
+    import sbt.internal.CompatParColls.Converters._
+    val toAggregate = known.par.map {
+      case key if validID(key.key.label) =>
+        Aggregation.aggregate(key, ScopeMask(), extra, reverse = true)
+      case _ => Nil
     }
+    toAggregate.foldLeft(base(projects, configurations)) {
+      case (index, Nil)  => index
+      case (index, keys) => keys.foldLeft(index)(_ add _)
+    }
+  }
+
+  private[this] def base(
+      projects: Map[URI, Set[String]],
+      configurations: Map[String, Seq[Configuration]]
+  ): ExtendableKeyIndex = {
+    val data = for {
+      (uri, ids) <- projects
+    } yield {
+      val data = ids map { id =>
+        val configs = configurations.getOrElse(id, Seq())
+        val configIdentToName = configs.map(config => config.id -> config.name).toMap
+        Option(id) -> new ConfigIndex(Map.empty, configIdentToName, emptyAKeyIndex)
+      }
+      Option(uri) -> new ProjectIndex(data.toMap)
+    }
+    new KeyIndex0(new BuildIndex(data))
+  }
 
   def combine(indices: Seq[KeyIndex]): KeyIndex = new KeyIndex {
     def buildURIs = concat(_.buildURIs)
     def projects(uri: URI) = concat(_.projects(uri))
     def exists(project: Option[ResolvedReference]): Boolean = indices.exists(_ exists project)
     def configs(proj: Option[ResolvedReference]) = concat(_.configs(proj))
+    private[sbt] def configIdents(proj: Option[ResolvedReference]) = concat(_.configIdents(proj))
+    private[sbt] def fromConfigIdent(proj: Option[ResolvedReference])(configIdent: String): String =
+      indices.find(idx => idx.exists(proj)) match {
+        case Some(idx) => idx.fromConfigIdent(proj)(configIdent)
+        case _         => Scope.unguessConfigIdent(configIdent)
+      }
     def tasks(proj: Option[ResolvedReference], conf: Option[String]) = concat(_.tasks(proj, conf))
-    def tasks(proj: Option[ResolvedReference], conf: Option[String], key: String) = concat(_.tasks(proj, conf, key))
+    def tasks(proj: Option[ResolvedReference], conf: Option[String], key: String) =
+      concat(_.tasks(proj, conf, key))
     def keys(proj: Option[ResolvedReference]) = concat(_.keys(proj))
     def keys(proj: Option[ResolvedReference], conf: Option[String]) = concat(_.keys(proj, conf))
-    def keys(proj: Option[ResolvedReference], conf: Option[String], task: Option[AttributeKey[_]]) = concat(_.keys(proj, conf, task))
+    def keys(proj: Option[ResolvedReference], conf: Option[String], task: Option[AttributeKey[_]]) =
+      concat(_.keys(proj, conf, task))
     def concat[T](f: KeyIndex => Set[T]): Set[T] =
-      (Set.empty[T] /: indices)((s, k) => s ++ f(k))
+      indices.foldLeft(Set.empty[T])((s, k) => s ++ f(k))
   }
   private[sbt] def getOr[A, B](m: Map[A, B], key: A, or: B): B = m.getOrElse(key, or)
   private[sbt] def keySet[A, B](m: Map[Option[A], B]): Set[A] = m.keys.flatten.toSet
   private[sbt] val emptyAKeyIndex = new AKeyIndex(Relation.empty)
-  private[sbt] val emptyConfigIndex = new ConfigIndex(Map.empty)
+  private[sbt] val emptyConfigIndex = new ConfigIndex(Map.empty, Map.empty, emptyAKeyIndex)
   private[sbt] val emptyProjectIndex = new ProjectIndex(Map.empty)
   private[sbt] val emptyBuildIndex = new BuildIndex(Map.empty)
+
 }
 import KeyIndex._
 
 trait KeyIndex {
   // TODO, optimize
-  def isEmpty(proj: Option[ResolvedReference], conf: Option[String]): Boolean = keys(proj, conf).isEmpty
-  def isEmpty(proj: Option[ResolvedReference], conf: Option[String], task: Option[AttributeKey[_]]): Boolean = keys(proj, conf, task).isEmpty
+  def isEmpty(proj: Option[ResolvedReference], conf: Option[String]): Boolean =
+    keys(proj, conf).isEmpty
+  def isEmpty(
+      proj: Option[ResolvedReference],
+      conf: Option[String],
+      task: Option[AttributeKey[_]]
+  ): Boolean = keys(proj, conf, task).isEmpty
 
   def buildURIs: Set[URI]
   def projects(uri: URI): Set[String]
   def exists(project: Option[ResolvedReference]): Boolean
   def configs(proj: Option[ResolvedReference]): Set[String]
   def tasks(proj: Option[ResolvedReference], conf: Option[String]): Set[AttributeKey[_]]
-  def tasks(proj: Option[ResolvedReference], conf: Option[String], key: String): Set[AttributeKey[_]]
+  def tasks(
+      proj: Option[ResolvedReference],
+      conf: Option[String],
+      key: String
+  ): Set[AttributeKey[_]]
   def keys(proj: Option[ResolvedReference]): Set[String]
   def keys(proj: Option[ResolvedReference], conf: Option[String]): Set[String]
-  def keys(proj: Option[ResolvedReference], conf: Option[String], task: Option[AttributeKey[_]]): Set[String]
+  def keys(
+      proj: Option[ResolvedReference],
+      conf: Option[String],
+      task: Option[AttributeKey[_]]
+  ): Set[String]
+  private[sbt] def configIdents(project: Option[ResolvedReference]): Set[String]
+  private[sbt] def fromConfigIdent(proj: Option[ResolvedReference])(configIdent: String): String
 }
 trait ExtendableKeyIndex extends KeyIndex {
   def add(scoped: ScopedKey[_]): ExtendableKeyIndex
@@ -68,26 +140,91 @@ trait ExtendableKeyIndex extends KeyIndex {
 }
 // task axis <-> key
 private[sbt] final class AKeyIndex(val data: Relation[Option[AttributeKey[_]], String]) {
-  def add(task: Option[AttributeKey[_]], key: AttributeKey[_]): AKeyIndex = new AKeyIndex(data + (task, key.label))
+  def add(task: Option[AttributeKey[_]], key: AttributeKey[_]): AKeyIndex =
+    new AKeyIndex(data + (task, key.label))
   def keys(task: Option[AttributeKey[_]]): Set[String] = data.forward(task)
   def allKeys: Set[String] = data._2s.toSet
   def tasks: Set[AttributeKey[_]] = data._1s.flatten.toSet
-  def tasks(key: String): Set[AttributeKey[_]] = data.reverse(key).flatten.toSet
+  def tasks(key: String): Set[AttributeKey[_]] = data.reverse(key).flatten
 }
-private[sbt] final class ConfigIndex(val data: Map[Option[String], AKeyIndex]) {
-  def add(config: Option[String], task: Option[AttributeKey[_]], key: AttributeKey[_]): ConfigIndex =
-    new ConfigIndex(data updated (config, keyIndex(config).add(task, key)))
-  def keyIndex(conf: Option[String]): AKeyIndex = getOr(data, conf, emptyAKeyIndex)
-  def configs: Set[String] = keySet(data)
+
+private[sbt] case class IdentifiableConfig(name: String, ident: Option[String])
+
+private[sbt] case class ConfigData(ident: Option[String], keys: AKeyIndex)
+
+/*
+ * data contains the mapping between a configuration name and its keys.
+ * configIdentToName contains the mapping between a configuration ident and its name
+ * noConfigKeys contains the keys without a configuration.
+ */
+private[sbt] final class ConfigIndex(
+    val data: Map[String, AKeyIndex],
+    val configIdentToName: Map[String, String],
+    val noConfigKeys: AKeyIndex
+) {
+  def add(
+      config: Option[IdentifiableConfig],
+      task: Option[AttributeKey[_]],
+      key: AttributeKey[_]
+  ): ConfigIndex = {
+    config match {
+      case Some(c) => addKeyWithConfig(c, task, key)
+      case None    => addKeyWithoutConfig(task, key)
+    }
+  }
+
+  def addKeyWithConfig(
+      config: IdentifiableConfig,
+      task: Option[AttributeKey[_]],
+      key: AttributeKey[_]
+  ): ConfigIndex = {
+    val keyIndex = data.getOrElse(config.name, emptyAKeyIndex)
+    val configIdent = config.ident.getOrElse(Scope.guessConfigIdent(config.name))
+    new ConfigIndex(
+      data.updated(config.name, keyIndex.add(task, key)),
+      configIdentToName.updated(configIdent, config.name),
+      noConfigKeys
+    )
+  }
+
+  def addKeyWithoutConfig(task: Option[AttributeKey[_]], key: AttributeKey[_]): ConfigIndex = {
+    new ConfigIndex(data, configIdentToName, noConfigKeys.add(task, key))
+  }
+
+  def keyIndex(conf: Option[String]): AKeyIndex = conf match {
+    case Some(c) => data.get(c).getOrElse(emptyAKeyIndex)
+    case None    => noConfigKeys
+  }
+
+  def configs: Set[String] = data.keySet
+  private[sbt] lazy val idents: Set[String] = configIdentToName.keySet
+
+  // guess Configuration name from an identifier.
+  // There's a guessing involved because we could have scoped key that Project is not aware of.
+  private[sbt] def fromConfigIdent(ident: String): String =
+    configIdentToName.getOrElse(ident, Scope.unguessConfigIdent(ident))
 }
+private[sbt] object ConfigIndex
+
 private[sbt] final class ProjectIndex(val data: Map[Option[String], ConfigIndex]) {
-  def add(id: Option[String], config: Option[String], task: Option[AttributeKey[_]], key: AttributeKey[_]): ProjectIndex =
+  def add(
+      id: Option[String],
+      config: Option[IdentifiableConfig],
+      task: Option[AttributeKey[_]],
+      key: AttributeKey[_]
+  ): ProjectIndex =
     new ProjectIndex(data updated (id, confIndex(id).add(config, task, key)))
   def confIndex(id: Option[String]): ConfigIndex = getOr(data, id, emptyConfigIndex)
   def projects: Set[String] = keySet(data)
 }
 private[sbt] final class BuildIndex(val data: Map[Option[URI], ProjectIndex]) {
-  def add(build: Option[URI], project: Option[String], config: Option[String], task: Option[AttributeKey[_]], key: AttributeKey[_]): BuildIndex =
+  def add(
+      build: Option[URI],
+      project: Option[String],
+      config: Option[IdentifiableConfig],
+      task: Option[AttributeKey[_]],
+      key: AttributeKey[_]
+  ): BuildIndex =
     new BuildIndex(data updated (build, projectIndex(build).add(project, config, task, key)))
   def projectIndex(build: Option[URI]): ProjectIndex = getOr(data, build, emptyProjectIndex)
   def builds: Set[URI] = keySet(data)
@@ -95,47 +232,73 @@ private[sbt] final class BuildIndex(val data: Map[Option[URI], ProjectIndex]) {
 private[sbt] final class KeyIndex0(val data: BuildIndex) extends ExtendableKeyIndex {
   def buildURIs: Set[URI] = data.builds
   def projects(uri: URI): Set[String] = data.projectIndex(Some(uri)).projects
-  def exists(proj: Option[ResolvedReference]): Boolean =
-    {
-      val (build, project) = parts(proj)
-      data.data.get(build).flatMap(_.data.get(project)).isDefined
-    }
+  def exists(proj: Option[ResolvedReference]): Boolean = {
+    val (build, project) = parts(proj)
+    data.data.get(build).flatMap(_.data.get(project)).isDefined
+  }
   def configs(project: Option[ResolvedReference]): Set[String] = confIndex(project).configs
-  def tasks(proj: Option[ResolvedReference], conf: Option[String]): Set[AttributeKey[_]] = keyIndex(proj, conf).tasks
-  def tasks(proj: Option[ResolvedReference], conf: Option[String], key: String): Set[AttributeKey[_]] = keyIndex(proj, conf).tasks(key)
-  def keys(proj: Option[ResolvedReference]): Set[String] = (Set.empty[String] /: optConfigs(proj)) { (s, c) => s ++ keys(proj, c) }
-  def keys(proj: Option[ResolvedReference], conf: Option[String]): Set[String] = keyIndex(proj, conf).allKeys
-  def keys(proj: Option[ResolvedReference], conf: Option[String], task: Option[AttributeKey[_]]): Set[String] = keyIndex(proj, conf).keys(task)
+
+  private[sbt] def configIdents(project: Option[ResolvedReference]): Set[String] =
+    confIndex(project).idents
+
+  private[sbt] def fromConfigIdent(proj: Option[ResolvedReference])(configIdent: String): String =
+    confIndex(proj).fromConfigIdent(configIdent)
+
+  def tasks(proj: Option[ResolvedReference], conf: Option[String]): Set[AttributeKey[_]] =
+    keyIndex(proj, conf).tasks
+  def tasks(
+      proj: Option[ResolvedReference],
+      conf: Option[String],
+      key: String
+  ): Set[AttributeKey[_]] = keyIndex(proj, conf).tasks(key)
+  def keys(proj: Option[ResolvedReference]): Set[String] =
+    optConfigs(proj).foldLeft(Set.empty[String]) { (s, c) =>
+      s ++ keys(proj, c)
+    }
+  def keys(proj: Option[ResolvedReference], conf: Option[String]): Set[String] =
+    keyIndex(proj, conf).allKeys
+  def keys(
+      proj: Option[ResolvedReference],
+      conf: Option[String],
+      task: Option[AttributeKey[_]]
+  ): Set[String] = keyIndex(proj, conf).keys(task)
 
   def keyIndex(proj: Option[ResolvedReference], conf: Option[String]): AKeyIndex =
     confIndex(proj).keyIndex(conf)
-  def confIndex(proj: Option[ResolvedReference]): ConfigIndex =
-    {
-      val (build, project) = parts(proj)
-      data.projectIndex(build).confIndex(project)
-    }
+  def confIndex(proj: Option[ResolvedReference]): ConfigIndex = {
+    val (build, project) = parts(proj)
+    data.projectIndex(build).confIndex(project)
+  }
   def parts(proj: Option[Reference]): (Option[URI], Option[String]) =
     proj match {
       case Some(ProjectRef(uri, id)) => (Some(uri), Some(id))
       case Some(BuildRef(uri))       => (Some(uri), None)
       case _                         => (None, None)
     }
-  private[this] def optConfigs(project: Option[ResolvedReference]): Seq[Option[String]] = None +: (configs(project).toSeq map some.fn)
+  private[this] def optConfigs(project: Option[ResolvedReference]): Seq[Option[String]] =
+    None +: (configs(project).toSeq map some.fn)
 
   def addAggregated(scoped: ScopedKey[_], extra: BuildUtil[_]): ExtendableKeyIndex =
     if (validID(scoped.key.label)) {
       val aggregateProjects = Aggregation.aggregate(scoped, ScopeMask(), extra, reverse = true)
-      ((this: ExtendableKeyIndex) /: aggregateProjects)(_ add _)
+      aggregateProjects.foldLeft(this: ExtendableKeyIndex)(_ add _)
     } else
       this
 
   def add(scoped: ScopedKey[_]): ExtendableKeyIndex =
     if (validID(scoped.key.label)) add0(scoped) else this
-  private[this] def add0(scoped: ScopedKey[_]): ExtendableKeyIndex =
-    {
-      val (build, project) = parts(scoped.scope.project.toOption)
-      add1(build, project, scoped.scope.config, scoped.scope.task, scoped.key)
-    }
-  private[this] def add1(uri: Option[URI], id: Option[String], config: ScopeAxis[ConfigKey], task: ScopeAxis[AttributeKey[_]], key: AttributeKey[_]): ExtendableKeyIndex =
-    new KeyIndex0(data.add(uri, id, config.toOption.map(_.name), task.toOption, key))
+  private[this] def add0(scoped: ScopedKey[_]): ExtendableKeyIndex = {
+    val (build, project) = parts(scoped.scope.project.toOption)
+    add1(build, project, scoped.scope.config, scoped.scope.task, scoped.key)
+  }
+  private[this] def add1(
+      uri: Option[URI],
+      id: Option[String],
+      config: ScopeAxis[ConfigKey],
+      task: ScopeAxis[AttributeKey[_]],
+      key: AttributeKey[_]
+  ): ExtendableKeyIndex = {
+    val keyConfig = config.toOption.map(c => IdentifiableConfig(c.name, None))
+    new KeyIndex0(data.add(uri, id, keyConfig, task.toOption, key))
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/LayeredClassLoaders.scala b/main/src/main/scala/sbt/internal/LayeredClassLoaders.scala
new file mode 100644
index 000000000..579b08415
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/LayeredClassLoaders.scala
@@ -0,0 +1,178 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.io.File
+import java.net.URLClassLoader
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+
+import sbt.io.IO
+import sbt.util.Logger
+
+import scala.collection.JavaConverters._
+
+/**
+ * This classloader doesn't load any classes. It is able to create a two layer bundled ClassLoader
+ * that is able to load the full project classpath. The top layer is able to directly load the
+ * project dependencies. The bottom layer can load the full classpath of the run or test task.
+ * If the top layer needs to load a class from the bottom layer via java reflection, we facilitate
+ * that with the `ReverseLookupClassLoader`.
+ *
+ *
+ * This holder caches the ReverseLookupClassLoader, which is the top loader in this hierarchy. The
+ * checkout method will get the RevereLookupClassLoader from the cache or make a new one if
+ * none is available. It will only cache at most one so if multiple concurrently tasks have the
+ * same dependency classpath, multiple instances of ReverseLookupClassLoader will be created for
+ * the classpath. If the ReverseLookupClassLoader makes a lookup in the BottomClassLoader, it
+ * invalidates itself and will not be cached when it is returned.
+ *
+ * The reason it is a ClassLoader even though it can't load any classes is so its
+ * lifecycle -- and therefore the lifecycle of its cache entry -- is managed by the
+ * ClassLoaderCache, allowing the cache entry to be evicted under memory pressure.
+ *
+ * @param classpath the dependency classpath of the managed loader
+ * @param parent the parent ClassLoader of the managed loader
+ */
+private[internal] final class ReverseLookupClassLoaderHolder(
+    val classpath: Seq[File],
+    val parent: ClassLoader,
+    val closeThis: Boolean,
+    val allowZombies: Boolean,
+    val logger: Logger
+) extends URLClassLoader(Array.empty, null) {
+  private[this] val cached: AtomicReference[ReverseLookupClassLoader] = new AtomicReference
+  private[this] val closed = new AtomicBoolean(false)
+  private[this] val urls = classpath.map(_.toURI.toURL).toArray
+
+  /**
+   * Get a classloader. If there is a loader available in the cache, it will use that loader,
+   * otherwise it makes a new classloader.
+   *
+   * @return a ClassLoader
+   */
+  def checkout(fullClasspath: Seq[File], tempDir: File): ClassLoader = {
+    if (closed.get()) {
+      val msg = "Tried to extract class loader from closed ReverseLookupClassLoaderHolder. " +
+        "Try running the `clearCaches` command and re-trying."
+      throw new IllegalStateException(msg)
+    }
+    val reverseLookupClassLoader = cached.getAndSet(null) match {
+      case null => new ReverseLookupClassLoader(urls, parent, closeThis, allowZombies, logger)
+      case c    => c
+    }
+    reverseLookupClassLoader.setup(tempDir)
+    new BottomClassLoader(
+      ReverseLookupClassLoaderHolder.this,
+      fullClasspath.map(_.toURI.toURL).toArray,
+      reverseLookupClassLoader,
+      tempDir,
+      closeThis,
+      allowZombies,
+      logger
+    )
+  }
+
+  private[sbt] def checkin(reverseLookupClassLoader: ReverseLookupClassLoader): Unit = {
+    if (reverseLookupClassLoader.isDirty) reverseLookupClassLoader.close()
+    else {
+      if (closed.get()) reverseLookupClassLoader.close()
+      else
+        cached.getAndSet(reverseLookupClassLoader) match {
+          case null => if (closed.get) reverseLookupClassLoader.close()
+          case c    => c.close()
+        }
+    }
+  }
+
+  override def close(): Unit = {
+    closed.set(true)
+    cached.get() match {
+      case null =>
+      case c    => c.close()
+    }
+  }
+}
+
+/**
+ * This is more or less copied from the NativeCopyLoader in zinc. It differs from the zinc
+ * NativeCopyLoader in that it doesn't allow any explicit mappings and it allows the tempDir
+ * to be dynamically reset. The explicit mappings feature isn't used by sbt. The dynamic
+ * temp directory use case is needed in some layered class loading scenarios.
+ */
+private[internal] trait NativeLoader extends AutoCloseable {
+  private[internal] def setTempDir(file: File): Unit = {}
+}
+private[internal] class NativeLookup extends NativeLoader {
+  private[this] val mapped = new ConcurrentHashMap[String, String]
+  private[this] val searchPaths =
+    sys.props.get("java.library.path").map(IO.parseClasspath).getOrElse(Nil)
+  private[this] val tempDir = new AtomicReference(new File("/dev/null"))
+
+  override def close(): Unit = setTempDir(new File("/dev/null"))
+
+  def findLibrary(name: String): String = synchronized {
+    mapped.get(name) match {
+      case null =>
+        findLibrary0(name) match {
+          case null => null
+          case n =>
+            mapped.put(name, n)
+            NativeLibs.addNativeLib(n)
+            n
+        }
+      case n => n
+    }
+  }
+
+  private[internal] override def setTempDir(file: File): Unit = {
+    deleteNativeLibs()
+    tempDir.set(file)
+  }
+
+  private[this] def deleteNativeLibs(): Unit = {
+    mapped.values().forEach(NativeLibs.delete)
+    mapped.clear()
+  }
+
+  private[this] def findLibrary0(name: String): String = {
+    val mappedName = System.mapLibraryName(name)
+    val search = searchPaths.toStream flatMap relativeLibrary(mappedName)
+    search.headOption.map(copy).orNull
+  }
+
+  private[this] def relativeLibrary(mappedName: String)(base: File): Seq[File] = {
+    val f = new File(base, mappedName)
+    if (f.isFile) f :: Nil else Nil
+  }
+
+  private[this] def copy(f: File): String = {
+    val target = new File(tempDir.get(), f.getName)
+    IO.copyFile(f, target)
+    target.getAbsolutePath
+  }
+}
+
+private[internal] object NativeLibs {
+  private[this] val nativeLibs = new java.util.HashSet[File].asScala
+  ShutdownHooks.add(() => {
+    nativeLibs.foreach(IO.delete)
+    IO.deleteIfEmpty(nativeLibs.map(_.getParentFile).toSet)
+    nativeLibs.clear()
+  })
+  def addNativeLib(lib: String): Unit = {
+    nativeLibs.add(new File(lib))
+    ()
+  }
+  def delete(lib: String): Unit = {
+    val file = new File(lib)
+    nativeLibs.remove(file)
+    file.delete()
+    ()
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/LibraryManagement.scala b/main/src/main/scala/sbt/internal/LibraryManagement.scala
new file mode 100644
index 000000000..e6aafbbba
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/LibraryManagement.scala
@@ -0,0 +1,372 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.File
+import java.util.concurrent.Callable
+
+import sbt.SlashSyntax0._
+import sbt.internal.librarymanagement._
+import sbt.librarymanagement._
+import sbt.librarymanagement.syntax._
+import sbt.util.{ CacheStore, CacheStoreFactory, Level, Logger, Tracked }
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.Project.richInitializeTask
+import sjsonnew.JsonFormat
+import scala.compat.Platform.EOL
+
+private[sbt] object LibraryManagement {
+  implicit val linter: sbt.dsl.LinterLevel.Ignore.type = sbt.dsl.LinterLevel.Ignore
+
+  private type UpdateInputs = (Long, ModuleSettings, UpdateConfiguration)
+
+  def cachedUpdate(
+      lm: DependencyResolution,
+      module: ModuleDescriptor,
+      cacheStoreFactory: CacheStoreFactory,
+      label: String,
+      updateConfig: UpdateConfiguration,
+      transform: UpdateReport => UpdateReport,
+      skip: Boolean,
+      force: Boolean,
+      depsUpdated: Boolean,
+      uwConfig: UnresolvedWarningConfiguration,
+      evictionLevel: Level.Value,
+      versionSchemeOverrides: Seq[ModuleID],
+      assumedEvictionErrorLevel: Level.Value,
+      assumedVersionScheme: String,
+      assumedVersionSchemeJava: String,
+      mavenStyle: Boolean,
+      compatWarning: CompatibilityWarningOptions,
+      includeCallers: Boolean,
+      includeDetails: Boolean,
+      log: Logger
+  ): UpdateReport = {
+
+    /* Resolve the module settings from the inputs. */
+    def resolve: UpdateReport = {
+      import sbt.util.ShowLines._
+
+      log.debug(s"Updating $label...")
+      val reportOrUnresolved: Either[UnresolvedWarning, UpdateReport] =
+        lm.update(module, updateConfig, uwConfig, log)
+      val report = reportOrUnresolved match {
+        case Right(report0) => report0
+        case Left(unresolvedWarning) =>
+          unresolvedWarning.lines.foreach(log.warn(_))
+          throw unresolvedWarning.resolveException
+      }
+      log.debug(s"Done updating $label")
+      val report1 = transform(report)
+
+      // Warn of any eviction and compatibility warnings
+      val evictionError = EvictionError(
+        report1,
+        module,
+        versionSchemeOverrides,
+        assumedVersionScheme,
+        assumedVersionSchemeJava,
+        assumedEvictionErrorLevel
+      )
+      def extraLines = List(
+        "",
+        "this can be overridden using libraryDependencySchemes or evictionErrorLevel"
+      )
+      val errorLines: Seq[String] =
+        (if (evictionError.incompatibleEvictions.isEmpty
+             || evictionLevel != Level.Error) Nil
+         else evictionError.lines) ++
+          (if (evictionError.assumedIncompatibleEvictions.isEmpty
+               || assumedEvictionErrorLevel != Level.Error) Nil
+           else evictionError.toAssumedLines)
+      if (errorLines.nonEmpty) sys.error((errorLines ++ extraLines).mkString(EOL))
+      else {
+        if (evictionError.incompatibleEvictions.isEmpty) ()
+        else evictionError.lines.foreach(log.log(evictionLevel, _: String))
+
+        if (evictionError.assumedIncompatibleEvictions.isEmpty) ()
+        else evictionError.toAssumedLines.foreach(log.log(assumedEvictionErrorLevel, _: String))
+      }
+      CompatibilityWarning.run(compatWarning, module, mavenStyle, log)
+      val report2 = transformDetails(report1, includeCallers, includeDetails)
+      report2
+    }
+
+    /* Check if a update report is still up to date or we must resolve again. */
+    def upToDate(inChanged: Boolean, out: UpdateReport): Boolean = {
+      !force &&
+      !depsUpdated &&
+      !inChanged &&
+      out.allFiles.forall(f => fileUptodate(f, out.stamps, log)) &&
+      fileUptodate(out.cachedDescriptor, out.stamps, log)
+    }
+
+    /* Skip resolve if last output exists, otherwise error. */
+    def skipResolve(cache: CacheStore): UpdateInputs => UpdateReport = {
+      import sbt.librarymanagement.LibraryManagementCodec._
+      Tracked.lastOutput[UpdateInputs, UpdateReport](cache) {
+        case (_, Some(out)) => markAsCached(out)
+        case _ =>
+          sys.error("Skipping update requested, but update has not previously run successfully.")
+      }
+    }
+
+    // Mark UpdateReport#stats as "cached." This is used by the dependers later
+    // to determine whether they now need to run update in the above `upToDate`.
+    def markAsCached(ur: UpdateReport): UpdateReport =
+      ur.withStats(ur.stats.withCached(true))
+
+    def doResolve(cache: CacheStore): UpdateInputs => UpdateReport = {
+      val doCachedResolve = { (inChanged: Boolean, updateInputs: UpdateInputs) =>
+        import sbt.librarymanagement.LibraryManagementCodec._
+        val cachedResolve = Tracked.lastOutput[UpdateInputs, UpdateReport](cache) {
+          case (_, Some(out)) if upToDate(inChanged, out) => markAsCached(out)
+          case pair =>
+            log.debug(s"""not up to date. inChanged = $inChanged, force = $force""")
+            resolve
+        }
+        import scala.util.control.Exception.catching
+        catching(classOf[NullPointerException], classOf[OutOfMemoryError])
+          .withApply { t =>
+            val resolvedAgain = resolve
+            val culprit = t.getClass.getSimpleName
+            log.warn(s"Update task caching failed due to $culprit.")
+            log.warn("Report the following output to sbt:")
+            resolvedAgain.toString.linesIterator.foreach(log.warn(_))
+            log.trace(t)
+            resolvedAgain
+          }
+          .apply(cachedResolve(updateInputs))
+      }
+      import LibraryManagementCodec._
+      Tracked.inputChanged(cacheStoreFactory.make("inputs"))(doCachedResolve)
+    }
+
+    // Get the handler to use and feed it in the inputs
+    // This is lm-engine specific input hashed into Long
+    val extraInputHash = module.extraInputHash
+    val settings = module.moduleSettings
+    val outStore = cacheStoreFactory.make("output")
+    val handler = if (skip && !force) skipResolve(outStore) else doResolve(outStore)
+    // Remove clock for caching purpose
+    val withoutClock = updateConfig.withLogicalClock(LogicalClock.unknown)
+    handler((extraInputHash, settings, withoutClock))
+  }
+
+  private[this] def fileUptodate(file: File, stamps: Map[File, Long], log: Logger): Boolean = {
+    val exists = file.exists
+    // https://github.com/sbt/sbt/issues/5292 warn the user that the file is missing since this indicates
+    // that UpdateReport was persisted but Coursier cache was not.
+    if (!exists) {
+      log.warn(s"${file.getName} no longer exists at $file")
+    }
+    // coursier doesn't populate stamps
+    val timeStampIsSame = stamps
+      .get(file)
+      .forall(_ == IO.getModifiedTimeOrZero(file))
+    exists && timeStampIsSame
+  }
+
+  private[sbt] def transitiveScratch(
+      lm: DependencyResolution,
+      label: String,
+      config: GetClassifiersConfiguration,
+      uwconfig: UnresolvedWarningConfiguration,
+      log: Logger
+  ): Either[UnresolvedWarning, UpdateReport] = {
+    import config.{ updateConfiguration => c, module => mod }
+    import mod.{ id, dependencies => deps, scalaModuleInfo }
+    val base = restrictedCopy(id, true).withName(id.name + "$" + label)
+    val module = lm.moduleDescriptor(base, deps, scalaModuleInfo)
+    val report = lm.update(module, c, uwconfig, log) match {
+      case Right(r) => r
+      case Left(w) =>
+        throw w.resolveException
+    }
+    val newConfig = config
+      .withModule(mod.withDependencies(report.allModules))
+    lm.updateClassifiers(newConfig, uwconfig, Vector(), log)
+  }
+
+  private[sbt] def restrictedCopy(m: ModuleID, confs: Boolean) =
+    ModuleID(m.organization, m.name, m.revision)
+      .withCrossVersion(m.crossVersion)
+      .withExtraAttributes(m.extraAttributes)
+      .withConfigurations(if (confs) m.configurations else None)
+      .branch(m.branchName)
+
+  private[this] def transformDetails(
+      ur: UpdateReport,
+      includeCallers: Boolean,
+      includeDetails: Boolean
+  ): UpdateReport = {
+    val crs0 = ur.configurations
+    val crs1 =
+      if (includeDetails) crs0
+      else crs0 map { _.withDetails(Vector()) }
+    val crs2 =
+      if (includeCallers) crs1
+      else
+        crs1 map { cr =>
+          val mrs0 = cr.modules
+          val mrs1 = mrs0 map { _.withCallers(Vector()) }
+          cr.withModules(mrs1)
+        }
+    ur.withConfigurations(crs2)
+  }
+
+  val moduleIdJsonKeyFormat: sjsonnew.JsonKeyFormat[ModuleID] =
+    new sjsonnew.JsonKeyFormat[ModuleID] {
+      import LibraryManagementCodec._
+      import sjsonnew.support.scalajson.unsafe._
+      val moduleIdFormat: JsonFormat[ModuleID] = implicitly[JsonFormat[ModuleID]]
+      def write(key: ModuleID): String =
+        CompactPrinter(Converter.toJsonUnsafe(key)(moduleIdFormat))
+      def read(key: String): ModuleID =
+        Converter.fromJsonUnsafe[ModuleID](Parser.parseUnsafe(key))(moduleIdFormat)
+    }
+
+  /**
+   * Resolves and optionally retrieves classified artifacts, such as javadocs and sources,
+   * for dependency definitions, transitively.
+   */
+  def updateClassifiersTask: Def.Initialize[Task[UpdateReport]] =
+    (Def.task {
+      import Keys._
+      val s = streams.value
+      val cacheDirectory = streams.value.cacheDirectory
+      val csr = useCoursier.value
+      val lm = dependencyResolution.value
+
+      if (csr) {
+        // following copied from https://github.com/coursier/sbt-coursier/blob/9173406bb399879508aa481fed16efda72f55820/modules/sbt-lm-coursier/src/main/scala/sbt/hack/Foo.scala
+        val isRoot = executionRoots.value contains resolvedScoped.value
+        val shouldForce = isRoot || {
+          forceUpdatePeriod.value match {
+            case None => false
+            case Some(period) =>
+              val fullUpdateOutput = cacheDirectory / "out"
+              val now = System.currentTimeMillis
+              val diff = now - fullUpdateOutput.lastModified()
+              val elapsedDuration = new scala.concurrent.duration.FiniteDuration(
+                diff,
+                java.util.concurrent.TimeUnit.MILLISECONDS
+              )
+              fullUpdateOutput.exists() && elapsedDuration > period
+          }
+        }
+        val state0 = state.value
+        val updateConf = {
+          import UpdateLogging.{ Full, DownloadOnly, Default }
+          val conf = updateConfiguration.value
+          val maybeUpdateLevel = (update / logLevel).?.value
+          val conf1 = maybeUpdateLevel.orElse(state0.get(logLevel.key)) match {
+            case Some(Level.Debug) if conf.logging == Default => conf.withLogging(logging = Full)
+            case Some(_) if conf.logging == Default           => conf.withLogging(logging = DownloadOnly)
+            case _                                            => conf
+          }
+          // logical clock is folded into UpdateConfiguration
+          conf1.withLogicalClock(LogicalClock(state0.hashCode))
+        }
+        cachedUpdate(
+          // LM API
+          lm = lm,
+          // Ivy-free ModuleDescriptor
+          module = ivyModule.value,
+          s.cacheStoreFactory.sub(updateCacheName.value),
+          Reference.display(thisProjectRef.value),
+          updateConf,
+          identity,
+          skip = (update / skip).value,
+          force = shouldForce,
+          depsUpdated = transitiveUpdate.value.exists(!_.stats.cached),
+          uwConfig = (update / unresolvedWarningConfiguration).value,
+          evictionLevel = Level.Debug,
+          versionSchemeOverrides = Nil,
+          assumedEvictionErrorLevel = Level.Debug,
+          assumedVersionScheme = VersionScheme.Always,
+          assumedVersionSchemeJava = VersionScheme.Always,
+          mavenStyle = publishMavenStyle.value,
+          compatWarning = compatibilityWarningOptions.value,
+          includeCallers = false,
+          includeDetails = false,
+          log = s.log
+        )
+      } else {
+        val is = ivySbt.value
+        val mod = classifiersModule.value
+        val updateConfig0 = updateConfiguration.value
+        lazy val updateConfig = updateConfig0
+          .withMetadataDirectory(dependencyCacheDirectory.value)
+          .withArtifactFilter(
+            updateConfig0.artifactFilter.map(af => af.withInverted(!af.inverted))
+          )
+        val app = appConfiguration.value
+        val srcTypes = sourceArtifactTypes.value
+        val docTypes = docArtifactTypes.value
+        val uwConfig = (update / unresolvedWarningConfiguration).value
+        val out = is.withIvy(s.log)(_.getSettings.getDefaultIvyUserDir)
+        withExcludes(out, mod.classifiers, lock(app)) { excludes =>
+          lm.updateClassifiers(
+            GetClassifiersConfiguration(
+              mod,
+              excludes.toVector,
+              updateConfig,
+              srcTypes.toVector,
+              docTypes.toVector
+            ),
+            uwConfig,
+            Vector.empty,
+            s.log
+          ) match {
+            case Left(_)   => ???
+            case Right(ur) => ur
+          }
+        }
+      }
+    } tag (Tags.Update, Tags.Network))
+
+  def withExcludes(out: File, classifiers: Seq[String], lock: xsbti.GlobalLock)(
+      f: Map[ModuleID, Vector[ConfigRef]] => UpdateReport
+  ): UpdateReport = {
+    import sbt.librarymanagement.LibraryManagementCodec._
+    import sbt.util.FileBasedStore
+    val exclName = "exclude_classifiers"
+    val file = out / exclName
+    val store = new FileBasedStore(file)
+    lock(
+      out / (exclName + ".lock"),
+      new Callable[UpdateReport] {
+        def call = {
+          implicit val midJsonKeyFmt: sjsonnew.JsonKeyFormat[ModuleID] = moduleIdJsonKeyFormat
+          val excludes =
+            store
+              .read[Map[ModuleID, Vector[ConfigRef]]](
+                default = Map.empty[ModuleID, Vector[ConfigRef]]
+              )
+          val report = f(excludes)
+          val allExcludes: Map[ModuleID, Vector[ConfigRef]] = excludes ++ IvyActions
+            .extractExcludes(report)
+            .mapValues(cs => cs.map(c => ConfigRef(c)).toVector)
+          store.write(allExcludes)
+          IvyActions
+            .addExcluded(
+              report,
+              classifiers.toVector,
+              allExcludes.mapValues(_.map(_.name).toSet).toMap
+            )
+        }
+      }
+    )
+  }
+
+  def lock(app: xsbti.AppConfiguration): xsbti.GlobalLock =
+    app.provider.scalaProvider.launcher.globalLock
+}
diff --git a/main/src/main/scala/sbt/internal/LintUnused.scala b/main/src/main/scala/sbt/internal/LintUnused.scala
new file mode 100644
index 000000000..af7645504
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/LintUnused.scala
@@ -0,0 +1,181 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import Keys._
+import Def.{ Setting, ScopedKey }
+import sbt.internal.util.{ FilePosition, NoPosition, SourcePosition }
+import java.io.File
+import Scope.Global
+import sbt.SlashSyntax0._
+import sbt.Def._
+
+object LintUnused {
+  lazy val lintSettings: Seq[Setting[_]] = Seq(
+    lintIncludeFilter := {
+      val includes = includeLintKeys.value.map(_.scopedKey.key.label)
+      keyName => includes(keyName)
+    },
+    lintExcludeFilter := {
+      val excludedPrefixes = List("release", "sonatype", "watch", "whitesource")
+      val excludes = excludeLintKeys.value.map(_.scopedKey.key.label)
+      keyName => excludes(keyName) || excludedPrefixes.exists(keyName.startsWith(_))
+    },
+    excludeLintKeys := Set(
+      aggregate,
+      concurrentRestrictions,
+      commands,
+      crossScalaVersions,
+      initialize,
+      lintUnusedKeysOnLoad,
+      onLoad,
+      onLoadMessage,
+      onUnload,
+      sbt.nio.Keys.watchTriggers,
+      serverConnectionType,
+      serverIdleTimeout,
+      shellPrompt,
+    ),
+    includeLintKeys := Set(
+      scalacOptions,
+      javacOptions,
+      javaOptions,
+      incOptions,
+      compileOptions,
+      packageOptions,
+      mainClass,
+      mappings,
+      testOptions,
+      classpathConfiguration,
+      ivyConfiguration,
+    ),
+    Keys.lintUnused := lintUnusedTask.evaluated,
+    Keys.lintUnusedKeysOnLoad := true,
+  )
+
+  // input task version of the lintUnused
+  def lintUnusedTask: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val _ = Def.spaceDelimited().parsed // not used yet
+    val state = Keys.state.value
+    val log = streams.value.log
+    val includeKeys = (Global / lintIncludeFilter).value
+    val excludeKeys = (Global / lintExcludeFilter).value
+    val result = lintUnused(state, includeKeys, excludeKeys)
+    if (result.isEmpty) log.success("ok")
+    else lintResultLines(result) foreach { log.warn(_) }
+  }
+
+  // function version of the lintUnused, based on just state
+  def lintUnusedFunc(s: State): State = {
+    val log = s.log
+    val extracted = Project.extract(s)
+    val includeKeys = extracted.get((Global / lintIncludeFilter))
+    val excludeKeys = extracted.get((Global / lintExcludeFilter))
+    if (extracted.get((Global / lintUnusedKeysOnLoad))) {
+      val result = lintUnused(s, includeKeys, excludeKeys)
+      lintResultLines(result) foreach { log.warn(_) }
+    }
+    s
+  }
+
+  def lintResultLines(
+      result: Seq[(ScopedKey[_], String, Vector[SourcePosition])]
+  ): Vector[String] = {
+    import scala.collection.mutable.ListBuffer
+    val buffer = ListBuffer.empty[String]
+
+    if (result.isEmpty) Vector.empty
+    else {
+      val size = result.size
+      if (size == 1) buffer.append("there's a key that's not used by any other settings/tasks:")
+      else buffer.append(s"there are $size keys that are not used by any other settings/tasks:")
+      buffer.append(" ")
+      result foreach {
+        case (_, str, positions) =>
+          buffer.append(s"* $str")
+          positions foreach {
+            case pos: FilePosition => buffer.append(s"  +- ${pos.path}:${pos.startLine}")
+            case _                 => ()
+          }
+      }
+      buffer.append(" ")
+      buffer.append(
+        "note: a setting might still be used by a command; to exclude a key from this `lintUnused` check"
+      )
+      buffer.append(
+        "either append it to `Global / excludeLintKeys` or call .withRank(KeyRanks.Invisible) on the key"
+      )
+      buffer.toVector
+    }
+  }
+
+  def lintUnused(
+      state: State,
+      includeKeys: String => Boolean,
+      excludeKeys: String => Boolean
+  ): Seq[(ScopedKey[_], String, Vector[SourcePosition])] = {
+    val extracted = Project.extract(state)
+    val structure = extracted.structure
+    val display = Def.showShortKey(None) // extracted.showKey
+    val comp = structure.compiledMap
+    val cMap = Def.flattenLocals(comp)
+    val used: Set[ScopedKey[_]] = cMap.values.flatMap(_.dependencies).toSet
+    val unused: Seq[ScopedKey[_]] = cMap.keys.filter(!used.contains(_)).toSeq
+    val withDefinedAts: Seq[UnusedKey] = unused map { u =>
+      val definingScope = structure.data.definingScope(u.scope, u.key)
+      val definingScoped = definingScope match {
+        case Some(sc) => ScopedKey(sc, u.key)
+        case _        => u
+      }
+      val definedAt = comp.get(definingScoped) match {
+        case Some(c) => definedAtString(c.settings.toVector)
+        case _       => Vector.empty
+      }
+      val data = Project.scopedKeyData(structure, u.scope, u.key)
+      UnusedKey(u, definedAt, data)
+    }
+
+    def isIncludeKey(u: UnusedKey): Boolean = includeKeys(u.scoped.key.label)
+    def isExcludeKey(u: UnusedKey): Boolean = excludeKeys(u.scoped.key.label)
+    def isSettingKey(u: UnusedKey): Boolean = u.data match {
+      case Some(data) => data.settingValue.isDefined
+      case _          => false
+    }
+    def isLocallyDefined(u: UnusedKey): Boolean = u.positions exists {
+      case pos: FilePosition => pos.path.contains(File.separator)
+      case _                 => false
+    }
+    def isInvisible(u: UnusedKey): Boolean = u.scoped.key.rank == KeyRanks.Invisible
+    val unusedKeys = withDefinedAts collect {
+      case u
+          if !isExcludeKey(u) && !isInvisible(u)
+            && (isSettingKey(u) || isIncludeKey(u))
+            && isLocallyDefined(u) =>
+        u
+    }
+    (unusedKeys map { u =>
+      (u.scoped, display.show(u.scoped), u.positions)
+    }).sortBy(_._2)
+  }
+
+  private[this] case class UnusedKey(
+      scoped: ScopedKey[_],
+      positions: Vector[SourcePosition],
+      data: Option[ScopedKeyData[_]]
+  )
+
+  private def definedAtString(settings: Vector[Setting[_]]): Vector[SourcePosition] = {
+    settings flatMap { setting =>
+      setting.pos match {
+        case NoPosition => Vector.empty
+        case pos        => Vector(pos)
+      }
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/Load.scala b/main/src/main/scala/sbt/internal/Load.scala
index 7d8b22e3b..ef6e08149 100755
--- a/main/src/main/scala/sbt/internal/Load.scala
+++ b/main/src/main/scala/sbt/internal/Load.scala
@@ -1,105 +1,186 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
-import sbt.librarymanagement.{ Configuration, Configurations, Resolver, UpdateOptions }
-import sbt.internal.librarymanagement.{ InlineIvyConfiguration, IvyPaths }
-
 import java.io.File
-import java.net.{ URI, URL }
-import compiler.Eval
-import scala.annotation.tailrec
-import collection.mutable
-import sbt.internal.inc.{ Analysis, ClasspathOptionsUtil, ModuleUtilities }
-import sbt.internal.inc.classpath.ClasspathUtilities
-import Project.inScope
-import Def.{ isDummy, ScopedKey, ScopeLocal, Setting }
-import Keys.{ appConfiguration, baseDirectory, configuration, exportedProducts, fullClasspath, fullResolvers, 
-  loadedBuild, onLoadMessage, pluginData, resolvedScoped, sbtPlugin, scalacOptions, streams,
-  thisProject, thisProjectRef, update }
-import tools.nsc.reporters.ConsoleReporter
-import sbt.internal.util.{ Attributed, Eval => Ev, Settings, Show, ~> }
+import java.net.URI
+
+import sbt.BuildPaths._
+import sbt.Def.{ ScopeLocal, ScopedKey, Setting, isDummy }
+import sbt.Keys._
+import sbt.Project.inScope
+import sbt.Scope.GlobalScope
+import sbt.SlashSyntax0._
+import sbt.compiler.Eval
+import sbt.internal.BuildStreams._
+import sbt.internal.inc.classpath.ClasspathUtil
+import sbt.internal.inc.{ ScalaInstance, ZincLmUtil, ZincUtil }
 import sbt.internal.util.Attributed.data
-import Scope.GlobalScope
 import sbt.internal.util.Types.const
-import BuildPaths._
-import BuildStreams._
+import sbt.internal.util.{ Attributed, Settings, ~> }
 import sbt.io.{ GlobFilter, IO, Path }
-import sbt.util.Logger
-import xsbti.compile.Compilers
+import sbt.librarymanagement.ivy.{ InlineIvyConfiguration, IvyDependencyResolution, IvyPaths }
+import sbt.librarymanagement.{ Configuration, Configurations, Resolver }
+import sbt.nio.Settings
+import sbt.util.{ Logger, Show }
+import xsbti.compile.{ ClasspathOptionsUtil, Compilers }
+
+import scala.annotation.{ nowarn, tailrec }
+import scala.collection.mutable
+import scala.tools.nsc.reporters.ConsoleReporter
 
 private[sbt] object Load {
   // note that there is State passed in but not pulled out
-  def defaultLoad(state: State, baseDirectory: File, log: Logger, isPlugin: Boolean = false, topLevelExtras: List[URI] = Nil): (() => Eval, BuildStructure) =
-    {
+  def defaultLoad(
+      state: State,
+      baseDirectory: File,
+      log: Logger,
+      isPlugin: Boolean = false,
+      topLevelExtras: List[URI] = Nil
+  ): (() => Eval, BuildStructure) = {
+    val (base, config) = timed("Load.defaultLoad until apply", log) {
       val globalBase = getGlobalBase(state)
       val base = baseDirectory.getCanonicalFile
       val rawConfig = defaultPreGlobal(state, base, globalBase, log)
-      val config0 = defaultWithGlobal(state, base, rawConfig, globalBase, log)
-      val config = if (isPlugin) enableSbtPlugin(config0) else config0.copy(extraBuilds = topLevelExtras)
-      val result = apply(base, state, config)
-      result
-    }
-  def defaultPreGlobal(state: State, baseDirectory: File, globalBase: File, log: Logger): LoadBuildConfiguration =
-    {
-      val provider = state.configuration.provider
-      val scalaProvider = provider.scalaProvider
-      val stagingDirectory = getStagingDirectory(state, globalBase).getCanonicalFile
-      val loader = getClass.getClassLoader
-      val classpath = Attributed.blankSeq(provider.mainClasspath ++ scalaProvider.jars)
-      val localOnly = false
-      val lock = None
-      val checksums = Nil
-      val ivyPaths = new IvyPaths(baseDirectory, bootIvyHome(state.configuration))
-      val ivyConfiguration = new InlineIvyConfiguration(ivyPaths, Resolver.withDefaultResolvers(Nil),
-        Nil, Nil, localOnly, lock, checksums, None, UpdateOptions(), log)
-      val compilers = Compiler.compilers(ClasspathOptionsUtil.boot, ivyConfiguration)(state.configuration, log)
-      val evalPluginDef = EvaluateTask.evalPluginDef(log) _
-      val delegates = defaultDelegates
-      val pluginMgmt = PluginManagement(loader)
-      val inject = InjectSettings(injectGlobal(state), Nil, const(Nil))
-      LoadBuildConfiguration(stagingDirectory, classpath, loader, compilers, evalPluginDef, delegates,
-        EvaluateTask.injectStreams, pluginMgmt, inject, None, Nil, log)
+      val config0 = defaultWithGlobal(state, base, rawConfig, globalBase)
+      val config =
+        if (isPlugin) enableSbtPlugin(config0) else config0.copy(extraBuilds = topLevelExtras)
+      (base, config)
     }
+    val result = apply(base, state, config)
+    result
+  }
+
+  def defaultPreGlobal(
+      state: State,
+      baseDirectory: File,
+      globalBase: File,
+      log: Logger
+  ): LoadBuildConfiguration = {
+    val app = state.configuration
+    val provider = app.provider
+    val scalaProvider = app.provider.scalaProvider
+    val launcher = scalaProvider.launcher
+    val stagingDirectory = getStagingDirectory(state, globalBase).getCanonicalFile
+    val loader = getClass.getClassLoader
+    val classpath = Attributed.blankSeq(provider.mainClasspath ++ scalaProvider.jars)
+    val ivyConfiguration =
+      InlineIvyConfiguration()
+        .withPaths(IvyPaths(baseDirectory, bootIvyHome(state.configuration)))
+        .withResolvers(Resolver.combineDefaultResolvers(Vector.empty))
+        .withLog(log)
+    val dependencyResolution = IvyDependencyResolution(ivyConfiguration)
+    val si = ScalaInstance(scalaProvider.version, scalaProvider.launcher)
+    val zincDir = BuildPaths.getZincDirectory(state, globalBase)
+    val classpathOptions = ClasspathOptionsUtil.boot
+    val scalac = ZincLmUtil.scalaCompiler(
+      scalaInstance = si,
+      classpathOptions = classpathOptions,
+      globalLock = launcher.globalLock,
+      componentProvider = app.provider.components,
+      secondaryCacheDir = Option(zincDir),
+      dependencyResolution = dependencyResolution,
+      compilerBridgeSource = ZincLmUtil.getDefaultBridgeSourceModule(scalaProvider.version),
+      scalaJarsTarget = zincDir,
+      state.get(BasicKeys.classLoaderCache),
+      log = log
+    )
+    val compilers = ZincUtil.compilers(
+      instance = si,
+      classpathOptions = classpathOptions,
+      javaHome = None,
+      scalac
+    )
+    val evalPluginDef: (BuildStructure, State) => PluginData = EvaluateTask.evalPluginDef _
+    val delegates = defaultDelegates
+    val pluginMgmt = PluginManagement(loader)
+    val inject = InjectSettings(injectGlobal(state), Nil, const(Nil))
+    System.setProperty(
+      "swoval.tmpdir",
+      System.getProperty("swoval.tmpdir", globalBase.getAbsolutePath.toString)
+    )
+    LoadBuildConfiguration(
+      stagingDirectory,
+      classpath,
+      loader,
+      compilers,
+      evalPluginDef,
+      delegates,
+      s => EvaluateTask.injectStreams(s) ++ Settings.inject(s),
+      pluginMgmt,
+      inject,
+      None,
+      Nil,
+      log
+    )
+  }
+
   private def bootIvyHome(app: xsbti.AppConfiguration): Option[File] =
-    try { Option(app.provider.scalaProvider.launcher.ivyHome) }
-    catch { case _: NoSuchMethodError => None }
+    try {
+      Option(app.provider.scalaProvider.launcher.ivyHome)
+    } catch {
+      case _: NoSuchMethodError => None
+    }
+
   def injectGlobal(state: State): Seq[Setting[_]] =
-    (appConfiguration in GlobalScope :== state.configuration) +:
+    ((GlobalScope / appConfiguration) :== state.configuration) +:
       LogManager.settingsLogger(state) +:
       EvaluateTask.injectSettings
-  def defaultWithGlobal(state: State, base: File, rawConfig: LoadBuildConfiguration, globalBase: File, log: Logger): LoadBuildConfiguration =
-    {
-      val globalPluginsDir = getGlobalPluginsDirectory(state, globalBase)
-      val withGlobal = loadGlobal(state, base, globalPluginsDir, rawConfig)
-      val globalSettings = configurationSources(getGlobalSettingsDirectory(state, globalBase))
-      loadGlobalSettings(base, globalBase, globalSettings, withGlobal)
-    }
 
-  def loadGlobalSettings(base: File, globalBase: File, files: Seq[File], config: LoadBuildConfiguration): LoadBuildConfiguration =
-    {
-      val compiled: ClassLoader => Seq[Setting[_]] =
-        if (files.isEmpty || base == globalBase) const(Nil) else buildGlobalSettings(globalBase, files, config)
-      config.copy(injectSettings = config.injectSettings.copy(projectLoaded = compiled))
-    }
-  def buildGlobalSettings(base: File, files: Seq[File], config: LoadBuildConfiguration): ClassLoader => Seq[Setting[_]] =
-    {
-      val eval = mkEval(data(config.globalPluginClasspath), base, defaultEvalOptions)
+  def defaultWithGlobal(
+      state: State,
+      base: File,
+      rawConfig: LoadBuildConfiguration,
+      globalBase: File,
+  ): LoadBuildConfiguration = {
+    val globalPluginsDir = getGlobalPluginsDirectory(state, globalBase)
+    val withGlobal = loadGlobal(state, base, globalPluginsDir, rawConfig)
+    val globalSettings = configurationSources(getGlobalSettingsDirectory(state, globalBase))
+    loadGlobalSettings(base, globalBase, globalSettings, withGlobal)
+  }
 
-      val imports = BuildUtil.baseImports ++
-        config.detectedGlobalPlugins.imports
+  def loadGlobalSettings(
+      base: File,
+      globalBase: File,
+      files: Seq[File],
+      config: LoadBuildConfiguration
+  ): LoadBuildConfiguration = {
+    val compiled: ClassLoader => Seq[Setting[_]] =
+      if (files.isEmpty || base == globalBase) const(Nil)
+      else buildGlobalSettings(globalBase, files, config)
+    config.copy(injectSettings = config.injectSettings.copy(projectLoaded = compiled))
+  }
 
-      loader => {
-        val loaded = EvaluateConfigurations(eval, files, imports)(loader)
-        // TODO - We have a potential leak of config-classes in the global directory right now.
-        // We need to find a way to clean these safely, or at least warn users about
-        // unused class files that could be cleaned when multiple sbt instances are not running.
-        loaded.settings
-      }
+  def buildGlobalSettings(
+      base: File,
+      files: Seq[File],
+      config: LoadBuildConfiguration
+  ): ClassLoader => Seq[Setting[_]] = {
+    val eval = mkEval(data(config.globalPluginClasspath), base, defaultEvalOptions)
+
+    val imports =
+      BuildUtil.baseImports ++ config.detectedGlobalPlugins.imports
+
+    loader => {
+      val loaded = EvaluateConfigurations(eval, files, imports)(loader)
+      // TODO - We have a potential leak of config-classes in the global directory right now.
+      // We need to find a way to clean these safely, or at least warn users about
+      // unused class files that could be cleaned when multiple sbt instances are not running.
+      loaded.settings
     }
-  def loadGlobal(state: State, base: File, global: File, config: LoadBuildConfiguration): LoadBuildConfiguration =
+  }
+  def loadGlobal(
+      state: State,
+      base: File,
+      global: File,
+      config: LoadBuildConfiguration
+  ): LoadBuildConfiguration =
     if (base != global && global.exists) {
       val gp = GlobalPlugin.load(global, state, config)
       config.copy(globalPlugin = Some(gp))
@@ -108,7 +189,8 @@ private[sbt] object Load {
 
   def defaultDelegates: LoadedBuild => Scope => Seq[Scope] = (lb: LoadedBuild) => {
     val rootProject = getRootProject(lb.units)
-    def resolveRef(project: Reference): ResolvedReference = Scope.resolveReference(lb.root, rootProject, project)
+    def resolveRef(project: Reference): ResolvedReference =
+      Scope.resolveReference(lb.root, rootProject, project)
     Scope.delegates(
       lb.allProjectRefs,
       (_: ResolvedProject).configurations.map(c => ConfigKey(c.name)),
@@ -117,19 +199,29 @@ private[sbt] object Load {
       project => projectInherit(lb, project),
       (project, config) => configInherit(lb, project, config, rootProject),
       task => task.extend,
-      (project, extra) => Nil
     )
   }
-  def configInherit(lb: LoadedBuild, ref: ResolvedReference, config: ConfigKey, rootProject: URI => String): Seq[ConfigKey] =
+
+  def configInherit(
+      lb: LoadedBuild,
+      ref: ResolvedReference,
+      config: ConfigKey,
+      rootProject: URI => String
+  ): Seq[ConfigKey] =
     ref match {
       case pr: ProjectRef => configInheritRef(lb, pr, config)
       case BuildRef(uri)  => configInheritRef(lb, ProjectRef(uri, rootProject(uri)), config)
     }
-  def configInheritRef(lb: LoadedBuild, ref: ProjectRef, config: ConfigKey): Seq[ConfigKey] =
-    configurationOpt(lb.units, ref.build, ref.project, config).toList.flatMap(_.extendsConfigs).map(c => ConfigKey(c.name))
 
-  def projectInherit(lb: LoadedBuild, ref: ProjectRef): Seq[ProjectRef] =
-    getProject(lb.units, ref.build, ref.project).delegates
+  def configInheritRef(lb: LoadedBuild, ref: ProjectRef, config: ConfigKey): Seq[ConfigKey] =
+    configurationOpt(lb.units, ref.build, ref.project, config).toList
+      .flatMap(_.extendsConfigs)
+      .map(c => ConfigKey(c.name))
+
+  def projectInherit(lb: LoadedBuild, ref: ProjectRef): Seq[ProjectRef] = {
+    val _ = getProject(lb.units, ref.build, ref.project)
+    Nil
+  }
 
   // build, load, and evaluate all units.
   //  1) Compile all plugin definitions
@@ -140,111 +232,206 @@ private[sbt] object Load {
   //  6) Load all configurations using build definitions and plugins (their classpaths and loaded instances).
   //  7) Combine settings from projects, plugins, and configurations
   //  8) Evaluate settings
-  def apply(rootBase: File, s: State, config: LoadBuildConfiguration): (() => Eval, BuildStructure) =
-    {
-      // load, which includes some resolution, but can't fill in project IDs yet, so follow with full resolution
-      val loaded = resolveProjects(load(rootBase, s, config))
-      val projects = loaded.units
-      lazy val rootEval = lazyEval(loaded.units(loaded.root).unit)
-      val settings = finalTransforms(buildConfigurations(loaded, getRootProject(projects), config.injectSettings))
-      val delegates = config.delegates(loaded)
-      val data = Def.make(settings)(delegates, config.scopeLocal, Project.showLoadingKey(loaded))
-      Project.checkTargets(data) foreach sys.error
-      val index = structureIndex(data, settings, loaded.extra(data), projects)
-      val streams = mkStreams(projects, loaded.root, data)
-      (rootEval, new BuildStructure(projects, loaded.root, settings, data, index, streams, delegates, config.scopeLocal))
+  def apply(
+      rootBase: File,
+      s: State,
+      config: LoadBuildConfiguration
+  ): (() => Eval, BuildStructure) = {
+    val log = config.log
+
+    // load, which includes some resolution, but can't fill in project IDs yet, so follow with full resolution
+    val partBuild = timed("Load.apply: load", log) { load(rootBase, s, config) }
+    val loaded = timed("Load.apply: resolveProjects", log) {
+      resolveProjects(partBuild)
     }
+    val projects = loaded.units
+    lazy val rootEval = lazyEval(loaded.units(loaded.root).unit)
+    val settings = timed("Load.apply: finalTransforms", log) {
+      finalTransforms(buildConfigurations(loaded, getRootProject(projects), config.injectSettings))
+    }
+    val delegates = timed("Load.apply: config.delegates", log) {
+      config.delegates(loaded)
+    }
+    val (cMap, data) = timed("Load.apply: Def.make(settings)...", log) {
+      // When settings.size is 100000, Def.make takes around 10s.
+      if (settings.size > 10000) {
+        log.info(s"resolving key references (${settings.size} settings) ...")
+      }
+      Def.makeWithCompiledMap(settings)(
+        delegates,
+        config.scopeLocal,
+        Project.showLoadingKey(loaded)
+      )
+    }
+    Project.checkTargets(data) foreach sys.error
+    val index = timed("Load.apply: structureIndex", log) {
+      structureIndex(data, settings, loaded.extra(data), projects)
+    }
+    val streams = timed("Load.apply: mkStreams", log) { mkStreams(projects, loaded.root, data) }
+    val bs = new BuildStructure(
+      projects,
+      loaded.root,
+      settings,
+      data,
+      index,
+      streams,
+      delegates,
+      config.scopeLocal,
+      cMap
+    )
+    (rootEval, bs)
+  }
 
   // map dependencies on the special tasks:
   // 1. the scope of 'streams' is the same as the defining key and has the task axis set to the defining key
   // 2. the defining key is stored on constructed tasks: used for error reporting among other things
   // 3. resolvedScoped is replaced with the defining key as a value
   // Note: this must be idempotent.
-  def finalTransforms(ss: Seq[Setting[_]]): Seq[Setting[_]] =
-    {
-      def mapSpecial(to: ScopedKey[_]) = new (ScopedKey ~> ScopedKey) {
-        def apply[T](key: ScopedKey[T]) =
-          if (key.key == streams.key)
-            ScopedKey(Scope.fillTaskAxis(Scope.replaceThis(to.scope)(key.scope), to.key), key.key)
-          else key
-      }
-      def setDefining[T] = (key: ScopedKey[T], value: T) => value match {
-        case tk: Task[t]      => setDefinitionKey(tk, key).asInstanceOf[T]
-        case ik: InputTask[t] => ik.mapTask(tk => setDefinitionKey(tk, key)).asInstanceOf[T]
-        case _                => value
-      }
-      def setResolved(defining: ScopedKey[_]) = new (ScopedKey ~> Option) {
-        def apply[T](key: ScopedKey[T]): Option[T] =
-          key.key match {
-            case resolvedScoped.key => Some(defining.asInstanceOf[T])
-            case _                  => None
-          }
-      }
-      ss.map(s => s mapConstant setResolved(s.key) mapReferenced mapSpecial(s.key) mapInit setDefining)
-    }
+  def finalTransforms(ss: Seq[Setting[_]]): Seq[Setting[_]] = {
+    def mapSpecial(to: ScopedKey[_]) = λ[ScopedKey ~> ScopedKey](
+      (key: ScopedKey[_]) =>
+        if (key.key == streams.key) {
+          ScopedKey(Scope.fillTaskAxis(Scope.replaceThis(to.scope)(key.scope), to.key), key.key)
+        } else key
+    )
+    def setDefining[T] =
+      (key: ScopedKey[T], value: T) =>
+        value match {
+          case tk: Task[t]      => setDefinitionKey(tk, key).asInstanceOf[T]
+          case ik: InputTask[t] => ik.mapTask(tk => setDefinitionKey(tk, key)).asInstanceOf[T]
+          case _                => value
+        }
+    def setResolved(defining: ScopedKey[_]) = λ[ScopedKey ~> Option](
+      (key: ScopedKey[_]) =>
+        key.key match {
+          case resolvedScoped.key => Some(defining.asInstanceOf[A1$])
+          case _                  => None
+        }
+    )
+    ss.map(
+      s => s mapConstant setResolved(s.key) mapReferenced mapSpecial(s.key) mapInit setDefining
+    )
+  }
+
   def setDefinitionKey[T](tk: Task[T], key: ScopedKey[_]): Task[T] =
     if (isDummy(tk)) tk else Task(tk.info.set(Keys.taskDefinitionKey, key), tk.work)
 
-  def structureIndex(data: Settings[Scope], settings: Seq[Setting[_]], extra: KeyIndex => BuildUtil[_], projects: Map[URI, LoadedBuildUnit]): StructureIndex =
-    {
-      val keys = Index.allKeys(settings)
-      val attributeKeys = Index.attributeKeys(data) ++ keys.map(_.key)
-      val scopedKeys = keys ++ data.allKeys((s, k) => ScopedKey(s, k))
-      val projectsMap = projects.mapValues(_.defined.keySet)
-      val keyIndex = KeyIndex(scopedKeys, projectsMap)
-      val aggIndex = KeyIndex.aggregate(scopedKeys, extra(keyIndex), projectsMap)
-      new StructureIndex(Index.stringToKeyMap(attributeKeys), Index.taskToKeyMap(data), Index.triggers(data), keyIndex, aggIndex)
-    }
+  def structureIndex(
+      data: Settings[Scope],
+      settings: Seq[Setting[_]],
+      extra: KeyIndex => BuildUtil[_],
+      projects: Map[URI, LoadedBuildUnit]
+  ): StructureIndex = {
+    val keys = Index.allKeys(settings)
+    val attributeKeys = Index.attributeKeys(data) ++ keys.map(_.key)
+    val scopedKeys = keys ++ data.allKeys((s, k) => ScopedKey(s, k)).toVector
+    val projectsMap = projects.mapValues(_.defined.keySet).toMap
+    val configsMap: Map[String, Seq[Configuration]] =
+      projects.values.flatMap(bu => bu.defined map { case (k, v) => (k, v.configurations) }).toMap
+    val keyIndex = KeyIndex(scopedKeys.toVector, projectsMap, configsMap)
+    val aggIndex = KeyIndex.aggregate(scopedKeys.toVector, extra(keyIndex), projectsMap, configsMap)
+    new StructureIndex(
+      Index.stringToKeyMap(attributeKeys),
+      Index.taskToKeyMap(data),
+      Index.triggers(data),
+      keyIndex,
+      aggIndex
+    )
+  }
 
   // Reevaluates settings after modifying them.  Does not recompile or reload any build components.
-  def reapply(newSettings: Seq[Setting[_]], structure: BuildStructure)(implicit display: Show[ScopedKey[_]]): BuildStructure =
-    {
-      val transformed = finalTransforms(newSettings)
-      val newData = Def.make(transformed)(structure.delegates, structure.scopeLocal, display)
-      val newIndex = structureIndex(newData, transformed, index => BuildUtil(structure.root, structure.units, index, newData), structure.units)
-      val newStreams = mkStreams(structure.units, structure.root, newData)
-      new BuildStructure(units = structure.units, root = structure.root, settings = transformed, data = newData, index = newIndex, streams = newStreams, delegates = structure.delegates, scopeLocal = structure.scopeLocal)
-    }
+  def reapply(newSettings: Seq[Setting[_]], structure: BuildStructure)(
+      implicit display: Show[ScopedKey[_]]
+  ): BuildStructure = {
+    val transformed = finalTransforms(newSettings)
+    val (cMap, newData) =
+      Def.makeWithCompiledMap(transformed)(structure.delegates, structure.scopeLocal, display)
+    def extra(index: KeyIndex) = BuildUtil(structure.root, structure.units, index, newData)
+    val newIndex = structureIndex(newData, transformed, extra, structure.units)
+    val newStreams = mkStreams(structure.units, structure.root, newData)
+    new BuildStructure(
+      units = structure.units,
+      root = structure.root,
+      settings = transformed,
+      data = newData,
+      index = newIndex,
+      streams = newStreams,
+      delegates = structure.delegates,
+      scopeLocal = structure.scopeLocal,
+      compiledMap = cMap,
+    )
+  }
 
-  def isProjectThis(s: Setting[_]) = s.key.scope.project match { case This | Select(ThisProject) => true; case _ => false }
-  def buildConfigurations(loaded: LoadedBuild, rootProject: URI => String, injectSettings: InjectSettings): Seq[Setting[_]] =
-    {
-      ((loadedBuild in GlobalScope :== loaded) +:
-        transformProjectOnly(loaded.root, rootProject, injectSettings.global)) ++
-        inScope(GlobalScope)(loaded.autos.globalSettings) ++
-        loaded.units.toSeq.flatMap {
-          case (uri, build) =>
-            val pluginBuildSettings = loaded.autos.buildSettings(uri)
-            val projectSettings = build.defined flatMap {
-              case (id, project) =>
-                val ref = ProjectRef(uri, id)
-                val defineConfig: Seq[Setting[_]] = for (c <- project.configurations) yield ((configuration in (ref, ConfigKey(c.name))) :== c)
-                val builtin: Seq[Setting[_]] = (thisProject :== project) +: (thisProjectRef :== ref) +: defineConfig
-                val settings = builtin ++ project.settings ++ injectSettings.project
-                // map This to thisScope, Select(p) to mapRef(uri, rootProject, p)
-                transformSettings(projectScope(ref), uri, rootProject, settings)
-            }
-            val buildScope = Scope(Select(BuildRef(uri)), Global, Global, Global)
-            val buildBase = baseDirectory :== build.localBase
-            val buildSettings = transformSettings(buildScope, uri, rootProject, pluginBuildSettings ++ (buildBase +: build.buildSettings))
-            buildSettings ++ projectSettings
-        }
-    }
+  @deprecated("No longer used. For binary compatibility", "1.2.1")
+  def reapply(
+      newSettings: Seq[Setting[_]],
+      structure: BuildStructure,
+      log: Logger
+  )(implicit display: Show[ScopedKey[_]]): BuildStructure = {
+    reapply(newSettings, structure)
+  }
 
-  def transformProjectOnly(uri: URI, rootProject: URI => String, settings: Seq[Setting[_]]): Seq[Setting[_]] =
+  def buildConfigurations(
+      loaded: LoadedBuild,
+      rootProject: URI => String,
+      injectSettings: InjectSettings
+  ): Seq[Setting[_]] = {
+    (((GlobalScope / loadedBuild) :== loaded) +:
+      transformProjectOnly(loaded.root, rootProject, injectSettings.global)) ++
+      inScope(GlobalScope)(loaded.autos.globalSettings) ++
+      loaded.units.toSeq.flatMap {
+        case (uri, build) =>
+          val pluginBuildSettings = loaded.autos.buildSettings(uri)
+          val projectSettings = build.defined flatMap {
+            case (id, project) =>
+              val ref = ProjectRef(uri, id)
+              val defineConfig: Seq[Setting[_]] =
+                for (c <- project.configurations)
+                  yield ((ref / ConfigKey(c.name) / configuration) :== c)
+              val builtin: Seq[Setting[_]] =
+                (thisProject :== project) +: (thisProjectRef :== ref) +: defineConfig
+              val settings = builtin ++ project.settings ++ injectSettings.project
+              // map This to thisScope, Select(p) to mapRef(uri, rootProject, p)
+              transformSettings(projectScope(ref), uri, rootProject, settings)
+          }
+          val buildScope = Scope(Select(BuildRef(uri)), Zero, Zero, Zero)
+          val buildBase = baseDirectory :== build.localBase
+          val settings3 = pluginBuildSettings ++ (buildBase +: build.buildSettings)
+          val buildSettings = transformSettings(buildScope, uri, rootProject, settings3)
+          buildSettings ++ projectSettings
+      }
+  }
+
+  def transformProjectOnly(
+      uri: URI,
+      rootProject: URI => String,
+      settings: Seq[Setting[_]]
+  ): Seq[Setting[_]] =
     Project.transform(Scope.resolveProject(uri, rootProject), settings)
-  def transformSettings(thisScope: Scope, uri: URI, rootProject: URI => String, settings: Seq[Setting[_]]): Seq[Setting[_]] =
-    Project.transform(Scope.resolveScope(thisScope, uri, rootProject), settings)
-  def projectScope(project: Reference): Scope = Scope(Select(project), Global, Global, Global)
 
-  def lazyEval(unit: BuildUnit): () => Eval =
-    {
-      lazy val eval = mkEval(unit)
-      () => eval
-    }
-  def mkEval(unit: BuildUnit): Eval = mkEval(unit.definitions, unit.plugins, unit.plugins.pluginData.scalacOptions)
+  def transformSettings(
+      thisScope: Scope,
+      uri: URI,
+      rootProject: URI => String,
+      settings: Seq[Setting[_]]
+  ): Seq[Setting[_]] = {
+    val transformed = Project.transform(Scope.resolveScope(thisScope, uri, rootProject), settings)
+    Settings.inject(transformed)
+  }
+
+  def projectScope(project: Reference): Scope = Scope(Select(project), Zero, Zero, Zero)
+
+  def lazyEval(unit: BuildUnit): () => Eval = {
+    lazy val eval = mkEval(unit)
+    () => eval
+  }
+
+  def mkEval(unit: BuildUnit): Eval =
+    mkEval(unit.definitions, unit.plugins, unit.plugins.pluginData.scalacOptions)
+
   def mkEval(defs: LoadedDefinitions, plugs: LoadedPlugins, options: Seq[String]): Eval =
     mkEval(defs.target ++ plugs.classpath, defs.base, options)
+
   def mkEval(classpath: Seq[File], base: File, options: Seq[String]): Eval =
     new Eval(options, classpath, s => new ConsoleReporter(s), Some(evalOutputDirectory(base)))
 
@@ -271,30 +458,46 @@ private[sbt] object Load {
     }
   }
 
-  @deprecated("This method is no longer used", "0.13.6")
-  def configurations(srcs: Seq[File], eval: () => Eval, imports: Seq[String]): ClassLoader => LoadedSbtFile =
-    if (srcs.isEmpty) const(LoadedSbtFile.empty)
-    else EvaluateConfigurations(eval(), srcs, imports)
+  /** Loads the unresolved build units and computes its settings.
+   *
+   * @param root The root directory.
+   * @param s The given state.
+   * @param config The configuration of the loaded build.
+   * @return An instance of [[PartBuild]] with all the unresolved build units.
+   */
+  def load(root: File, s: State, config: LoadBuildConfiguration): PartBuild = {
+    val manager = config.pluginManagement.shift
+    // Forced type ascription, otherwise scalac does not compile it
+    val newConfig: LoadBuildConfiguration =
+      config.copy(pluginManagement = manager, extraBuilds = Nil)
+    val loader = builtinLoader(s, newConfig)
+    loadURI(IO.directoryURI(root), loader, config.extraBuilds.toList)
+  }
+
+  /** Creates a loader for the build.
+   *
+   * @param s The given state.
+   * @param config The configuration of the loaded build.
+   * @return A [[BuildLoader]].
+   */
+  def builtinLoader(s: State, config: LoadBuildConfiguration): BuildLoader = {
+    val fail = (uri: URI) => sys.error("Invalid build URI (no handler available): " + uri)
+    val resolver = (info: BuildLoader.ResolveInfo) => RetrieveUnit(info)
+    val build = (info: BuildLoader.BuildInfo) =>
+      Some(() => loadUnit(info.uri, info.base, info.state, info.config))
+    val loader = BuildLoader.componentLoader
+    val components = BuildLoader.components(resolver, build, full = loader)
+    BuildLoader(components, fail, s, config)
+  }
+
+  private def loadURI(uri: URI, loader: BuildLoader, extra: List[URI]): PartBuild = {
+    IO.assertAbsolute(uri)
+    val (referenced, map, newLoaders) = loadAll(uri +: extra, Map.empty, loader, Map.empty)
+    checkAll(referenced, map)
+    val build = new PartBuild(uri, map)
+    newLoaders transformAll build
+  }
 
-  def load(file: File, s: State, config: LoadBuildConfiguration): PartBuild =
-    load(file, builtinLoader(s, config.copy(pluginManagement = config.pluginManagement.shift, extraBuilds = Nil)), config.extraBuilds.toList)
-  def builtinLoader(s: State, config: LoadBuildConfiguration): BuildLoader =
-    {
-      val fail = (uri: URI) => sys.error("Invalid build URI (no handler available): " + uri)
-      val resolver = (info: BuildLoader.ResolveInfo) => RetrieveUnit(info)
-      val build = (info: BuildLoader.BuildInfo) => Some(() => loadUnit(info.uri, info.base, info.state, info.config))
-      val components = BuildLoader.components(resolver, build, full = BuildLoader.componentLoader)
-      BuildLoader(components, fail, s, config)
-    }
-  def load(file: File, loaders: BuildLoader, extra: List[URI]): PartBuild = loadURI(IO.directoryURI(file), loaders, extra)
-  def loadURI(uri: URI, loaders: BuildLoader, extra: List[URI]): PartBuild =
-    {
-      IO.assertAbsolute(uri)
-      val (referenced, map, newLoaders) = loadAll(uri :: extra, Map.empty, loaders, Map.empty)
-      checkAll(referenced, map)
-      val build = new PartBuild(uri, map)
-      newLoaders transformAll build
-    }
   def addOverrides(unit: BuildUnit, loaders: BuildLoader): BuildLoader =
     loaders updatePluginManagement PluginManagement.extractOverrides(unit.plugins.fullClasspath)
 
@@ -302,55 +505,80 @@ private[sbt] object Load {
     unit.definitions.builds.flatMap(_.buildLoaders).toList match {
       case Nil => loaders
       case x :: xs =>
-        val resolver = (x /: xs) { _ | _ }
+        val resolver = xs.foldLeft(x) { _ | _ }
         if (isRoot) loaders.setRoot(resolver) else loaders.addNonRoot(unit.uri, resolver)
     }
 
-  def loaded(unit: BuildUnit): (PartBuildUnit, List[ProjectReference]) =
-    {
-      val defined = projects(unit)
-      val firstDefined = defined match {
-        case Nil            => sys.error("No projects defined in build unit " + unit)
-        case Seq(first, _*) => first
-      }
-
-      // since base directories are resolved at this point (after 'projects'),
-      //   we can compare Files instead of converting to URIs
-      def isRoot(p: Project) = p.base == unit.localBase
-
-      val externals = referenced(defined).toList
-      val explicitRoots = unit.definitions.builds.flatMap(_.rootProject)
-      val projectsInRoot = if (explicitRoots.isEmpty) defined.filter(isRoot) else explicitRoots
-      val rootProjects = if (projectsInRoot.isEmpty) firstDefined :: Nil else projectsInRoot
-      (new PartBuildUnit(unit, defined.map(d => (d.id, d)).toMap, rootProjects.map(_.id), buildSettings(unit)), externals)
-    }
-  def buildSettings(unit: BuildUnit): Seq[Setting[_]] =
-    {
-      val buildScope = GlobalScope.copy(project = Select(BuildRef(unit.uri)))
-      val resolve = Scope.resolveBuildScope(buildScope, unit.uri)
-      Project.transform(resolve, unit.definitions.builds.flatMap(_.settings))
+  def loaded(unit: BuildUnit): (PartBuildUnit, List[ProjectReference]) = {
+    val defined = projects(unit)
+    val firstDefined = defined match {
+      case Nil            => sys.error("No projects defined in build unit " + unit)
+      case Seq(first, _*) => first
+    }
+
+    // since base directories are resolved at this point (after 'projects'),
+    //   we can compare Files instead of converting to URIs
+    def isRoot(p: Project) = p.base == unit.localBase
+
+    val externals = referenced(defined).toList
+    val explicitRoots = unit.definitions.builds.flatMap(_.rootProject)
+    val projectsInRoot = if (explicitRoots.isEmpty) defined.filter(isRoot) else explicitRoots
+    val rootProjects = if (projectsInRoot.isEmpty) firstDefined :: Nil else projectsInRoot
+    val partBuildUnit = new PartBuildUnit(
+      unit,
+      defined.map(d => (d.id, d)).toMap,
+      rootProjects.map(_.id),
+      buildSettings(unit)
+    )
+    (partBuildUnit, externals)
+  }
+
+  def buildSettings(unit: BuildUnit): Seq[Setting[_]] = {
+    val buildScope = GlobalScope.copy(project = Select(BuildRef(unit.uri)))
+    val resolve = Scope.resolveBuildScope(buildScope, unit.uri)
+    Project.transform(resolve, unit.definitions.builds.flatMap(_.settings))
+  }
+
+  @tailrec private def loadAll(
+      bases: List[URI],
+      references: Map[URI, List[ProjectReference]],
+      loaders: BuildLoader,
+      builds: Map[URI, PartBuildUnit]
+  ): (Map[URI, List[ProjectReference]], Map[URI, PartBuildUnit], BuildLoader) = {
+    def loadURI(base: URI, bases: List[URI]) = {
+      val (loadedBuild, refs) = loaded(loaders(base))
+      val uris = refs.flatMap(Reference.uri)
+      val buildUnit = loadedBuild.unit
+      checkBuildBase(buildUnit.localBase)
+      val resolvers = addResolvers(buildUnit, builds.isEmpty, loaders.resetPluginDepth)
+      val updatedLoader = addOverrides(buildUnit, resolvers)
+      val updatedReferences = references.updated(base, refs)
+      val updatedBuilds = builds.updated(base, loadedBuild)
+      val sortedRemaining = uris.reverse_:::(bases).sorted
+      (sortedRemaining, updatedReferences, updatedLoader, updatedBuilds)
     }
 
-  @tailrec def loadAll(bases: List[URI], references: Map[URI, List[ProjectReference]], loaders: BuildLoader, builds: Map[URI, PartBuildUnit]): (Map[URI, List[ProjectReference]], Map[URI, PartBuildUnit], BuildLoader) =
     bases match {
       case b :: bs =>
-        if (builds contains b)
-          loadAll(bs, references, loaders, builds)
+        if (builds contains b) loadAll(bs, references, loaders, builds)
         else {
-          val (loadedBuild, refs) = loaded(loaders(b))
-          checkBuildBase(loadedBuild.unit.localBase)
-          val newLoader = addOverrides(loadedBuild.unit, addResolvers(loadedBuild.unit, builds.isEmpty, loaders.resetPluginDepth))
-          // it is important to keep the load order stable, so we sort the remaining URIs
-          val remainingBases = (refs.flatMap(Reference.uri) reverse_::: bs).sorted
-          loadAll(remainingBases, references.updated(b, refs), newLoader, builds.updated(b, loadedBuild))
+          val (newBases, newReferences, newLoaders, newBuilds) = loadURI(b, bs)
+          loadAll(newBases, newReferences, newLoaders, newBuilds)
         }
       case Nil => (references, builds, loaders)
     }
+  }
+
   def checkProjectBase(buildBase: File, projectBase: File): Unit = {
     checkDirectory(projectBase)
-    assert(buildBase == projectBase || IO.relativize(buildBase, projectBase).isDefined, "Directory " + projectBase + " is not contained in build root " + buildBase)
+    assert(
+      buildBase == projectBase || IO.relativize(buildBase, projectBase).isDefined,
+      s"directory $projectBase is not contained in build root $buildBase"
+    )
   }
+
   def checkBuildBase(base: File) = checkDirectory(base)
+
   def checkDirectory(base: File): Unit = {
     assert(base.isAbsolute, "Not absolute: " + base)
     if (base.isFile)
@@ -358,144 +586,219 @@ private[sbt] object Load {
     else if (!base.exists)
       IO createDirectory base
   }
-  def resolveAll(builds: Map[URI, PartBuildUnit]): Map[URI, LoadedBuildUnit] =
-    {
-      val rootProject = getRootProject(builds)
-      builds map {
-        case (uri, unit) =>
-          (uri, unit.resolveRefs(ref => Scope.resolveProjectRef(uri, rootProject, ref)))
-      }
+
+  def resolveAll(builds: Map[URI, PartBuildUnit]): Map[URI, LoadedBuildUnit] = {
+    val rootProject = getRootProject(builds)
+    builds map {
+      case (uri, unit) =>
+        (uri, unit.resolveRefs(ref => Scope.resolveProjectRef(uri, rootProject, ref)))
     }
-  def checkAll(referenced: Map[URI, List[ProjectReference]], builds: Map[URI, PartBuildUnit]): Unit = {
+  }
+
+  def checkAll(
+      referenced: Map[URI, List[ProjectReference]],
+      builds: Map[URI, PartBuildUnit]
+  ): Unit = {
     val rootProject = getRootProject(builds)
     for ((uri, refs) <- referenced; ref <- refs) {
       val ProjectRef(refURI, refID) = Scope.resolveProjectRef(uri, rootProject, ref)
       val loadedUnit = builds(refURI)
       if (!(loadedUnit.defined contains refID)) {
         val projectIDs = loadedUnit.defined.keys.toSeq.sorted
-        sys.error("No project '" + refID + "' in '" + refURI + "'.\nValid project IDs: " + projectIDs.mkString(", "))
+        sys.error(s"""No project '$refID' in '$refURI'.
+                     |Valid project IDs: ${projectIDs.mkString(", ")}""".stripMargin)
       }
     }
   }
 
-  def resolveBase(against: File): Project => Project =
-    {
-      def resolve(f: File) =
-        {
-          val fResolved = new File(IO.directoryURI(IO.resolve(against, f)))
-          checkProjectBase(against, fResolved)
-          fResolved
-        }
-      p => p.copy(base = resolve(p.base))
+  def resolveBase(against: File): Project => Project = {
+    def resolve(f: File) = {
+      val fResolved = new File(IO.directoryURI(IO.resolve(against, f)))
+      checkProjectBase(against, fResolved)
+      fResolved
     }
-  def resolveProjects(loaded: PartBuild): LoadedBuild =
-    {
-      val rootProject = getRootProject(loaded.units)
-      val units = loaded.units map {
-        case (uri, unit) =>
-          IO.assertAbsolute(uri)
-          (uri, resolveProjects(uri, unit, rootProject))
-      }
-      new LoadedBuild(loaded.root, units)
-    }
-  def resolveProjects(uri: URI, unit: PartBuildUnit, rootProject: URI => String): LoadedBuildUnit =
-    {
-      IO.assertAbsolute(uri)
-      val resolve = (_: Project).resolve(ref => Scope.resolveProjectRef(uri, rootProject, ref))
-      new LoadedBuildUnit(unit.unit, unit.defined mapValues resolve, unit.rootProjects, unit.buildSettings)
-    }
-  def projects(unit: BuildUnit): Seq[Project] =
-    {
-      // we don't have the complete build graph loaded, so we don't have the rootProject function yet.
-      //  Therefore, we use resolveProjectBuild instead of resolveProjectRef.  After all builds are loaded, we can fully resolve ProjectReferences.
-      val resolveBuild = (_: Project).resolveBuild(ref => Scope.resolveProjectBuild(unit.uri, ref))
-      // although the default loader will resolve the project base directory, other loaders may not, so run resolveBase here as well
-      unit.definitions.projects.map(resolveBuild compose resolveBase(unit.localBase))
+    p => p.copy(base = resolve(p.base))
+  }
+
+  def resolveProjects(loaded: PartBuild): LoadedBuild = {
+    val rootProject = getRootProject(loaded.units)
+    val units = loaded.units map {
+      case (uri, unit) =>
+        IO.assertAbsolute(uri)
+        (uri, resolveProjects(uri, unit, rootProject))
     }
+    new LoadedBuild(loaded.root, units)
+  }
+
+  def resolveProjects(
+      uri: URI,
+      unit: PartBuildUnit,
+      rootProject: URI => String
+  ): LoadedBuildUnit = {
+    IO.assertAbsolute(uri)
+    val resolve = (_: Project).resolve(ref => Scope.resolveProjectRef(uri, rootProject, ref))
+    new LoadedBuildUnit(
+      unit.unit,
+      unit.defined.mapValues(resolve).toMap,
+      unit.rootProjects,
+      unit.buildSettings
+    )
+  }
+
+  def projects(unit: BuildUnit): Seq[Project] = {
+    // we don't have the complete build graph loaded, so we don't have the rootProject function yet.
+    //  Therefore, we use resolveProjectBuild instead of resolveProjectRef.  After all builds are loaded, we can fully resolve ProjectReferences.
+    val resolveBuild = (_: Project).resolveBuild(ref => Scope.resolveProjectBuild(unit.uri, ref))
+    // although the default loader will resolve the project base directory, other loaders may not, so run resolveBase here as well
+    unit.definitions.projects.map(resolveBuild compose resolveBase(unit.localBase))
+  }
+
   def getRootProject(map: Map[URI, BuildUnitBase]): URI => String =
     uri => getBuild(map, uri).rootProjects.headOption getOrElse emptyBuild(uri)
-  def getConfiguration(map: Map[URI, LoadedBuildUnit], uri: URI, id: String, conf: ConfigKey): Configuration =
+
+  def getConfiguration(
+      map: Map[URI, LoadedBuildUnit],
+      uri: URI,
+      id: String,
+      conf: ConfigKey
+  ): Configuration =
     configurationOpt(map, uri, id, conf) getOrElse noConfiguration(uri, id, conf.name)
-  def configurationOpt(map: Map[URI, LoadedBuildUnit], uri: URI, id: String, conf: ConfigKey): Option[Configuration] =
+
+  def configurationOpt(
+      map: Map[URI, LoadedBuildUnit],
+      uri: URI,
+      id: String,
+      conf: ConfigKey
+  ): Option[Configuration] =
     getProject(map, uri, id).configurations.find(_.name == conf.name)
 
   def getProject(map: Map[URI, LoadedBuildUnit], uri: URI, id: String): ResolvedProject =
     getBuild(map, uri).defined.getOrElse(id, noProject(uri, id))
-  def getBuild[T](map: Map[URI, T], uri: URI): T =
-    map.getOrElse(uri, noBuild(uri))
 
-  def emptyBuild(uri: URI) = sys.error(s"No root project defined for build unit '$uri'")
-  def noBuild(uri: URI) = sys.error(s"Build unit '$uri' not defined.")
-  def noProject(uri: URI, id: String) = sys.error(s"No project '$id' defined in '$uri'.")
-  def noConfiguration(uri: URI, id: String, conf: String) = sys.error(s"No configuration '$conf' defined in project '$id' in '$uri'")
+  def getBuild[T](map: Map[URI, T], uri: URI): T = map.getOrElse(uri, noBuild(uri))
 
+  def emptyBuild(uri: URI) = sys.error(s"no root project defined for build unit '$uri'")
+  def noBuild(uri: URI) = sys.error(s"build unit '$uri' not defined.")
+  def noProject(uri: URI, id: String) = sys.error(s"no project '$id' defined in '$uri'.")
+
+  def noConfiguration(uri: URI, id: String, conf: String) =
+    sys.error(s"no configuration '$conf' defined in project '$id' in '$uri'")
+
+  // Called from builtinLoader
   def loadUnit(uri: URI, localBase: File, s: State, config: LoadBuildConfiguration): BuildUnit =
-    {
+    timed(s"Load.loadUnit($uri, ...)", config.log) {
+      val log = config.log
       val normBase = localBase.getCanonicalFile
       val defDir = projectStandard(normBase)
 
-      val plugs = plugins(defDir, s, config.copy(pluginManagement = config.pluginManagement.forPlugin))
-      val defsScala = plugs.detected.builds.values
+      val plugs = timed("Load.loadUnit: plugins", log) {
+        plugins(defDir, s, config.copy(pluginManagement = config.pluginManagement.forPlugin))
+      }
+      val defsScala = timed("Load.loadUnit: defsScala", log) {
+        plugs.detected.builds.values
+      }
       val buildLevelExtraProjects = plugs.detected.autoPlugins flatMap { d =>
-        d.value.extraProjects map {_.setProjectOrigin(ProjectOrigin.ExtraProject)}
+        d.value.extraProjects map { _.setProjectOrigin(ProjectOrigin.ExtraProject) }
       }
 
       // NOTE - because we create an eval here, we need a clean-eval later for this URI.
-      lazy val eval = mkEval(plugs.classpath, defDir, plugs.pluginData.scalacOptions)
+      lazy val eval = timed("Load.loadUnit: mkEval", log) {
+        mkEval(plugs.classpath, defDir, plugs.pluginData.scalacOptions)
+      }
       val initialProjects = defsScala.flatMap(b => projectsFromBuild(b, normBase)) ++ buildLevelExtraProjects
 
       val hasRootAlreadyDefined = defsScala.exists(_.rootProject.isDefined)
 
       val memoSettings = new mutable.HashMap[File, LoadedSbtFile]
-      def loadProjects(ps: Seq[Project], createRoot: Boolean) = {
-        val result = loadTransitive(ps, normBase, plugs, () => eval, config.injectSettings, Nil, memoSettings, config.log, createRoot, uri, config.pluginManagement.context, Nil)
-        result
+      def loadProjects(ps: Seq[Project], createRoot: Boolean) =
+        loadTransitive(
+          ps,
+          normBase,
+          plugs,
+          () => eval,
+          config.injectSettings,
+          Nil,
+          memoSettings,
+          config.log,
+          createRoot,
+          uri,
+          config.pluginManagement.context,
+          Nil,
+          s.get(BasicKeys.extraMetaSbtFiles).getOrElse(Nil)
+        )
+      val loadedProjectsRaw = timed("Load.loadUnit: loadedProjectsRaw", log) {
+        loadProjects(initialProjects, !hasRootAlreadyDefined)
       }
-
-      val loadedProjectsRaw = loadProjects(initialProjects, !hasRootAlreadyDefined)
       // TODO - As of sbt 0.13.6 we should always have a default root project from
       //        here on, so the autogenerated build aggregated can be removed from this code. ( I think)
       // We may actually want to move it back here and have different flags in loadTransitive...
-      val hasRoot = loadedProjectsRaw.projects.exists(_.base == normBase) || defsScala.exists(_.rootProject.isDefined)
+      val hasRoot = loadedProjectsRaw.projects.exists(_.base == normBase) || defsScala.exists(
+        _.rootProject.isDefined
+      )
       val (loadedProjects, defaultBuildIfNone, keepClassFiles) =
         if (hasRoot)
-          (loadedProjectsRaw.projects, BuildDef.defaultEmpty, loadedProjectsRaw.generatedConfigClassFiles)
+          (
+            loadedProjectsRaw.projects,
+            BuildDef.defaultEmpty,
+            loadedProjectsRaw.generatedConfigClassFiles
+          )
         else {
           val existingIDs = loadedProjectsRaw.projects.map(_.id)
           val refs = existingIDs.map(id => ProjectRef(uri, id))
           val defaultID = autoID(normBase, config.pluginManagement.context, existingIDs)
           val b = BuildDef.defaultAggregated(defaultID, refs)
-          val defaultProjects = loadProjects(projectsFromBuild(b, normBase), false)
-          (defaultProjects.projects ++ loadedProjectsRaw.projects, b, defaultProjects.generatedConfigClassFiles ++ loadedProjectsRaw.generatedConfigClassFiles)
+          val defaultProjects = timed("Load.loadUnit: defaultProjects", log) {
+            loadProjects(projectsFromBuild(b, normBase), false)
+          }
+          (
+            defaultProjects.projects ++ loadedProjectsRaw.projects,
+            b,
+            defaultProjects.generatedConfigClassFiles ++ loadedProjectsRaw.generatedConfigClassFiles
+          )
         }
       // Now we clean stale class files.
       // TODO - this may cause issues with multiple sbt clients, but that should be deprecated pending sbt-server anyway
-      cleanEvalClasses(defDir, keepClassFiles)
-
+      timed("Load.loadUnit: cleanEvalClasses", log) {
+        cleanEvalClasses(defDir, keepClassFiles)
+      }
       val defs = if (defsScala.isEmpty) defaultBuildIfNone :: Nil else defsScala
       // HERE we pull out the defined vals from memoSettings and unify them all so
       // we can use them later.
       val valDefinitions = memoSettings.values.foldLeft(DefinedSbtValues.empty) { (prev, sbtFile) =>
         prev.zip(sbtFile.definitions)
       }
-      val loadedDefs = new LoadedDefinitions(defDir, Nil, plugs.loader, defs, loadedProjects, plugs.detected.builds.names, valDefinitions)
+      val loadedDefs = new LoadedDefinitions(
+        defDir,
+        Nil,
+        plugs.loader,
+        defs,
+        loadedProjects,
+        plugs.detected.builds.names,
+        valDefinitions
+      )
       new BuildUnit(uri, normBase, loadedDefs, plugs)
     }
 
-  private[this] def autoID(localBase: File, context: PluginManagement.Context, existingIDs: Seq[String]): String =
-    {
-      def normalizeID(f: File) = Project.normalizeProjectID(f.getName) match {
-        case Right(id) => id
-        case Left(msg) => sys.error(autoIDError(f, msg))
-      }
-      def nthParentName(f: File, i: Int): String =
-        if (f eq null) BuildDef.defaultID(localBase) else if (i <= 0) normalizeID(f) else nthParentName(f.getParentFile, i - 1)
-      val pluginDepth = context.pluginProjectDepth
-      val postfix = "-build" * pluginDepth
-      val idBase = if (context.globalPluginProject) "global-plugins" else nthParentName(localBase, pluginDepth)
-      val tryID = idBase + postfix
-      if (existingIDs.contains(tryID)) BuildDef.defaultID(localBase) else tryID
+  private[this] def autoID(
+      localBase: File,
+      context: PluginManagement.Context,
+      existingIDs: Seq[String]
+  ): String = {
+    def normalizeID(f: File) = Project.normalizeProjectID(f.getName) match {
+      case Right(id) => id
+      case Left(msg) => sys.error(autoIDError(f, msg))
     }
+    @tailrec def nthParentName(f: File, i: Int): String =
+      if (f eq null) BuildDef.defaultID(localBase)
+      else if (i <= 0) normalizeID(f)
+      else nthParentName(f.getParentFile, i - 1)
+    val pluginDepth = context.pluginProjectDepth
+    val postfix = "-build" * pluginDepth
+    val idBase =
+      if (context.globalPluginProject) "global-plugins" else nthParentName(localBase, pluginDepth)
+    val tryID = idBase + postfix
+    if (existingIDs.contains(tryID)) BuildDef.defaultID(localBase) else tryID
+  }
 
   private[this] def autoIDError(base: File, reason: String): String =
     "Could not derive root project ID from directory " + base.getAbsolutePath + ":\n" +
@@ -505,7 +808,11 @@ private[sbt] object Load {
     b.projectDefinitions(base).map(resolveBase(base))
 
   // Lame hackery to keep track of our state.
-  private[this] case class LoadedProjects(projects: Seq[Project], generatedConfigClassFiles: Seq[File])
+  private[this] case class LoadedProjects(
+      projects: Seq[Project],
+      generatedConfigClassFiles: Seq[File]
+  )
+
   /**
    * Loads a new set of projects, including any transitively defined projects underneath this one.
    *
@@ -514,76 +821,116 @@ private[sbt] object Load {
    * 1. The first `Project` instance we encounter defines AddSettings and gets to specify where we pull other settings.
    * 2. Any project manipulation (enable/disablePlugins) is ok to be added in the order we encounter it.
    *
-   * Any further setting is ignored, as even the SettingSet API should be deprecated/removed with sbt 1.0.
+   * Any further setting is ignored.
    *
    * Note:  Lots of internal details in here that shouldn't be otherwise exposed.
    *
-   * @param newProjects    A sequence of projects we have not yet loaded, but will try to.  Must not be Nil
+   * TODO - We want to attach the known (at this time) vals/lazy vals defined in each project's
+   *        build.sbt to that project so we can later use this for the `set` command.
+   *
+   * @param newProjects    A sequence of projects we have not yet loaded, but will try to.
    * @param buildBase      The `baseDirectory` for the entire build.
    * @param plugins        A misnomer, this is actually the compiled BuildDefinition (classpath and such) for this project.
    * @param eval           A mechanism of generating an "Eval" which can compile scala code for us.
    * @param injectSettings Settings we need to inject into projects.
-   * @param acc            An accumulated list of loaded projects.  TODO - how do these differ from newProjects?
+   * @param acc            An accumulated list of loaded projects, originally in newProjects.
    * @param memoSettings   A recording of all sbt files that have been loaded so far.
    * @param log            The logger used for this project.
-   * @param makeOrDiscoverRoot  True if we should autogenerate a root project.
+   * @param makeOrDiscoverRoot  True if we should auto-generate a root project.
    * @param buildUri            The URI of the build this is loading
    * @param context             The plugin management context for autogenerated IDs.
-   *
+   * @param generatedConfigClassFiles
+   * @param extraSbtFiles
    * @return The completely resolved/updated sequence of projects defined, with all settings expanded.
-   *
-   * TODO - We want to attach the known (at this time) vals/lazy vals defined in each project's
-   *        build.sbt to that project so we can later use this for the `set` command.
    */
   private[this] def loadTransitive(
-    newProjects: Seq[Project],
-    buildBase: File,
-    plugins: LoadedPlugins,
-    eval: () => Eval,
-    injectSettings: InjectSettings,
-    acc: Seq[Project],
-    memoSettings: mutable.Map[File, LoadedSbtFile],
-    log: Logger,
-    makeOrDiscoverRoot: Boolean,
-    buildUri: URI,
-    context: PluginManagement.Context,
-    generatedConfigClassFiles: Seq[File]): LoadedProjects =
-    {
+      newProjects: Seq[Project],
+      buildBase: File,
+      plugins: LoadedPlugins,
+      eval: () => Eval,
+      injectSettings: InjectSettings,
+      acc: Seq[Project],
+      memoSettings: mutable.Map[File, LoadedSbtFile],
+      log: Logger,
+      makeOrDiscoverRoot: Boolean,
+      buildUri: URI,
+      context: PluginManagement.Context,
+      generatedConfigClassFiles: Seq[File],
+      extraSbtFiles: Seq[File]
+  ): LoadedProjects =
+    /*timed(s"Load.loadTransitive(${ newProjects.map(_.id) })", log)*/ {
+
+      def load(newProjects: Seq[Project], acc: Seq[Project], generated: Seq[File]) = {
+        loadTransitive(
+          newProjects,
+          buildBase,
+          plugins,
+          eval,
+          injectSettings,
+          acc,
+          memoSettings,
+          log,
+          false,
+          buildUri,
+          context,
+          generated,
+          Nil
+        )
+      }
+
       // load all relevant configuration files (.sbt, as .scala already exists at this point)
-      def discover(auto: AddSettings, base: File): DiscoveredProjects =
-        discoverProjects(auto, base, plugins, eval, memoSettings)
+      def discover(base: File): DiscoveredProjects = {
+        val auto =
+          if (base == buildBase) AddSettings.allDefaults
+          else AddSettings.defaultSbtFiles
+
+        val extraFiles =
+          if (base == buildBase && isMetaBuildContext(context)) extraSbtFiles
+          else Nil
+        discoverProjects(auto, base, extraFiles, plugins, eval, memoSettings)
+      }
+
       // Step two:
       // a. Apply all the project manipulations from .sbt files in order
       // b. Deduce the auto plugins for the project
       // c. Finalize a project with all its settings/configuration.
-      def finalizeProject(p: Project, files: Seq[File], expand: Boolean): (Project, Seq[Project]) = {
-        val configFiles = files flatMap { f => memoSettings.get(f) }
-        val p1: Project =
-          configFiles.flatMap(_.manipulations).foldLeft(p) { (prev, t) =>
-            t(prev)
-          }
+      def finalizeProject(
+          p: Project,
+          files: Seq[File],
+          extraFiles: Seq[File],
+          expand: Boolean
+      ): (Project, Seq[Project]) = {
+        val configFiles = files.flatMap(f => memoSettings.get(f))
+        val p1: Project = Function.chain(configFiles.flatMap(_.manipulations))(p)
         val autoPlugins: Seq[AutoPlugin] =
           try plugins.detected.deducePluginsFromProject(p1, log)
           catch { case e: AutoPluginException => throw translateAutoPluginException(e, p) }
-        val p2 = this.resolveProject(p1, autoPlugins, plugins, injectSettings, memoSettings, log)
+        val p2 =
+          resolveProject(p1, autoPlugins, plugins, injectSettings, memoSettings, extraFiles, log)
         val projectLevelExtra =
-          if (expand) autoPlugins flatMap { _.derivedProjects(p2) map {_.setProjectOrigin(ProjectOrigin.DerivedProject)} }
-          else Nil
+          if (expand) {
+            autoPlugins.flatMap(
+              _.derivedProjects(p2).map(_.setProjectOrigin(ProjectOrigin.DerivedProject))
+            )
+          } else Nil
         (p2, projectLevelExtra)
       }
+
       // Discover any new project definition for the base directory of this project, and load all settings.
-      // Also return any newly discovered project instances.
-      def discoverAndLoad(p: Project): (Project, Seq[Project], Seq[File]) = {
-        val (root, discovered, files, generated) = discover(p.auto, p.base) match {
-          case DiscoveredProjects(Some(root), rest, files, generated) =>
-            // TODO - We assume here the project defined in a build.sbt WINS because the original was
-            //        a phony.  However, we may want to 'merge' the two, or only do this if the original was a default
-            //        generated project.
-            (root, rest, files, generated)
-          case DiscoveredProjects(None, rest, files, generated) => (p, rest, files, generated)
-        }
-        val (finalRoot, projectLevelExtra) = finalizeProject(root, files, true)
-        (finalRoot, discovered ++ projectLevelExtra, generated)
+      def discoverAndLoad(p: Project, rest: Seq[Project]): LoadedProjects = {
+        val DiscoveredProjects(rootOpt, discovered, files, extraFiles, generated) = discover(
+          p.base
+        )
+
+        // TODO: We assume here the project defined in a build.sbt WINS because the original was a
+        // phony.  However, we may want to 'merge' the two, or only do this if the original was a
+        // default generated project.
+        val root = rootOpt.getOrElse(p)
+        val (finalRoot, projectLevelExtra) = finalizeProject(root, files, extraFiles, true)
+        val newProjects = rest ++ discovered ++ projectLevelExtra
+        val newAcc = acc :+ finalRoot
+        val newGenerated = generated ++ generatedConfigClassFiles
+        load(newProjects, newAcc, newGenerated)
       }
 
       // Load all config files AND finalize the project at the root directory, if it exists.
@@ -591,39 +938,52 @@ private[sbt] object Load {
       newProjects match {
         case Seq(next, rest @ _*) =>
           log.debug(s"[Loading] Loading project ${next.id} @ ${next.base}")
-          val (finished, discovered, generated) = discoverAndLoad(next)
-          loadTransitive(rest ++ discovered, buildBase, plugins, eval, injectSettings, acc :+ finished, memoSettings, log, false, buildUri, context, generated ++ generatedConfigClassFiles)
+          discoverAndLoad(next, rest)
         case Nil if makeOrDiscoverRoot =>
-          log.debug(s"[Loading] Scanning directory ${buildBase}")
-          discover(AddSettings.defaultSbtFiles, buildBase) match {
-            case DiscoveredProjects(Some(root), discovered, files, generated) =>
-              log.debug(s"[Loading] Found root project ${root.id} w/ remaining ${discovered.map(_.id).mkString(",")}")
-              val (finalRoot, projectLevelExtra) = finalizeProject(root, files, true)
-              loadTransitive(discovered ++ projectLevelExtra, buildBase, plugins, eval, injectSettings, finalRoot +: acc, memoSettings, log, false, buildUri, context, generated ++ generatedConfigClassFiles)
-            // Here we need to create a root project...
-            case DiscoveredProjects(None, discovered, files, generated) =>
-              log.debug(s"[Loading] Found non-root projects ${discovered.map(_.id).mkString(",")}")
+          log.debug(s"[Loading] Scanning directory $buildBase")
+          val DiscoveredProjects(rootOpt, discovered, files, extraFiles, generated) = discover(
+            buildBase
+          )
+          val discoveredIdsStr = discovered.map(_.id).mkString(",")
+          val (root, expand, moreProjects, otherProjects) = rootOpt match {
+            case Some(root) =>
+              log.debug(s"[Loading] Found root project ${root.id} w/ remaining $discoveredIdsStr")
+              (root, true, discovered, LoadedProjects(Nil, Nil))
+            case None =>
+              log.debug(s"[Loading] Found non-root projects $discoveredIdsStr")
               // Here we do something interesting... We need to create an aggregate root project
-              val otherProjects = loadTransitive(discovered, buildBase, plugins, eval, injectSettings, acc, memoSettings, log, false, buildUri, context, Nil)
-              val otherGenerated = otherProjects.generatedConfigClassFiles
-              val existingIds = otherProjects.projects map (_.id)
-              val refs = existingIds map (id => ProjectRef(buildUri, id))
-              val defaultID = autoID(buildBase, context, existingIds)
-              val root0 = if (discovered.isEmpty || java.lang.Boolean.getBoolean("sbt.root.ivyplugin")) BuildDef.defaultAggregatedProject(defaultID, buildBase, refs)
-              else BuildDef.generatedRootWithoutIvyPlugin(defaultID, buildBase, refs)
-              val (root, _) = finalizeProject(root0, files, false)
-              val result = root +: (acc ++ otherProjects.projects)
-              log.debug(s"[Loading] Done in ${buildBase}, returning: ${result.map(_.id).mkString("(", ", ", ")")}")
-              LoadedProjects(result, generated ++ otherGenerated ++ generatedConfigClassFiles)
+              val otherProjects = load(discovered, acc, Nil)
+              val root = {
+                val existingIds = otherProjects.projects.map(_.id)
+                val defaultID = autoID(buildBase, context, existingIds)
+                val refs = existingIds.map(id => ProjectRef(buildUri, id))
+                if (discovered.isEmpty || java.lang.Boolean.getBoolean("sbt.root.ivyplugin"))
+                  BuildDef.defaultAggregatedProject(defaultID, buildBase, refs)
+                else BuildDef.generatedRootWithoutIvyPlugin(defaultID, buildBase, refs)
+              }
+              (root, false, Nil, otherProjects)
           }
+          val (finalRoot, projectLevelExtra) =
+            timed(s"Load.loadTransitive: finalizeProject($root)", log) {
+              finalizeProject(root, files, extraFiles, expand)
+            }
+          val newProjects = moreProjects ++ projectLevelExtra
+          val newAcc = finalRoot +: (acc ++ otherProjects.projects)
+          val newGenerated =
+            generated ++ otherProjects.generatedConfigClassFiles ++ generatedConfigClassFiles
+          load(newProjects, newAcc, newGenerated)
         case Nil =>
-          log.debug(s"[Loading] Done in ${buildBase}, returning: ${acc.map(_.id).mkString("(", ", ", ")")}")
+          val projectIds = acc.map(_.id).mkString("(", ", ", ")")
+          log.debug(s"[Loading] Done in $buildBase, returning: $projectIds")
           LoadedProjects(acc, generatedConfigClassFiles)
       }
     }
 
-  private[this] def translateAutoPluginException(e: AutoPluginException, project: Project): AutoPluginException =
-    e.withPrefix(s"Error determining plugins for project '${project.id}' in ${project.base}:\n")
+  private[this] def translateAutoPluginException(
+      e: AutoPluginException,
+      project: Project
+  ): AutoPluginException =
+    e.withPrefix(s"error determining plugins for project '${project.id}' in ${project.base}:\n")
 
   /**
    * Represents the results of flushing out a directory and discovering all the projects underneath it.
@@ -632,67 +992,84 @@ private[sbt] object Load {
    *  @param root The project at "root" directory we were looking, or non if non was defined.
    *  @param nonRoot Any sub-projects discovered from this directory
    *  @param sbtFiles Any sbt file loaded during this discovery (used later to complete the project).
-   *  @param generatedFile Any .class file that was generated when compiling/discovering these projects.
+   *  @param generatedFiles Any .class file that was generated when compiling/discovering these projects.
    */
   private[this] case class DiscoveredProjects(
-    root: Option[Project],
-    nonRoot: Seq[Project],
-    sbtFiles: Seq[File],
-    generatedFiles: Seq[File])
+      root: Option[Project],
+      nonRoot: Seq[Project],
+      sbtFiles: Seq[File],
+      extraSbtFiles: Seq[File],
+      generatedFiles: Seq[File]
+  )
 
   /**
    * This method attempts to resolve/apply all configuration loaded for a project. It is responsible for the following:
    *
    * Ordering all Setting[_]s for the project
    *
-   *
-   * @param transformedProject  The project with manipulation.
+   * @param p  The project with manipulation.
    * @param projectPlugins The deduced list of plugins for the given project.
    * @param loadedPlugins  The project definition (and classloader) of the build.
    * @param globalUserSettings All the settings contributed from the ~/.sbt/<version> directory
    * @param memoSettings A recording of all loaded files (our files should reside in there).  We should need not load any
    *                     sbt file to resolve a project.
+   * @param extraSbtFiles Extra *.sbt files.
    * @param log  A logger to report auto-plugin issues to.
    */
-  private[this] def resolveProject(
-    p: Project,
-    projectPlugins: Seq[AutoPlugin],
-    loadedPlugins: LoadedPlugins,
-    globalUserSettings: InjectSettings,
-    memoSettings: mutable.Map[File, LoadedSbtFile],
-    log: Logger): Project = {
-    import AddSettings._
-    val autoConfigs = projectPlugins.flatMap(_.projectConfigurations)
+  private[sbt] def resolveProject(
+      p: Project,
+      projectPlugins: Seq[AutoPlugin],
+      loadedPlugins: LoadedPlugins,
+      globalUserSettings: InjectSettings,
+      memoSettings: mutable.Map[File, LoadedSbtFile],
+      extraSbtFiles: Seq[File],
+      log: Logger
+  ): Project =
+    timed(s"Load.resolveProject(${p.id})", log) {
+      import AddSettings._
+      val autoConfigs = projectPlugins.flatMap(_.projectConfigurations)
 
-    // 3. Use AddSettings instance to order all Setting[_]s appropriately
-    val allSettings = {
-      // TODO - This mechanism of applying settings could be off... It's in two places now...
-      lazy val defaultSbtFiles = configurationSources(p.base)
-      // Filter the AutoPlugin settings we included based on which ones are
-      // intended in the AddSettings.AutoPlugins filter.
-      def autoPluginSettings(f: AutoPlugins) =
-        projectPlugins.filter(f.include).flatMap(_.projectSettings)
-      // Grab all the settigns we already loaded from sbt files
-      def settings(files: Seq[File]): Seq[Setting[_]] =
-        for {
-          file <- files
-          config <- (memoSettings get file).toSeq
-          setting <- config.settings
-        } yield setting
-      // Expand the AddSettings instance into a real Seq[Setting[_]] we'll use on the project
-      def expandSettings(auto: AddSettings): Seq[Setting[_]] = auto match {
-        case BuildScalaFiles     => p.settings
-        case User                => globalUserSettings.projectLoaded(loadedPlugins.loader)
-        case sf: SbtFiles        => settings(sf.files.map(f => IO.resolve(p.base, f)))
-        case sf: DefaultSbtFiles => settings(defaultSbtFiles.filter(sf.include))
-        case p: AutoPlugins      => autoPluginSettings(p)
-        case q: Sequence         => (Seq.empty[Setting[_]] /: q.sequence) { (b, add) => b ++ expandSettings(add) }
+      // 3. Use AddSettings instance to order all Setting[_]s appropriately
+      val allSettings = {
+        // TODO - This mechanism of applying settings could be off... It's in two places now...
+        lazy val defaultSbtFiles = configurationSources(p.base)
+        lazy val sbtFiles = defaultSbtFiles ++ extraSbtFiles
+        // Filter the AutoPlugin settings we included based on which ones are
+        // intended in the AddSettings.AutoPlugins filter.
+        def autoPluginSettings(f: AutoPlugins) =
+          projectPlugins.filter(f.include).flatMap(_.projectSettings)
+        // Grab all the settings we already loaded from sbt files
+        def settings(files: Seq[File]): Seq[Setting[_]] = {
+          if (files.nonEmpty)
+            log.info(
+              s"${files.map(_.getName).mkString(s"loading settings for project ${p.id} from ", ",", " ...")}"
+            )
+          for {
+            file <- files
+            config <- (memoSettings get file).toSeq
+            setting <- config.settings
+          } yield setting
+        }
+        // Expand the AddSettings instance into a real Seq[Setting[_]] we'll use on the project
+        def expandSettings(auto: AddSettings): Seq[Setting[_]] = auto match {
+          case BuildScalaFiles     => p.settings
+          case User                => globalUserSettings.cachedProjectLoaded(loadedPlugins.loader)
+          case sf: SbtFiles        => settings(sf.files.map(f => IO.resolve(p.base, f)))
+          case sf: DefaultSbtFiles => settings(sbtFiles.filter(sf.include))
+          case p: AutoPlugins      => autoPluginSettings(p)
+          case q: Sequence =>
+            q.sequence.foldLeft(Seq.empty[Setting[_]]) { (b, add) =>
+              b ++ expandSettings(add)
+            }
+        }
+        val auto = AddSettings.allDefaults
+        expandSettings(auto)
       }
-      expandSettings(p.auto)
+      // Finally, a project we can use in buildStructure.
+      p.copy(settings = allSettings)
+        .setAutoPlugins(projectPlugins)
+        .prefixConfigs(autoConfigs: _*)
     }
-    // Finally, a project we can use in buildStructure.
-    p.copy(settingsEval = Ev.later(allSettings)).setAutoPlugins(projectPlugins).prefixConfigs(autoConfigs: _*)
-  }
 
   /**
    * This method attempts to discover all Project/settings it can using the configured AddSettings and project base.
@@ -703,14 +1080,17 @@ private[sbt] object Load {
    * @param memoSettings  A recording of all files we've parsed.
    */
   private[this] def discoverProjects(
-    auto: AddSettings,
-    projectBase: File,
-    loadedPlugins: LoadedPlugins,
-    eval: () => Eval,
-    memoSettings: mutable.Map[File, LoadedSbtFile]): DiscoveredProjects = {
+      auto: AddSettings,
+      projectBase: File,
+      extraSbtFiles: Seq[File],
+      loadedPlugins: LoadedPlugins,
+      eval: () => Eval,
+      memoSettings: mutable.Map[File, LoadedSbtFile]
+  ): DiscoveredProjects = {
 
     // Default sbt files to read, if needed
     lazy val defaultSbtFiles = configurationSources(projectBase)
+    lazy val sbtFiles = defaultSbtFiles ++ extraSbtFiles
 
     // Classloader of the build
     val loader = loadedPlugins.loader
@@ -719,35 +1099,53 @@ private[sbt] object Load {
     // TODO - We should import vals defined in other sbt files here, if we wish to
     // share.  For now, build.sbt files have their own unique namespace.
     def loadSettingsFile(src: File): LoadedSbtFile =
-      EvaluateConfigurations.evaluateSbtFile(eval(), src, IO.readLines(src), loadedPlugins.detected.imports, 0)(loader)
+      EvaluateConfigurations.evaluateSbtFile(
+        eval(),
+        src,
+        IO.readLines(src),
+        loadedPlugins.detected.imports,
+        0
+      )(loader)
     // How to merge SbtFiles we read into one thing
-    def merge(ls: Seq[LoadedSbtFile]): LoadedSbtFile = (LoadedSbtFile.empty /: ls) { _ merge _ }
+    def merge(ls: Seq[LoadedSbtFile]): LoadedSbtFile = ls.foldLeft(LoadedSbtFile.empty) {
+      _ merge _
+    }
     // Loads a given file, or pulls from the cache.
 
-    def memoLoadSettingsFile(src: File): LoadedSbtFile = memoSettings.getOrElse(src, {
-      val lf = loadSettingsFile(src)
-      memoSettings.put(src, lf.clearProjects) // don't load projects twice
-      lf
-    })
+    def memoLoadSettingsFile(src: File): LoadedSbtFile =
+      memoSettings.getOrElse(src, {
+        val lf = loadSettingsFile(src)
+        memoSettings.put(src, lf.clearProjects) // don't load projects twice
+        lf
+      })
 
     // Loads a set of sbt files, sorted by their lexical name (current behavior of sbt).
     def loadFiles(fs: Seq[File]): LoadedSbtFile =
       merge(fs.sortBy(_.getName).map(memoLoadSettingsFile))
 
     // Finds all the build files associated with this project
-    import AddSettings.{ SbtFiles, DefaultSbtFiles, Sequence }
+    import AddSettings.{ DefaultSbtFiles, SbtFiles, Sequence }
     def associatedFiles(auto: AddSettings): Seq[File] = auto match {
       case sf: SbtFiles        => sf.files.map(f => IO.resolve(projectBase, f)).filterNot(_.isHidden)
-      case sf: DefaultSbtFiles => defaultSbtFiles.filter(sf.include).filterNot(_.isHidden)
-      case q: Sequence         => (Seq.empty[File] /: q.sequence) { (b, add) => b ++ associatedFiles(add) }
-      case _                   => Seq.empty
+      case sf: DefaultSbtFiles => sbtFiles.filter(sf.include).filterNot(_.isHidden)
+      case q: Sequence =>
+        q.sequence.foldLeft(Seq.empty[File]) { (b, add) =>
+          b ++ associatedFiles(add)
+        }
+      case _ => Seq.empty
     }
     val rawFiles = associatedFiles(auto)
     val loadedFiles = loadFiles(rawFiles)
     val rawProjects = loadedFiles.projects
     val (root, nonRoot) = rawProjects.partition(_.base == projectBase)
     // TODO - good error message if more than one root project
-    DiscoveredProjects(root.headOption, nonRoot, rawFiles, loadedFiles.generatedFiles)
+    DiscoveredProjects(
+      root.headOption,
+      nonRoot,
+      rawFiles,
+      extraSbtFiles,
+      loadedFiles.generatedFiles
+    )
   }
 
   def globalPluginClasspath(globalPlugin: Option[GlobalPlugin]): Seq[Attributed[File]] =
@@ -755,157 +1153,247 @@ private[sbt] object Load {
       case Some(cp) => cp.data.fullClasspath
       case None     => Nil
     }
+
   /** These are the settings defined when loading a project "meta" build. */
-  val autoPluginSettings: Seq[Setting[_]] = inScope(GlobalScope in LocalRootProject)(Seq(
-    sbtPlugin :== true,
-    pluginData := {
-      val prod = (exportedProducts in Configurations.Runtime).value
-      val cp = (fullClasspath in Configurations.Runtime).value
-      val opts = (scalacOptions in Configurations.Compile).value
-      PluginData(removeEntries(cp, prod), prod, Some(fullResolvers.value), Some(update.value), opts)
-    },
-    onLoadMessage := ("Loading project definition from " + baseDirectory.value)
-  ))
-  private[this] def removeEntries(cp: Seq[Attributed[File]], remove: Seq[Attributed[File]]): Seq[Attributed[File]] =
-    {
-      val files = data(remove).toSet
-      cp filter { f => !files.contains(f.data) }
+  @nowarn
+  val autoPluginSettings: Seq[Setting[_]] = inScope(GlobalScope in LocalRootProject)(
+    Seq(
+      sbtPlugin :== true,
+      isMetaBuild :== true,
+      pluginData := {
+        val prod = (Configurations.Runtime / exportedProducts).value
+        val cp = (Configurations.Runtime / fullClasspath).value
+        val opts = (Configurations.Compile / scalacOptions).value
+        PluginData(
+          removeEntries(cp, prod),
+          prod,
+          Some(fullResolvers.value.toVector),
+          Some(update.value),
+          opts
+        )
+      },
+      scalacOptions += "-Wconf:cat=unused-nowarn:s",
+      onLoadMessage := ("loading project definition from " + baseDirectory.value)
+    )
+  )
+
+  private[this] def removeEntries(
+      cp: Seq[Attributed[File]],
+      remove: Seq[Attributed[File]]
+  ): Seq[Attributed[File]] = {
+    val files = data(remove).toSet
+    cp filter { f =>
+      !files.contains(f.data)
     }
+  }
 
   def enableSbtPlugin(config: LoadBuildConfiguration): LoadBuildConfiguration =
-    config.copy(injectSettings = config.injectSettings.copy(
-      global = autoPluginSettings ++ config.injectSettings.global,
-      project = config.pluginManagement.inject ++ config.injectSettings.project
-    ))
+    config.copy(
+      injectSettings = config.injectSettings.copy(
+        global = autoPluginSettings ++ config.injectSettings.global,
+        project = config.pluginManagement.inject ++ config.injectSettings.project
+      )
+    )
+
   def activateGlobalPlugin(config: LoadBuildConfiguration): LoadBuildConfiguration =
     config.globalPlugin match {
-      case Some(gp) => config.copy(injectSettings = config.injectSettings.copy(project = gp.inject))
-      case None     => config
+      case Some(gp) =>
+        config.copy(injectSettings = config.injectSettings.copy(project = gp.inject))
+      case None => config
     }
-  def plugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins =
-    if (hasDefinition(dir))
+
+  def plugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins = {
+    val context = config.pluginManagement.context
+    val extraSbtFiles: Seq[File] =
+      if (isMetaBuildContext(context)) s.get(BasicKeys.extraMetaSbtFiles).getOrElse(Nil)
+      else Nil
+    if (hasDefinition(dir) || extraSbtFiles.nonEmpty)
       buildPlugins(dir, s, enableSbtPlugin(activateGlobalPlugin(config)))
     else
       noPlugins(dir, config)
+  }
+
+  private def isMetaBuildContext(context: PluginManagement.Context): Boolean =
+    !context.globalPluginProject && context.pluginProjectDepth == 1
+
+  def hasDefinition(dir: File): Boolean = {
+    import sbt.io.syntax._
+    (dir * -GlobFilter(DefaultTargetName)).get.nonEmpty
+  }
 
-  def hasDefinition(dir: File) =
-    {
-      import sbt.io.syntax._
-      (dir * -GlobFilter(DefaultTargetName)).get.nonEmpty
-    }
   def noPlugins(dir: File, config: LoadBuildConfiguration): LoadedPlugins =
-    loadPluginDefinition(dir, config, PluginData(config.globalPluginClasspath, Nil, None, None, Nil))
+    loadPluginDefinition(
+      dir,
+      config,
+      PluginData(config.globalPluginClasspath, Nil, None, None, Nil)
+    )
+
   def buildPlugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins =
     loadPluginDefinition(dir, config, buildPluginDefinition(dir, s, config))
 
-  def loadPluginDefinition(dir: File, config: LoadBuildConfiguration, pluginData: PluginData): LoadedPlugins =
-    {
-      val (definitionClasspath, pluginLoader) = pluginDefinitionLoader(config, pluginData)
-      loadPlugins(dir, pluginData.copy(dependencyClasspath = definitionClasspath), pluginLoader)
-    }
-  def pluginDefinitionLoader(config: LoadBuildConfiguration, dependencyClasspath: Seq[Attributed[File]]): (Seq[Attributed[File]], ClassLoader) =
-    pluginDefinitionLoader(config, dependencyClasspath, Nil)
-  def pluginDefinitionLoader(config: LoadBuildConfiguration, pluginData: PluginData): (Seq[Attributed[File]], ClassLoader) =
-    pluginDefinitionLoader(config, pluginData.dependencyClasspath, pluginData.definitionClasspath)
-  def pluginDefinitionLoader(config: LoadBuildConfiguration, depcp: Seq[Attributed[File]], defcp: Seq[Attributed[File]]): (Seq[Attributed[File]], ClassLoader) =
-    {
-      val definitionClasspath =
-        if (depcp.isEmpty)
-          config.classpath
-        else
-          (depcp ++ config.classpath).distinct
-      val pm = config.pluginManagement
-      // only the dependencyClasspath goes in the common plugin class loader ...
-      def addToLoader() = pm.loader add Path.toURLs(data(depcp))
+  /** Loads the plugins.
+   *
+   * @param dir The base directory for the build.
+   * @param config The configuration for the build.
+   * @param pluginData The data required to load plugins.
+   * @return An instance of the loaded build with plugin information.
+   */
+  def loadPluginDefinition(
+      dir: File,
+      config: LoadBuildConfiguration,
+      pluginData: PluginData
+  ): LoadedPlugins = {
+    val definitionClasspath = pluginData.definitionClasspath
+    val dependencyClasspath = pluginData.dependencyClasspath
+    val pluginLoader: ClassLoader =
+      pluginDefinitionLoader(config, dependencyClasspath, definitionClasspath)
+    val fullDependencyClasspath: Def.Classpath =
+      buildPluginClasspath(config, pluginData.dependencyClasspath)
+    val newData = pluginData.copy(dependencyClasspath = fullDependencyClasspath)
+    loadPlugins(dir, newData, pluginLoader)
+  }
 
-      val parentLoader = if (depcp.isEmpty) pm.initialLoader else { addToLoader(); pm.loader }
-      val pluginLoader =
-        if (defcp.isEmpty)
-          parentLoader
-        else {
-          // ... the build definition classes get their own loader so that they don't conflict with other build definitions (#511)
-          ClasspathUtilities.toLoader(data(defcp), parentLoader)
-        }
-      (definitionClasspath, pluginLoader)
-    }
-  def buildPluginDefinition(dir: File, s: State, config: LoadBuildConfiguration): PluginData =
-    {
-      val (eval, pluginDef) = apply(dir, s, config)
-      val pluginState = Project.setProject(Load.initialSession(pluginDef, eval), pluginDef, s)
-      config.evalPluginDef(Project.structure(pluginState), pluginState)
+  /** Constructs the classpath required to load plugins, the so-called
+   * dependency classpath, from the provided classpath and the current config.
+   *
+   * @param config The configuration that declares classpath entries.
+   * @param depcp The user-defined dependency classpath.
+   * @return A classpath aggregating both without repeated entries.
+   */
+  def buildPluginClasspath(
+      config: LoadBuildConfiguration,
+      depcp: Seq[Attributed[File]]
+  ): Def.Classpath = {
+    if (depcp.isEmpty) config.classpath
+    else (depcp ++ config.classpath).distinct
+  }
+
+  /** Creates a classloader with a hierarchical structure, where the parent
+   * classloads the dependency classpath and the return classloader classloads
+   * the definition classpath.
+   *
+   * @param config The configuration for the whole sbt build.
+   * @param dependencyClasspath The dependency classpath (sbt dependencies).
+   * @param definitionClasspath The definition classpath for build definitions.
+   * @return A classloader ready to class load plugins.
+   */
+  def pluginDefinitionLoader(
+      config: LoadBuildConfiguration,
+      dependencyClasspath: Def.Classpath,
+      definitionClasspath: Def.Classpath
+  ): ClassLoader = {
+    val manager = config.pluginManagement
+    val parentLoader: ClassLoader = {
+      if (dependencyClasspath.isEmpty) manager.initialLoader
+      else {
+        // Load only the dependency classpath for the common plugin classloader
+        val loader = manager.loader
+        loader.add(Path.toURLs(data(dependencyClasspath)))
+        loader
+      }
     }
 
-  @deprecated("Use ModuleUtilities.getCheckedObjects[BuildDef].", "0.13.2")
-  def loadDefinitions(loader: ClassLoader, defs: Seq[String]): Seq[BuildDef] =
-    defs map { definition => loadDefinition(loader, definition) }
+    // Load the definition classpath separately to avoid conflicts, see #511.
+    if (definitionClasspath.isEmpty) parentLoader
+    else ClasspathUtil.toLoader(data(definitionClasspath).map(_.toPath), parentLoader)
+  }
 
-  @deprecated("Use ModuleUtilities.getCheckedObject[BuildDef].", "0.13.2")
-  def loadDefinition(loader: ClassLoader, definition: String): BuildDef =
-    ModuleUtilities.getObject(definition, loader).asInstanceOf[BuildDef]
+  def buildPluginDefinition(dir: File, s: State, config: LoadBuildConfiguration): PluginData = {
+    val (eval, pluginDef) = apply(dir, s, config)
+    val pluginState = Project.setProject(Load.initialSession(pluginDef, eval), pluginDef, s)
+    config.evalPluginDef(Project.structure(pluginState), pluginState)
+  }
 
   def loadPlugins(dir: File, data: PluginData, loader: ClassLoader): LoadedPlugins =
     new LoadedPlugins(dir, data, loader, PluginDiscovery.discoverAll(data, loader))
 
-  @deprecated("Use PluginDiscovery.onClasspath", "0.13.2")
-  def onClasspath(classpath: Seq[File])(url: URL): Boolean =
-    PluginDiscovery.onClasspath(classpath)(url)
-
-  @deprecated("No longer used.", "0.13.2")
-  def findDefinitions(analysis: Analysis): Seq[String] = discover(analysis, "sbt.internal.BuildDef")
-
-  @deprecated("Use PluginDiscovery.sourceModuleNames", "0.13.2")
-  def discover(analysis: Analysis, subclasses: String*): Seq[String] =
-    PluginDiscovery.sourceModuleNames(analysis, subclasses: _*)
-
   def initialSession(structure: BuildStructure, rootEval: () => Eval, s: State): SessionSettings = {
     val session = s get Keys.sessionSettings
     val currentProject = session map (_.currentProject) getOrElse Map.empty
-    val currentBuild = session map (_.currentBuild) filter (uri => structure.units.keys exists (uri ==)) getOrElse structure.root
-    new SessionSettings(currentBuild, projectMap(structure, currentProject), structure.settings, Map.empty, Nil, rootEval)
+    val currentBuild = session map (_.currentBuild) filter (
+        uri => structure.units.keys exists (uri ==)
+    ) getOrElse structure.root
+    new SessionSettings(
+      currentBuild,
+      projectMap(structure, currentProject),
+      structure.settings,
+      Map.empty,
+      Nil,
+      rootEval
+    )
   }
 
   def initialSession(structure: BuildStructure, rootEval: () => Eval): SessionSettings =
-    new SessionSettings(structure.root, projectMap(structure, Map.empty), structure.settings, Map.empty, Nil, rootEval)
+    new SessionSettings(
+      structure.root,
+      projectMap(structure, Map.empty),
+      structure.settings,
+      Map.empty,
+      Nil,
+      rootEval
+    )
 
-  def projectMap(structure: BuildStructure, current: Map[URI, String]): Map[URI, String] =
-    {
-      val units = structure.units
-      val getRoot = getRootProject(units)
-      def project(uri: URI) = {
-        current get uri filter {
-          p => structure allProjects uri map (_.id) contains p
-        } getOrElse getRoot(uri)
-      }
-      units.keys.map(uri => (uri, project(uri))).toMap
+  def projectMap(structure: BuildStructure, current: Map[URI, String]): Map[URI, String] = {
+    val units = structure.units
+    val getRoot = getRootProject(units)
+    def project(uri: URI) = {
+      current get uri filter { p =>
+        structure allProjects uri map (_.id) contains p
+      } getOrElse getRoot(uri)
     }
+    units.keys.map(uri => (uri, project(uri))).toMap
+  }
 
   def defaultEvalOptions: Seq[String] = Nil
 
-  @deprecated("Use BuildUtil.baseImports", "0.13.0")
-  def baseImports = BuildUtil.baseImports
-  @deprecated("Use BuildUtil.checkCycles", "0.13.0")
-  def checkCycles(units: Map[URI, LoadedBuildUnit]): Unit = BuildUtil.checkCycles(units)
-  @deprecated("Use BuildUtil.importAll", "0.13.0")
-  def importAll(values: Seq[String]): Seq[String] = BuildUtil.importAll(values)
-  @deprecated("Use BuildUtil.importAllRoot", "0.13.0")
-  def importAllRoot(values: Seq[String]): Seq[String] = BuildUtil.importAllRoot(values)
-  @deprecated("Use BuildUtil.rootedNames", "0.13.0")
-  def rootedName(s: String): String = BuildUtil.rootedName(s)
-  @deprecated("Use BuildUtil.getImports", "0.13.0")
-  def getImports(unit: BuildUnit): Seq[String] = BuildUtil.getImports(unit)
-
-  def referenced[PR <: ProjectReference](definitions: Seq[ProjectDefinition[PR]]): Seq[PR] = definitions flatMap { _.referenced }
+  def referenced[PR <: ProjectReference](definitions: Seq[ProjectDefinition[PR]]): Seq[PR] =
+    definitions flatMap { _.referenced }
 
   final class EvaluatedConfigurations(val eval: Eval, val settings: Seq[Setting[_]])
-  final case class InjectSettings(global: Seq[Setting[_]], project: Seq[Setting[_]], projectLoaded: ClassLoader => Seq[Setting[_]])
 
-  @deprecated("Use BuildUtil.apply", "0.13.0")
-  def buildUtil(root: URI, units: Map[URI, LoadedBuildUnit], keyIndex: KeyIndex, data: Settings[Scope]): BuildUtil[ResolvedProject] = BuildUtil(root, units, keyIndex, data)
+  final case class InjectSettings(
+      global: Seq[Setting[_]],
+      project: Seq[Setting[_]],
+      projectLoaded: ClassLoader => Seq[Setting[_]]
+  ) {
+    import java.net.URLClassLoader
+    private val cache: mutable.Map[String, Seq[Setting[_]]] = mutable.Map.empty
+    // Cache based on the underlying URL values of the classloader
+    def cachedProjectLoaded(cl: ClassLoader): Seq[Setting[_]] =
+      cl match {
+        case cl: URLClassLoader =>
+          cache.getOrElseUpdate(classLoaderToHash(Some(cl)), projectLoaded(cl))
+        case _ => projectLoaded(cl)
+      }
+    private def classLoaderToHash(o: Option[ClassLoader]): String =
+      o match {
+        case Some(cl: URLClassLoader) =>
+          cl.getURLs.toList.toString + classLoaderToHash(Option(cl.getParent))
+        case Some(cl: ClassLoader) =>
+          cl.toString + classLoaderToHash(Option(cl.getParent))
+        case _ => "null"
+      }
+  }
+
+  /** Variable to control the indentation of the timing logs. */
+  private var timedIndentation: Int = 0
+
+  /** Debugging method to time how long it takes to run various compilation tasks. */
+  private[sbt] def timed[T](label: String, log: Logger)(t: => T): T = {
+    timedIndentation += 1
+    val start = System.nanoTime
+    val result = t
+    val elapsed = System.nanoTime - start
+    timedIndentation -= 1
+    val prefix = " " * 2 * timedIndentation
+    log.debug(s"$prefix$label took ${elapsed / 1e6}ms")
+    result
+  }
 }
 
 final case class LoadBuildConfiguration(
     stagingDirectory: File,
-    classpath: Seq[Attributed[File]],
+    classpath: Def.Classpath,
     loader: ClassLoader,
     compilers: Compilers,
     evalPluginDef: (BuildStructure, State) => PluginData,
@@ -915,21 +1403,32 @@ final case class LoadBuildConfiguration(
     injectSettings: Load.InjectSettings,
     globalPlugin: Option[GlobalPlugin],
     extraBuilds: Seq[URI],
-    log: Logger) {
-  lazy val (globalPluginClasspath, _) = Load.pluginDefinitionLoader(this, Load.globalPluginClasspath(globalPlugin))
+    log: Logger
+) {
+  lazy val globalPluginClasspath: Def.Classpath =
+    Load.buildPluginClasspath(this, Load.globalPluginClasspath(globalPlugin))
 
-  private[sbt] lazy val globalPluginDefs = {
+  lazy val detectedGlobalPlugins: DetectedPlugins = {
     val pluginData = globalPlugin match {
-      case Some(x) => PluginData(x.data.fullClasspath, x.data.internalClasspath, Some(x.data.resolvers), Some(x.data.updateReport), Nil)
-      case None    => PluginData(globalPluginClasspath, Nil, None, None, Nil)
+      case Some(info) =>
+        val data = info.data
+        PluginData(
+          data.fullClasspath,
+          data.internalClasspath,
+          Some(data.resolvers),
+          Some(data.updateReport),
+          Nil
+        )
+      case None => PluginData(globalPluginClasspath)
     }
     val baseDir = globalPlugin match {
       case Some(x) => x.base
       case _       => stagingDirectory
     }
-    Load.loadPluginDefinition(baseDir, this, pluginData)
+    val globalPlugins = Load.loadPluginDefinition(baseDir, this, pluginData)
+    globalPlugins.detected
   }
-  lazy val detectedGlobalPlugins = globalPluginDefs.detected
 }
 
-final class IncompatiblePluginsException(msg: String, cause: Throwable) extends Exception(msg, cause)
+final class IncompatiblePluginsException(msg: String, cause: Throwable)
+    extends Exception(msg, cause)
diff --git a/main/src/main/scala/sbt/internal/LoadedSbtFile.scala b/main/src/main/scala/sbt/internal/LoadedSbtFile.scala
index dbf0d6bfe..d39a8e69a 100644
--- a/main/src/main/scala/sbt/internal/LoadedSbtFile.scala
+++ b/main/src/main/scala/sbt/internal/LoadedSbtFile.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -16,7 +23,8 @@ private[sbt] final class LoadedSbtFile(
     // TODO - we may want to expose a simpler interface on top of here for the set command,
     // rather than what we have now...
     val definitions: DefinedSbtValues,
-    val generatedFiles: Seq[File]) {
+    val generatedFiles: Seq[File]
+) {
   // We still use merge for now.  We track originating sbt file in an alternative manner.
   def merge(o: LoadedSbtFile): LoadedSbtFile =
     new LoadedSbtFile(
@@ -25,9 +33,11 @@ private[sbt] final class LoadedSbtFile(
       importedDefs ++ o.importedDefs,
       manipulations,
       definitions zip o.definitions,
-      generatedFiles ++ o.generatedFiles)
+      generatedFiles ++ o.generatedFiles
+    )
 
-  def clearProjects = new LoadedSbtFile(settings, Nil, importedDefs, manipulations, definitions, generatedFiles)
+  def clearProjects =
+    new LoadedSbtFile(settings, Nil, importedDefs, manipulations, definitions, generatedFiles)
 }
 
 /**
@@ -40,7 +50,9 @@ private[sbt] final class DefinedSbtValues(val sbtFiles: Seq[compiler.EvalDefinit
     sbtFiles flatMap (_ values parent)
 
   def classloader(parent: ClassLoader): ClassLoader =
-    sbtFiles.foldLeft(parent) { (cl, e) => e.loader(cl) }
+    sbtFiles.foldLeft(parent) { (cl, e) =>
+      e.loader(cl)
+    }
 
   def imports: Seq[String] = {
     // TODO - Sanity check duplicates and such, so users get a nice warning rather
@@ -49,7 +61,7 @@ private[sbt] final class DefinedSbtValues(val sbtFiles: Seq[compiler.EvalDefinit
       file <- sbtFiles
       m = file.enclosingModule
       v <- file.valNames
-    } yield s"import ${m}.${v}"
+    } yield s"import ${m}.`${v}`"
   }
   def generated: Seq[File] =
     sbtFiles flatMap (_.generated)
@@ -67,16 +79,18 @@ private[sbt] final class DefinedSbtValues(val sbtFiles: Seq[compiler.EvalDefinit
     new DefinedSbtValues(sbtFiles ++ other.sbtFiles)
 }
 private[sbt] object DefinedSbtValues {
+
   /** Construct a DefinedSbtValues object directly from the underlying representation. */
   def apply(eval: compiler.EvalDefinitions): DefinedSbtValues =
     new DefinedSbtValues(Seq(eval))
+
   /** Construct an empty value object. */
   def empty = new DefinedSbtValues(Nil)
 
 }
 
 private[sbt] object LoadedSbtFile {
+
   /** Represents an empty .sbt file: no Projects, imports, or settings.*/
   def empty = new LoadedSbtFile(Nil, Nil, Nil, Nil, DefinedSbtValues.empty, Nil)
 }
-
diff --git a/main/src/main/scala/sbt/internal/LogManager.scala b/main/src/main/scala/sbt/internal/LogManager.scala
new file mode 100644
index 000000000..e28fd91ee
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/LogManager.scala
@@ -0,0 +1,331 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.PrintWriter
+
+import sbt.Def.ScopedKey
+import sbt.Keys._
+import sbt.Scope.Global
+import sbt.SlashSyntax0._
+import sbt.internal.util.MainAppender._
+import sbt.internal.util.{ Terminal => ITerminal, _ }
+import sbt.util.{ Level, LogExchange, Logger, LoggerContext }
+import org.apache.logging.log4j.core.{ Appender => XAppender }
+import scala.annotation.nowarn
+
+sealed abstract class LogManager {
+  def apply(
+      data: Settings[Scope],
+      state: State,
+      task: ScopedKey[_],
+      writer: PrintWriter,
+      context: LoggerContext,
+  ): ManagedLogger
+  @deprecated("Use alternate apply that provides a LoggerContext", "1.4.0")
+  def apply(
+      data: Settings[Scope],
+      state: State,
+      task: ScopedKey[_],
+      writer: PrintWriter
+  ): ManagedLogger = apply(data, state, task, writer, LoggerContext.globalContext)
+
+  def backgroundLog(
+      data: Settings[Scope],
+      state: State,
+      task: ScopedKey[_],
+      context: LoggerContext
+  ): ManagedLogger
+  @deprecated("Use alternate background log that provides a LoggerContext", "1.4.0")
+  final def backgroundLog(data: Settings[Scope], state: State, task: ScopedKey[_]): ManagedLogger =
+    backgroundLog(data, state, task, LoggerContext.globalContext)
+}
+
+/**
+ * A functional interface that allows us to preserve binary compatibility
+ * for LogManager.defaults with the old log4j variant.
+ */
+trait AppenderSupplier {
+  def apply(s: ScopedKey[_]): Seq[Appender]
+}
+
+object LogManager {
+  import java.util.concurrent.atomic.AtomicInteger
+  private val generateId: AtomicInteger = new AtomicInteger
+
+  // This is called by mkStreams
+  //
+  @nowarn
+  def construct(
+      data: Settings[Scope],
+      state: State
+  ): (ScopedKey[_], PrintWriter) => ManagedLogger =
+    (task: ScopedKey[_], to: PrintWriter) => {
+      val context = state.get(Keys.loggerContext).getOrElse(LoggerContext.globalContext)
+      val manager: LogManager =
+        (logManager in task.scope).get(data) getOrElse defaultManager(state.globalLogging.console)
+      manager(data, state, task, to, context)
+    }
+
+  @nowarn
+  def constructBackgroundLog(
+      data: Settings[Scope],
+      state: State
+  ): (ScopedKey[_]) => ManagedLogger =
+    (task: ScopedKey[_]) => {
+      val manager: LogManager =
+        (logManager in task.scope).get(data) getOrElse defaultManager(state.globalLogging.console)
+      val context = state.get(Keys.loggerContext).getOrElse(LoggerContext.globalContext)
+      manager.backgroundLog(data, state, task, context)
+    }
+
+  def defaultManager(console: ConsoleOut): LogManager =
+    withLoggers((_, _) => defaultScreen(console))
+
+  @deprecated(
+    "use defaults that takes AppenderSupplier instead of ScopedKey[_] => Seq[Appender]",
+    "1.4.0"
+  )
+  def defaults(extra: ScopedKey[_] => Seq[XAppender], console: ConsoleOut): LogManager =
+    defaults((sk: ScopedKey[_]) => extra(sk).map(new ConsoleAppenderFromLog4J("extra", _)), console)
+  // This is called by Defaults.
+  def defaults(extra: AppenderSupplier, console: ConsoleOut): LogManager =
+    withLoggers(
+      (task, state) => defaultScreen(console, suppressedMessage(task, state)),
+      extra = extra
+    )
+
+  def withScreenLogger(mk: (ScopedKey[_], State) => Appender): LogManager =
+    withLoggers(screen = mk)
+
+  def withLoggers(
+      screen: (ScopedKey[_], State) => Appender = (_, s) => defaultScreen(s.globalLogging.console),
+      backed: PrintWriter => Appender = defaultBacked,
+      relay: Unit => Appender = defaultRelay,
+      extra: AppenderSupplier = _ => Nil
+  ): LogManager = new DefaultLogManager(screen, backed, relay, extra)
+
+  private class DefaultLogManager(
+      screen: (ScopedKey[_], State) => Appender,
+      backed: PrintWriter => Appender,
+      relay: Unit => Appender,
+      extra: AppenderSupplier
+  ) extends LogManager {
+    def apply(
+        data: Settings[Scope],
+        state: State,
+        task: ScopedKey[_],
+        to: PrintWriter,
+        context: LoggerContext,
+    ): ManagedLogger =
+      defaultLogger(
+        data,
+        state,
+        task,
+        screen(task, state),
+        backed(to),
+        relay(()),
+        extra(task).toList,
+        context,
+      )
+
+    def backgroundLog(
+        data: Settings[Scope],
+        state: State,
+        task: ScopedKey[_],
+        context: LoggerContext
+    ): ManagedLogger = {
+      val console = screen(task, state)
+      LogManager.backgroundLog(data, state, task, console, relay(()), context)
+    }
+  }
+
+  // to change from global being the default to overriding, switch the order of state.get and data.get
+  def getOr[T](
+      key: AttributeKey[T],
+      data: Settings[Scope],
+      scope: Scope,
+      state: State,
+      default: T
+  ): T =
+    data.get(scope, key) orElse state.get(key) getOrElse default
+
+  @deprecated("Use defaultLogger that provides a LoggerContext", "1.4.0")
+  def defaultLogger(
+      data: Settings[Scope],
+      state: State,
+      task: ScopedKey[_],
+      console: Appender,
+      backed: Appender,
+      relay: Appender,
+      extra: List[Appender]
+  ): ManagedLogger =
+    defaultLogger(data, state, task, console, backed, relay, extra, LoggerContext.globalContext)
+  // This is the main function that is used to generate the logger for tasks.
+  def defaultLogger(
+      data: Settings[Scope],
+      state: State,
+      task: ScopedKey[_],
+      console: Appender,
+      backed: Appender,
+      relay: Appender,
+      extra: List[Appender],
+      context: LoggerContext,
+  ): ManagedLogger = {
+    val execOpt = state.currentCommand
+    val loggerName: String = s"${task.key.label}-${generateId.incrementAndGet}"
+    val channelName: Option[String] = execOpt flatMap (_.source map (_.channelName))
+    val execId: Option[String] = execOpt flatMap { _.execId }
+    val log = context.logger(loggerName, channelName, execId)
+    val scope = task.scope
+    val screenLevel = getOr(logLevel.key, data, scope, state, Level.Info)
+    val backingLevel = getOr(persistLogLevel.key, data, scope, state, Level.Debug)
+    val screenTrace = getOr(traceLevel.key, data, scope, state, defaultTraceLevel(state))
+    val backingTrace = getOr(persistTraceLevel.key, data, scope, state, Int.MaxValue)
+    val extraBacked = state.globalLogging.backed :: relay :: Nil
+    val consoleOpt = consoleLocally(state, console)
+    val config = MainAppender.MainAppenderConfig(
+      consoleOpt,
+      backed,
+      extraBacked ::: extra,
+      screenLevel,
+      backingLevel,
+      screenTrace,
+      backingTrace
+    )
+    multiLogger(log, config, context)
+  }
+
+  // Return None if the exec is not from console origin.
+  def consoleLocally(state: State, console: Appender): Option[Appender] =
+    state.currentCommand match {
+      case Some(x: Exec) =>
+        x.source match {
+          // TODO: Fix this stringliness
+          case Some(x: CommandSource) if x.channelName == ConsoleChannel.defaultName =>
+            Option(console)
+          case _ => Option(console)
+        }
+      case _ => Option(console)
+    }
+
+  def defaultTraceLevel(state: State): Int =
+    if (state.interactive) -1 else Int.MaxValue
+
+  def suppressedMessage(
+      key: ScopedKey[_],
+      state: State
+  ): SuppressedTraceContext => Option[String] = {
+    val display = Project.showContextKey(state)
+    def commandBase = "last " + display.show(unwrapStreamsKey(key))
+    def command(useFormat: Boolean) =
+      if (useFormat) s"${scala.Console.MAGENTA}$commandBase${scala.Console.RESET}"
+      else s"'$commandBase'"
+
+    { context =>
+      Some(
+        s"stack trace is suppressed; run ${command(context.useFormat)} for the full output"
+      )
+    }
+  }
+
+  def unwrapStreamsKey(key: ScopedKey[_]): ScopedKey[_] = key.scope.task match {
+    case Select(task) => ScopedKey(key.scope.copy(task = Zero), task)
+    case _            => key // should never get here
+  }
+
+  def backgroundLog(
+      data: Settings[Scope],
+      state: State,
+      task: ScopedKey[_],
+      console: Appender,
+      /* TODO: backed: Appender,*/
+      relay: Appender,
+      context: LoggerContext,
+  ): ManagedLogger = {
+    val scope = task.scope
+    val screenLevel = getOr(logLevel.key, data, scope, state, Level.Info)
+    val backingLevel = getOr(persistLogLevel.key, data, scope, state, Level.Debug)
+    val screenTrace = getOr(traceLevel.key, data, scope, state, 0)
+    val execOpt = state.currentCommand
+    val loggerName: String = s"bg-${task.key.label}-${generateId.incrementAndGet}"
+    val channelName: Option[String] = execOpt flatMap (_.source map (_.channelName))
+    // val execId: Option[String] = execOpt flatMap { _.execId }
+    val log = context.logger(loggerName, channelName, None)
+    context.clearAppenders(loggerName)
+    val consoleOpt = consoleLocally(state, console) map {
+      case a: Appender =>
+        a.setTrace(screenTrace)
+        a
+      case a => a
+    }
+    consoleOpt.foreach(a => context.addAppender(loggerName, a -> screenLevel))
+    context.addAppender(loggerName, relay -> backingLevel)
+    log
+  }
+
+  // TODO: Fix this
+  // if global logging levels are not explicitly set, set them from project settings
+  // private[sbt] def setGlobalLogLevels(s: State, data: Settings[Scope]): State =
+  //   if (hasExplicitGlobalLogLevels(s))
+  //     s
+  //   else {
+  //     val logging = s.globalLogging
+  //     def get[T](key: SettingKey[T]) = key in GlobalScope get data
+  //     def transfer(l: AbstractLogger, traceKey: SettingKey[Int], levelKey: SettingKey[Level.Value]): Unit = {
+  //       get(traceKey).foreach(l.setTrace)
+  //       get(levelKey).foreach(l.setLevel)
+  //     }
+  //     logging.full match {
+  //       case a: AbstractLogger => transfer(a, traceLevel, logLevel)
+  //       case _                 => ()
+  //     }
+  //     transfer(logging.backed, persistTraceLevel, persistLogLevel)
+  //     s
+  //   }
+
+  def setGlobalLogLevel(s: State, level: Level.Value): State = {
+    val s1 = s.put(BasicKeys.explicitGlobalLogLevels, true).put(Keys.logLevel.key, level)
+    val gl = s1.globalLogging
+    LoggerContext.globalContext.clearAppenders(gl.full.name)
+    LoggerContext.globalContext.addAppender(gl.full.name, gl.backed -> level)
+    s1
+  }
+
+  @deprecated("No longer used.", "1.4.0")
+  private[sbt] def progressLogger(appender: ConsoleAppender): ManagedLogger = {
+    val log = LogExchange.logger("progress", None, None)
+    LoggerContext.globalContext.clearAppenders("progress")
+    LoggerContext.globalContext.addAppender("progress", appender -> Level.Info)
+    log
+  }
+
+  // This is the default implementation for the relay appender
+  val defaultRelay: Unit => ConsoleAppender = _ => defaultRelayImpl
+
+  private[this] lazy val defaultRelayImpl: ConsoleAppender = new RelayAppender("Relay0")
+
+  private[sbt] def settingsLogger(state: State): Def.Setting[_] =
+    // strict to avoid retaining a reference to `state`
+    Global / sLog :== globalWrapper(state)
+
+  // construct a Logger that delegates to the global logger, but only holds a weak reference
+  //  this is an approximation to the ideal that would invalidate the delegate after loading completes
+  private[this] def globalWrapper(s: State): Logger =
+    new Logger {
+      private[this] val ref = new java.lang.ref.WeakReference(s.globalLogging.full)
+      private[this] def slog: Logger =
+        Option(ref.get) getOrElse sys.error("Settings logger used after project was loaded.")
+
+      override val ansiCodesSupported = ITerminal.isAnsiSupported
+      override def trace(t: => Throwable) = slog.trace(t)
+      override def success(message: => String) = slog.success(message)
+      override def log(level: Level.Value, message: => String) = slog.log(level, message)
+    }
+}
diff --git a/main/src/main/scala/sbt/internal/Output.scala b/main/src/main/scala/sbt/internal/Output.scala
index 5bc633820..81090e7a4 100644
--- a/main/src/main/scala/sbt/internal/Output.scala
+++ b/main/src/main/scala/sbt/internal/Output.scala
@@ -1,11 +1,15 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
-import sbt.internal.util.{ Show, Types }
-
+import sbt.internal.util.Types
+import sbt.util.Show
 import java.util.regex.Pattern
 import java.io.File
 import Keys.Streams
@@ -20,65 +24,84 @@ import sbt.io.IO
 object Output {
   final val DefaultTail = "> "
 
-  @deprecated("Explicitly provide None for the stream ID.", "0.13.0")
-  def last(keys: Values[_], streams: Streams, printLines: Seq[String] => Unit)(implicit display: Show[ScopedKey[_]]): Unit =
-    last(keys, streams, printLines, None)(display)
-
-  def last(keys: Values[_], streams: Streams, printLines: Seq[String] => Unit, sid: Option[String])(implicit display: Show[ScopedKey[_]]): Unit =
+  def last(
+      keys: Values[_],
+      streams: Streams,
+      printLines: Seq[String] => Unit,
+      sid: Option[String]
+  )(implicit display: Show[ScopedKey[_]]): Unit =
     printLines(flatLines(lastLines(keys, streams, sid))(idFun))
 
   def last(file: File, printLines: Seq[String] => Unit, tailDelim: String = DefaultTail): Unit =
     printLines(tailLines(file, tailDelim))
 
-  def lastGrep(keys: Values[_], streams: Streams, patternString: String, printLines: Seq[String] => Unit)(implicit display: Show[ScopedKey[_]]): Unit =
-    {
-      val pattern = Pattern compile patternString
-      val lines = flatLines(lastLines(keys, streams))(_ flatMap showMatches(pattern))
-      printLines(lines)
-    }
-  def lastGrep(file: File, patternString: String, printLines: Seq[String] => Unit, tailDelim: String = DefaultTail): Unit =
+  def lastGrep(
+      keys: Values[_],
+      streams: Streams,
+      patternString: String,
+      printLines: Seq[String] => Unit
+  )(implicit display: Show[ScopedKey[_]]): Unit = {
+    val pattern = Pattern compile patternString
+    val lines = flatLines(lastLines(keys, streams))(_ flatMap showMatches(pattern))
+    printLines(lines)
+  }
+
+  def lastGrep(
+      file: File,
+      patternString: String,
+      printLines: Seq[String] => Unit,
+      tailDelim: String = DefaultTail
+  ): Unit =
     printLines(grep(tailLines(file, tailDelim), patternString))
+
   def grep(lines: Seq[String], patternString: String): Seq[String] =
     lines flatMap showMatches(Pattern compile patternString)
 
-  def flatLines(outputs: Values[Seq[String]])(f: Seq[String] => Seq[String])(implicit display: Show[ScopedKey[_]]): Seq[String] =
-    {
-      val single = outputs.size == 1
-      outputs flatMap {
-        case KeyValue(key, lines) =>
-          val flines = f(lines)
-          if (!single) bold(display(key)) +: flines else flines
-      }
+  def flatLines(outputs: Values[Seq[String]])(f: Seq[String] => Seq[String])(
+      implicit display: Show[ScopedKey[_]]
+  ): Seq[String] = {
+    val single = outputs.size == 1
+    outputs flatMap {
+      case KeyValue(key, lines) =>
+        val flines = f(lines)
+        if (!single) bold(display.show(key)) +: flines else flines
     }
+  }
 
-  def lastLines(keys: Values[_], streams: Streams, sid: Option[String] = None): Values[Seq[String]] =
-    {
-      val outputs = keys map { (kv: KeyValue[_]) => KeyValue(kv.key, lastLines(kv.key, streams, sid)) }
-      outputs.filterNot(_.value.isEmpty)
+  def lastLines(
+      keys: Values[_],
+      streams: Streams,
+      sid: Option[String] = None
+  ): Values[Seq[String]] = {
+    val outputs = keys map { (kv: KeyValue[_]) =>
+      KeyValue(kv.key, lastLines(kv.key, streams, sid))
     }
-
-  @deprecated("Explicitly provide None for the stream ID.", "0.13.0")
-  def lastLines(key: ScopedKey[_], mgr: Streams): Seq[String] = lastLines(key, mgr, None)
+    outputs.filterNot(_.value.isEmpty)
+  }
 
   def lastLines(key: ScopedKey[_], mgr: Streams, sid: Option[String]): Seq[String] =
     mgr.use(key) { s =>
       // Workaround for #1155 - Keys.streams are always scoped by the task they're included in
       // but are keyed by the Keys.streams key.  I think this isn't actually a workaround, but
       // is how things are expected to work now.
-      // You can see where streams are injected using their own key scope in 
+      // You can see where streams are injected using their own key scope in
       // EvaluateTask.injectStreams.
-      val streamScopedKey: ScopedKey[_] = ScopedKey(Project.fillTaskAxis(key).scope, Keys.streams.key)
+      val streamScopedKey: ScopedKey[_] =
+        ScopedKey(Project.fillTaskAxis(key).scope, Keys.streams.key)
       val tmp = s.readText(streamScopedKey, sid)
       IO.readLines(tmp)
     }
 
-  def tailLines(file: File, tailDelim: String): Seq[String] = headLines(IO.readLines(file).reverse, tailDelim).reverse
+  def tailLines(file: File, tailDelim: String): Seq[String] =
+    headLines(IO.readLines(file).reverse, tailDelim).reverse
 
   @tailrec def headLines(lines: Seq[String], tailDelim: String): Seq[String] =
     if (lines.isEmpty)
       lines
     else {
-      val (first, tail) = lines.span { line => !(line startsWith tailDelim) }
+      val (first, tail) = lines.span { line =>
+        !(line startsWith tailDelim)
+      }
       if (first.isEmpty) headLines(tail drop 1, tailDelim) else first
     }
 }
diff --git a/main/src/main/scala/sbt/internal/PluginDiscovery.scala b/main/src/main/scala/sbt/internal/PluginDiscovery.scala
index f4f06d7ab..0f3998fc5 100644
--- a/main/src/main/scala/sbt/internal/PluginDiscovery.scala
+++ b/main/src/main/scala/sbt/internal/PluginDiscovery.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -13,6 +20,7 @@ import sbt.internal.inc.ModuleUtilities
 import sbt.io.IO
 
 object PluginDiscovery {
+
   /**
    * Relative paths of resources that list top-level modules that are available.
    * Normally, the classes for those modules will be in the same classpath entry as the resource.
@@ -21,6 +29,7 @@ object PluginDiscovery {
     final val AutoPlugins = "sbt/sbt.autoplugins"
     final val Builds = "sbt/sbt.builds"
   }
+
   /** Names of top-level modules that subclass sbt plugin-related classes: [[AutoPlugin]], and [[BuildDef]]. */
   final class DiscoveredNames(val autoPlugins: Seq[String], val builds: Seq[String]) {
     override def toString: String = s"""DiscoveredNames($autoPlugins, $builds)"""
@@ -29,110 +38,128 @@ object PluginDiscovery {
   def emptyDiscoveredNames: DiscoveredNames = new DiscoveredNames(Nil, Nil)
 
   /** Discovers and loads the sbt-plugin-related top-level modules from the classpath and source analysis in `data` and using the provided class `loader`. */
-  def discoverAll(data: PluginData, loader: ClassLoader): DetectedPlugins =
-    {
-      def discover[T](resource: String)(implicit classTag: reflect.ClassTag[T]) =
-        binarySourceModules[T](data, loader, resource)
-      import Paths._
-      // TODO - Fix this once we can autodetect AutoPlugins defined by sbt itself.
-      val defaultAutoPlugins = Seq(
-        "sbt.plugins.IvyPlugin" -> sbt.plugins.IvyPlugin,
-        "sbt.plugins.JvmPlugin" -> sbt.plugins.JvmPlugin,
-        "sbt.plugins.CorePlugin" -> sbt.plugins.CorePlugin,
-        "sbt.plugins.JUnitXmlReportPlugin" -> sbt.plugins.JUnitXmlReportPlugin
-      )
-      val detectedAutoPugins = discover[AutoPlugin](AutoPlugins)
-      val allAutoPlugins = (defaultAutoPlugins ++ detectedAutoPugins.modules) map {
-        case (name, value) =>
-          DetectedAutoPlugin(name, value, sbt.Plugins.hasAutoImportGetter(value, loader))
-      }
-      new DetectedPlugins(allAutoPlugins, discover[BuildDef](Builds))
+  def discoverAll(data: PluginData, loader: ClassLoader): DetectedPlugins = {
+    def discover[T](resource: String)(implicit classTag: reflect.ClassTag[T]) =
+      binarySourceModules[T](data, loader, resource)
+    import Paths._
+    // TODO - Fix this once we can autodetect AutoPlugins defined by sbt itself.
+    val defaultAutoPlugins = Seq(
+      "sbt.plugins.IvyPlugin" -> sbt.plugins.IvyPlugin,
+      "sbt.plugins.JvmPlugin" -> sbt.plugins.JvmPlugin,
+      "sbt.plugins.CorePlugin" -> sbt.plugins.CorePlugin,
+      "sbt.ScriptedPlugin" -> sbt.ScriptedPlugin,
+      "sbt.plugins.SbtPlugin" -> sbt.plugins.SbtPlugin,
+      "sbt.plugins.SemanticdbPlugin" -> sbt.plugins.SemanticdbPlugin,
+      "sbt.plugins.JUnitXmlReportPlugin" -> sbt.plugins.JUnitXmlReportPlugin,
+      "sbt.plugins.Giter8TemplatePlugin" -> sbt.plugins.Giter8TemplatePlugin,
+      "sbt.plugins.MiniDependencyTreePlugin" -> sbt.plugins.MiniDependencyTreePlugin,
+    )
+    val detectedAutoPlugins = discover[AutoPlugin](AutoPlugins)
+    val allAutoPlugins = (defaultAutoPlugins ++ detectedAutoPlugins.modules) map {
+      case (name, value) =>
+        DetectedAutoPlugin(name, value, sbt.Plugins.hasAutoImportGetter(value, loader))
     }
+    new DetectedPlugins(allAutoPlugins, discover[BuildDef](Builds))
+  }
 
   /** Discovers the sbt-plugin-related top-level modules from the provided source `analysis`. */
-  def discoverSourceAll(analysis: CompileAnalysis): DiscoveredNames =
-    {
-      def discover[T](implicit classTag: reflect.ClassTag[T]): Seq[String] =
-        sourceModuleNames(analysis, classTag.runtimeClass.getName)
-      new DiscoveredNames(discover[AutoPlugin], discover[BuildDef])
-    }
+  def discoverSourceAll(analysis: CompileAnalysis): DiscoveredNames = {
+    def discover[T](implicit classTag: reflect.ClassTag[T]): Seq[String] =
+      sourceModuleNames(analysis, classTag.runtimeClass.getName)
+    new DiscoveredNames(discover[AutoPlugin], discover[BuildDef])
+  }
 
-  // TODO: for 0.14.0, consider consolidating into a single file, which would make the classpath search 4x faster
+  // TODO: consider consolidating into a single file, which would make the classpath search 4x faster
   /** Writes discovered module `names` to zero or more files in `dir` as per [[writeDescriptor]] and returns the list of files written. */
-  def writeDescriptors(names: DiscoveredNames, dir: File): Seq[File] =
-    {
-      import Paths._
-      val files =
-        writeDescriptor(names.autoPlugins, dir, AutoPlugins) ::
-          writeDescriptor(names.builds, dir, Builds) ::
-          Nil
-      files.flatMap(_.toList)
-    }
+  def writeDescriptors(names: DiscoveredNames, dir: File): Seq[File] = {
+    import Paths._
+    val files =
+      writeDescriptor(names.autoPlugins, dir, AutoPlugins) ::
+        writeDescriptor(names.builds, dir, Builds) ::
+        Nil
+    files.flatMap(_.toList)
+  }
 
   /** Stores the module `names` in `dir / path`, one per line, unless `names` is empty and then the file is deleted and `None` returned. */
-  def writeDescriptor(names: Seq[String], dir: File, path: String): Option[File] =
-    {
-      val descriptor: File = new File(dir, path)
-      if (names.isEmpty) {
-        IO.delete(descriptor)
-        None
-      } else {
-        IO.writeLines(descriptor, names.distinct.sorted)
-        Some(descriptor)
-      }
+  def writeDescriptor(names: Seq[String], dir: File, path: String): Option[File] = {
+    val descriptor: File = new File(dir, path)
+    if (names.isEmpty) {
+      IO.delete(descriptor)
+      None
+    } else {
+      IO.writeLines(descriptor, names.distinct.sorted)
+      Some(descriptor)
     }
+  }
 
   /**
    * Discovers the names of top-level modules listed in resources named `resourceName` as per [[binaryModuleNames]] or
    * available as analyzed source and extending from any of `subclasses` as per [[sourceModuleNames]].
    */
-  def binarySourceModuleNames(classpath: Seq[Attributed[File]], loader: ClassLoader, resourceName: String, subclasses: String*): Seq[String] =
+  def binarySourceModuleNames(
+      classpath: Seq[Attributed[File]],
+      loader: ClassLoader,
+      resourceName: String,
+      subclasses: String*
+  ): Seq[String] =
     (
       binaryModuleNames(data(classpath), loader, resourceName) ++
-      (analyzed(classpath) flatMap (a => sourceModuleNames(a, subclasses: _*)))
+        (analyzed(classpath) flatMap (a => sourceModuleNames(a, subclasses: _*)))
     ).distinct
 
   /** Discovers top-level modules in `analysis` that inherit from any of `subclasses`. */
-  def sourceModuleNames(analysis: CompileAnalysis, subclasses: String*): Seq[String] =
-    {
-      val subclassSet = subclasses.toSet
-      val defs = Tests.allDefs(analysis)
-      val ds = Discovery(subclassSet, Set.empty)(defs)
-      ds.flatMap {
-        case (definition, Discovered(subs, _, _, true)) =>
-          if ((subs & subclassSet).isEmpty) Nil else definition.name :: Nil
-        case _ => Nil
-      }
+  def sourceModuleNames(analysis: CompileAnalysis, subclasses: String*): Seq[String] = {
+    val subclassSet = subclasses.toSet
+    val defs = Tests.allDefs(analysis)
+    val ds = Discovery(subclassSet, Set.empty)(defs)
+    ds.flatMap {
+      case (definition, Discovered(subs, _, _, true)) =>
+        if ((subs & subclassSet).isEmpty) Nil else definition.name :: Nil
+      case _ => Nil
     }
+  }
 
   /**
    * Obtains the list of modules identified in all resource files `resourceName` from `loader` that are on `classpath`.
    * `classpath` and `loader` are both required to ensure that `loader`
    * doesn't bring in any resources outside of the intended `classpath`, such as from parent loaders.
    */
-  def binaryModuleNames(classpath: Seq[File], loader: ClassLoader, resourceName: String): Seq[String] =
-    {
-      import collection.JavaConverters._
-      loader.getResources(resourceName).asScala.toSeq.filter(onClasspath(classpath)) flatMap { u =>
-        IO.readLinesURL(u).map(_.trim).filter(!_.isEmpty)
-      }
+  def binaryModuleNames(
+      classpath: Seq[File],
+      loader: ClassLoader,
+      resourceName: String
+  ): Seq[String] = {
+    import collection.JavaConverters._
+    loader.getResources(resourceName).asScala.toSeq.filter(onClasspath(classpath)) flatMap { u =>
+      IO.readLinesURL(u).map(_.trim).filter(!_.isEmpty)
     }
+  }
 
   /** Returns `true` if `url` is an entry in `classpath`.*/
   def onClasspath(classpath: Seq[File])(url: URL): Boolean =
     IO.urlAsFile(url) exists (classpath.contains _)
 
-  private[sbt] def binarySourceModules[T](data: PluginData, loader: ClassLoader, resourceName: String)(implicit classTag: reflect.ClassTag[T]): DetectedModules[T] =
-    {
-      val classpath = data.classpath
-      val namesAndValues = if (classpath.isEmpty) Nil else {
-        val names = binarySourceModuleNames(classpath, loader, resourceName, classTag.runtimeClass.getName)
+  private[sbt] def binarySourceModules[T](
+      data: PluginData,
+      loader: ClassLoader,
+      resourceName: String
+  )(implicit classTag: reflect.ClassTag[T]): DetectedModules[T] = {
+    val classpath = data.classpath
+    val namesAndValues =
+      if (classpath.isEmpty) Nil
+      else {
+        val names =
+          binarySourceModuleNames(classpath, loader, resourceName, classTag.runtimeClass.getName)
         loadModules[T](data, names, loader)
       }
-      new DetectedModules(namesAndValues)
-    }
+    new DetectedModules(namesAndValues)
+  }
 
-  private[this] def loadModules[T: reflect.ClassTag](data: PluginData, names: Seq[String], loader: ClassLoader): Seq[(String, T)] =
+  private[this] def loadModules[T: reflect.ClassTag](
+      data: PluginData,
+      names: Seq[String],
+      loader: ClassLoader
+  ): Seq[(String, T)] =
     try ModuleUtilities.getCheckedObjects[T](names, loader)
     catch {
       case e: ExceptionInInitializerError =>
@@ -141,13 +168,19 @@ object PluginDiscovery {
       case e: LinkageError => incompatiblePlugins(data, e)
     }
 
-  private[this] def incompatiblePlugins(data: PluginData, t: LinkageError): Nothing =
-    {
-      val evicted = data.report.toList.flatMap(_.configurations.flatMap(_.evicted))
-      val evictedModules = evicted map { id => (id.organization, id.name) } distinct;
-      val evictedStrings = evictedModules map { case (o, n) => o + ":" + n }
-      val msgBase = "Binary incompatibility in plugins detected."
-      val msgExtra = if (evictedStrings.isEmpty) "" else "\nNote that conflicts were resolved for some dependencies:\n\t" + evictedStrings.mkString("\n\t")
-      throw new IncompatiblePluginsException(msgBase + msgExtra, t)
-    }
+  private[this] def incompatiblePlugins(data: PluginData, t: LinkageError): Nothing = {
+    val evicted = data.report.toList.flatMap(_.configurations.flatMap(_.evicted))
+    val evictedModules = evicted map { id =>
+      (id.organization, id.name)
+    } distinct;
+    val evictedStrings = evictedModules map { case (o, n) => o + ":" + n }
+    val msgBase = "Binary incompatibility in plugins detected."
+    val msgExtra =
+      if (evictedStrings.isEmpty) ""
+      else
+        "\nNote that conflicts were resolved for some dependencies:\n\t" + evictedStrings.mkString(
+          "\n\t"
+        )
+    throw new IncompatiblePluginsException(msgBase + msgExtra, t)
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/PluginManagement.scala b/main/src/main/scala/sbt/internal/PluginManagement.scala
index 965880238..b000a1061 100644
--- a/main/src/main/scala/sbt/internal/PluginManagement.scala
+++ b/main/src/main/scala/sbt/internal/PluginManagement.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -8,9 +15,21 @@ import sbt.librarymanagement.ModuleID
 
 import java.net.{ URI, URL, URLClassLoader }
 
-final case class PluginManagement(overrides: Set[ModuleID], applyOverrides: Set[ModuleID], loader: PluginClassLoader, initialLoader: ClassLoader, context: Context) {
+final case class PluginManagement(
+    overrides: Set[ModuleID],
+    applyOverrides: Set[ModuleID],
+    loader: PluginClassLoader,
+    initialLoader: ClassLoader,
+    context: Context
+) {
   def shift: PluginManagement =
-    PluginManagement(Set.empty, overrides, new PluginClassLoader(initialLoader), initialLoader, context)
+    PluginManagement(
+      Set.empty,
+      overrides,
+      new PluginClassLoader(initialLoader),
+      initialLoader,
+      context
+    )
 
   def addOverrides(os: Set[ModuleID]): PluginManagement =
     copy(overrides = overrides ++ os)
@@ -19,25 +38,34 @@ final case class PluginManagement(overrides: Set[ModuleID], applyOverrides: Set[
     addOverrides(extractOverrides(cp))
 
   def inject: Seq[Setting[_]] = Seq(
-    Keys.dependencyOverrides ++= overrides
+    Keys.dependencyOverrides ++= overrides.toVector
   )
 
-  def resetDepth: PluginManagement = copy(context = Context(globalPluginProject = false, pluginProjectDepth = 0))
-  def forGlobalPlugin: PluginManagement = copy(context = Context(globalPluginProject = true, pluginProjectDepth = 0))
-  def forPlugin: PluginManagement = copy(context = context.copy(pluginProjectDepth = context.pluginProjectDepth + 1))
+  def resetDepth: PluginManagement =
+    copy(context = Context(globalPluginProject = false, pluginProjectDepth = 0))
+  def forGlobalPlugin: PluginManagement =
+    copy(context = Context(globalPluginProject = true, pluginProjectDepth = 0))
+  def forPlugin: PluginManagement =
+    copy(context = context.copy(pluginProjectDepth = context.pluginProjectDepth + 1))
 }
 object PluginManagement {
   final case class Context private[sbt] (globalPluginProject: Boolean, pluginProjectDepth: Int)
   val emptyContext: Context = Context(false, 0)
 
   def apply(initialLoader: ClassLoader): PluginManagement =
-    PluginManagement(Set.empty, Set.empty, new PluginClassLoader(initialLoader), initialLoader, emptyContext)
+    PluginManagement(
+      Set.empty,
+      Set.empty,
+      new PluginClassLoader(initialLoader),
+      initialLoader,
+      emptyContext
+    )
 
   def extractOverrides(classpath: Classpath): Set[ModuleID] =
     classpath flatMap { _.metadata get Keys.moduleID.key map keepOverrideInfo } toSet;
 
   def keepOverrideInfo(m: ModuleID): ModuleID =
-    ModuleID(m.organization, m.name, m.revision, crossVersion = m.crossVersion)
+    ModuleID(m.organization, m.name, m.revision).withCrossVersion(m.crossVersion)
 
   final class PluginClassLoader(p: ClassLoader) extends URLClassLoader(Array(), p) {
     private[this] val urlSet = new collection.mutable.HashSet[URI] // remember: don't use hashCode/equals on URL
diff --git a/main/src/main/scala/sbt/internal/PluginsDebug.scala b/main/src/main/scala/sbt/internal/PluginsDebug.scala
index 1f82640e3..d73cfcdc7 100644
--- a/main/src/main/scala/sbt/internal/PluginsDebug.scala
+++ b/main/src/main/scala/sbt/internal/PluginsDebug.scala
@@ -1,186 +1,293 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
 import sbt.internal.util.{ AttributeKey, Dag, Relation, Util }
 import sbt.util.Logger
 
-  import Def.Setting
-  import Plugins._
-  import PluginsDebug._
-  import java.net.URI
+import Def.Setting
+import sbt.SlashSyntax0._
+import Plugins._
+import PluginsDebug._
+import java.net.URI
 
-private[sbt] class PluginsDebug(val available: List[AutoPlugin], val nameToKey: Map[String, AttributeKey[_]], val provided: Relation[AutoPlugin, AttributeKey[_]]) {
-  /** The set of [[AutoPlugin]]s that might define a key named `keyName`.
-  * Because plugins can define keys in different scopes, this should only be used as a guideline. */
+private[sbt] class PluginsDebug(
+    val available: List[AutoPlugin],
+    val nameToKey: Map[String, AttributeKey[_]],
+    val provided: Relation[AutoPlugin, AttributeKey[_]]
+) {
+
+  /**
+   * The set of [[AutoPlugin]]s that might define a key named `keyName`.
+   * Because plugins can define keys in different scopes, this should only be used as a guideline.
+   */
   def providers(keyName: String): Set[AutoPlugin] = nameToKey.get(keyName) match {
-    case None => Set.empty
+    case None      => Set.empty
     case Some(key) => provided.reverse(key)
   }
-  /** Describes alternative approaches for defining key [[keyName]] in [[context]].*/
+
+  /** Describes alternative approaches for defining key `keyName` in [[Context]]. */
   def toEnable(keyName: String, context: Context): List[PluginEnable] =
     providers(keyName).toList.map(plugin => pluginEnable(context, plugin))
 
-  /** Provides text to suggest how [[notFoundKey]] can be defined in [[context]]. */
-  def debug(notFoundKey: String, context: Context): String =
-    {
-      val (activated, deactivated) = Util.separate(toEnable(notFoundKey, context)) {
-        case pa: PluginActivated => Left(pa)
-        case pd: EnableDeactivated => Right(pd)
-      }
-      val activePrefix = if(activated.nonEmpty) s"Some already activated plugins define $notFoundKey: ${activated.mkString(", ")}\n" else ""
-      activePrefix + debugDeactivated(notFoundKey, deactivated)
-    }
-  private[this] def debugDeactivated(notFoundKey: String, deactivated: Seq[EnableDeactivated]): String =
-    {
-      val (impossible, possible) = Util.separate(deactivated) {
-        case pi: PluginImpossible => Left(pi)
-        case pr: PluginRequirements => Right(pr)
-      }
-      if(possible.nonEmpty) {
-        val explained = possible.map(explainPluginEnable)
-        val possibleString =
-          if(explained.size > 1) explained.zipWithIndex.map{case (s,i) => s"$i. $s"}.mkString(s"Multiple plugins are available that can provide $notFoundKey:\n", "\n", "")
-          else s"$notFoundKey is provided by an available (but not activated) plugin:\n${explained.mkString}"
-        def impossiblePlugins = impossible.map(_.plugin.label).mkString(", ")
-        val imPostfix = if(impossible.isEmpty) "" else s"\n\nThere are other available plugins that provide $notFoundKey, but they are impossible to add: $impossiblePlugins"
-        possibleString + imPostfix
-      }
-      else if(impossible.isEmpty)
-        s"No available plugin provides key $notFoundKey."
-      else {
-        val explanations = impossible.map(explainPluginEnable)
-        explanations.mkString(s"Plugins are available that could provide $notFoundKey, but they are impossible to add:\n\t", "\n\t", "")
-      }
+  /** Provides text to suggest how `notFoundKey` can be defined in [[Context]]. */
+  def debug(notFoundKey: String, context: Context): String = {
+    val (activated, deactivated) = Util.separate(toEnable(notFoundKey, context)) {
+      case pa: PluginActivated   => Left(pa)
+      case pd: EnableDeactivated => Right(pd)
     }
+    val activePrefix =
+      if (activated.isEmpty) ""
+      else
+        s"Some already activated plugins define $notFoundKey: ${activated.mkString(", ")}\n"
+    activePrefix + debugDeactivated(notFoundKey, deactivated)
+  }
 
-  /** Text that suggests how to activate [[plugin]] in [[context]] if possible and if it is not already activated.*/
+  private[this] def debugDeactivated(
+      notFoundKey: String,
+      deactivated: Seq[EnableDeactivated]
+  ): String = {
+    val (impossible, possible) = Util.separate(deactivated) {
+      case pi: PluginImpossible   => Left(pi)
+      case pr: PluginRequirements => Right(pr)
+    }
+    if (possible.nonEmpty) {
+      val explained = possible.map(explainPluginEnable)
+      val possibleString =
+        if (explained.lengthCompare(1) > 0)
+          explained.zipWithIndex
+            .map { case (s, i) => s"$i. $s" }
+            .mkString(s"Multiple plugins are available that can provide $notFoundKey:\n", "\n", "")
+        else
+          s"$notFoundKey is provided by an available (but not activated) plugin:\n${explained.mkString}"
+      def impossiblePlugins = impossible.map(_.plugin.label).mkString(", ")
+      val imPostfix =
+        if (impossible.isEmpty) ""
+        else
+          s"\n\nThere are other available plugins that provide $notFoundKey, but they are " +
+            s"impossible to add: $impossiblePlugins"
+      possibleString + imPostfix
+    } else if (impossible.isEmpty)
+      s"No available plugin provides key $notFoundKey."
+    else {
+      val explanations = impossible.map(explainPluginEnable)
+      val preamble = s"Plugins are available that could provide $notFoundKey"
+      explanations.mkString(s"$preamble, but they are impossible to add:\n\t", "\n\t", "")
+    }
+  }
+
+  /** Text that suggests how to activate [[AutoPlugin]] in [[Context]] if possible and if it is not already activated. */
   def help(plugin: AutoPlugin, context: Context): String =
     if (context.enabled.contains(plugin)) activatedHelp(plugin)
     else deactivatedHelp(plugin, context)
-  private def activatedHelp(plugin: AutoPlugin): String =
-    {
-      val prefix = s"${plugin.label} is activated."
-      val keys = provided.forward(plugin)
-      val keysString = if(keys.isEmpty) "" else s"\nIt may affect these keys: ${multi(keys.toList.map(_.label))}"
-      val configs = plugin.projectConfigurations
-      val confsString = if(configs.isEmpty) "" else s"\nIt defines these configurations: ${multi(configs.map(_.name))}"
-      prefix + keysString + confsString
-    }
-  private def deactivatedHelp(plugin: AutoPlugin, context: Context): String =
-    {
-      val prefix = s"${plugin.label} is NOT activated."
-      val keys = provided.forward(plugin)
-      val keysString = if(keys.isEmpty) "" else s"\nActivating it may affect these keys: ${multi(keys.toList.map(_.label))}"
-      val configs = plugin.projectConfigurations
-      val confsString = if(configs.isEmpty) "" else s"\nActivating it will define these configurations: ${multi(configs.map(_.name))}"
-      val toActivate = explainPluginEnable(pluginEnable(context, plugin))
-      s"$prefix$keysString$confsString\n$toActivate"
-    }
 
-  private[this] def multi(strs: Seq[String]): String = strs.mkString(if(strs.size > 4) "\n\t" else ", ")
+  private def activatedHelp(plugin: AutoPlugin): String = {
+    val prefix = s"${plugin.label} is activated."
+    val keys = provided.forward(plugin)
+    val keysString =
+      if (keys.isEmpty) "" else s"\nIt may affect these keys: ${multi(keys.toList.map(_.label))}"
+    val configs = plugin.projectConfigurations
+    val confsString =
+      if (configs.isEmpty) ""
+      else s"\nIt defines these configurations: ${multi(configs.map(_.name))}"
+    prefix + keysString + confsString
+  }
+
+  private def deactivatedHelp(plugin: AutoPlugin, context: Context): String = {
+    val prefix = s"${plugin.label} is NOT activated."
+    val keys = provided.forward(plugin)
+    val keysString =
+      if (keys.isEmpty) ""
+      else s"\nActivating it may affect these keys: ${multi(keys.toList.map(_.label))}"
+    val configs = plugin.projectConfigurations
+    val confsString =
+      if (configs.isEmpty) ""
+      else s"\nActivating it will define these configurations: ${multi(configs.map(_.name))}"
+    val toActivate = explainPluginEnable(pluginEnable(context, plugin))
+    s"$prefix$keysString$confsString\n$toActivate"
+  }
+
+  private[this] def multi(strs: Seq[String]): String =
+    strs.mkString(if (strs.lengthCompare(4) > 0) "\n\t" else ", ")
 }
 
 private[sbt] object PluginsDebug {
   def helpAll(s: State): String =
-    if(Project.isProjectLoaded(s))
-      {
-        val extracted = Project.extract(s)
-        import extracted._
-        def helpBuild(uri: URI, build: LoadedBuildUnit): String =
-        {
-          val pluginStrings = for(plugin <- availableAutoPlugins(build)) yield {
-            val activatedIn = build.defined.values.toList.filter(_.autoPlugins.contains(plugin)).map(_.id)
-            val actString = if(activatedIn.nonEmpty) activatedIn.mkString(": enabled in ", ", ", "") else "" // TODO: deal with large builds
-            s"\n\t${plugin.label}$actString"
+    if (Project.isProjectLoaded(s)) {
+      val extracted = Project.extract(s)
+      import extracted._
+
+      def helpBuild(build: LoadedBuildUnit): String =
+        build.projects.toList
+          .sortBy(_.id)
+          .map { p =>
+            import p.autoPlugins
+            val `s?` = if (autoPlugins.length > 1) "s" else ""
+
+            new StringBuilder()
+              .append(s"  Enabled plugin${`s?`} in ${Highlight.bold(p.id)}:\n")
+              .append {
+                autoPlugins.map(_.label).sorted.mkString("    ", s"\n    ", "")
+              }
+              .toString
+          }
+          .mkString("\n")
+          .concat {
+            val autoPlugins = availableAutoPlugins(build)
+            val notEnabledPlugins =
+              autoPlugins.filter(p => build.projects.forall(!_.autoPlugins.contains(p)))
+            if (notEnabledPlugins.nonEmpty) {
+              val message = notEnabledPlugins.map(_.label).sorted.mkString("  ", "\n  ", "")
+              "\nPlugins that are loaded to the build but not enabled in any subprojects:\n" + message
+            } else ""
           }
-          s"In $uri${pluginStrings.mkString}"
-        }
-        val buildStrings = for((uri, build) <- structure.units) yield helpBuild(uri, build)
-        buildStrings.mkString("\n")
-      }
-    else "No project is currently loaded."
 
-  def autoPluginMap(s: State): Map[String, AutoPlugin] =
-    {
-      val extracted = Project.extract(s)
-      import extracted._
-      structure.units.values.toList.flatMap(availableAutoPlugins).map(plugin => (plugin.label, plugin)).toMap
-    }
+      val buildStrings = for {
+        (uri, build) <- structure.units
+      } yield s"In build ${uri.getPath}:\n${helpBuild(build)}"
+      buildStrings.mkString("\n")
+    } else "No project is currently loaded."
+
+  def autoPluginMap(s: State): Map[String, AutoPlugin] = {
+    val extracted = Project.extract(s)
+    import extracted._
+    structure.units.values.toList
+      .flatMap(availableAutoPlugins)
+      .map(plugin => (plugin.label, plugin))
+      .toMap
+  }
+
   private[this] def availableAutoPlugins(build: LoadedBuildUnit): Seq[AutoPlugin] =
-    build.unit.plugins.detected.autoPlugins map {_.value}
+    build.unit.plugins.detected.autoPlugins map { _.value }
 
-  def help(plugin: AutoPlugin, s: State): String =
-    {
-      val extracted = Project.extract(s)
-      import extracted._
-      def definesPlugin(p: ResolvedProject): Boolean = p.autoPlugins.contains(plugin)
-      def projectForRef(ref: ProjectRef): ResolvedProject = get(Keys.thisProject in ref)
-      val perBuild: Map[URI, Set[AutoPlugin]] = structure.units.mapValues(unit => availableAutoPlugins(unit).toSet)
-      val pluginsThisBuild = perBuild.getOrElse(currentRef.build, Set.empty).toList
-      lazy val context = Context(currentProject.plugins, currentProject.autoPlugins, Plugins.deducer(pluginsThisBuild), pluginsThisBuild, s.log)
-      lazy val debug = PluginsDebug(context.available)
-      if(!pluginsThisBuild.contains(plugin)) {
-        val availableInBuilds: List[URI] = perBuild.toList.filter(_._2(plugin)).map(_._1)
-        s"Plugin ${plugin.label} is only available in builds:\n\t${availableInBuilds.mkString("\n\t")}\nSwitch to a project in one of those builds using `project` and rerun this command for more information."
-      } else if(definesPlugin(currentProject))
-        debug.activatedHelp(plugin)
-      else {
-        val thisAggregated = BuildUtil.dependencies(structure.units).aggregateTransitive.getOrElse(currentRef, Nil)
-        val definedInAggregated = thisAggregated.filter(ref => definesPlugin(projectForRef(ref)))
-        if(definedInAggregated.nonEmpty) {
-          val projectNames = definedInAggregated.map(_.project) // TODO: usually in this build, but could technically require the build to be qualified
-          s"Plugin ${plugin.label} is not activated on this project, but this project aggregates projects where it is activated:\n\t${projectNames.mkString("\n\t")}"
-        } else {
-          val base = debug.deactivatedHelp(plugin, context)
-          val aggNote = if(thisAggregated.nonEmpty) "Note: This project aggregates other projects and this" else "Note: This"
-          val common =  " information is for this project only."
-          val helpOther = "To see how to activate this plugin for another project, change to the project using `project <name>` and rerun this command."
-          s"$base\n$aggNote$common\n$helpOther"
-        }
+  def help(plugin: AutoPlugin, s: State): String = {
+    val extracted = Project.extract(s)
+    import extracted._
+    def definesPlugin(p: ResolvedProject): Boolean = p.autoPlugins.contains(plugin)
+    def projectForRef(ref: ProjectRef): ResolvedProject = get(ref / Keys.thisProject)
+    val perBuild: Map[URI, Set[AutoPlugin]] =
+      structure.units.mapValues(unit => availableAutoPlugins(unit).toSet).toMap
+    val pluginsThisBuild = perBuild.getOrElse(currentRef.build, Set.empty).toList
+    lazy val context = Context(
+      currentProject.plugins,
+      currentProject.autoPlugins,
+      Plugins.deducer(pluginsThisBuild),
+      pluginsThisBuild,
+      s.log
+    )
+    lazy val debug = PluginsDebug(context.available)
+    if (!pluginsThisBuild.contains(plugin)) {
+      val availableInBuilds: List[URI] = perBuild.toList.filter(_._2(plugin)).map(_._1)
+      val s1 = s"Plugin ${plugin.label} is only available in builds:"
+      val s2 = availableInBuilds.mkString("\n\t")
+      val s3 =
+        s"Switch to a project in one of those builds using `project` and rerun this command for more information."
+      s"$s1\n\t$s2\n$s3"
+    } else if (definesPlugin(currentProject))
+      debug.activatedHelp(plugin)
+    else {
+      val thisAggregated =
+        BuildUtil.dependencies(structure.units).aggregateTransitive.getOrElse(currentRef, Nil)
+      val definedInAggregated = thisAggregated.filter(ref => definesPlugin(projectForRef(ref)))
+      if (definedInAggregated.nonEmpty) {
+        val projectNames = definedInAggregated.map(_.project) // TODO: usually in this build, but could technically require the build to be qualified
+        val s2 = projectNames.mkString("\n\t")
+        s"Plugin ${plugin.label} is not activated on this project, but this project aggregates projects where it is activated:\n\t$s2"
+      } else {
+        val base = debug.deactivatedHelp(plugin, context)
+        val aggNote =
+          if (thisAggregated.nonEmpty) "Note: This project aggregates other projects and this"
+          else "Note: This"
+        val common = " information is for this project only."
+        val helpOther =
+          "To see how to activate this plugin for another project, change to the project using `project <name>` and rerun this command."
+        s"$base\n$aggNote$common\n$helpOther"
       }
     }
+  }
 
-  /** Precomputes information for debugging plugins. */
-  def apply(available: List[AutoPlugin]): PluginsDebug =
-    {
-      val keyR = definedKeys(available)
-      val nameToKey: Map[String, AttributeKey[_]] = keyR._2s.toList.map(key => (key.label, key)).toMap
-      new PluginsDebug(available, nameToKey, keyR)
-    }
+  /** Pre-computes information for debugging plugins. */
+  def apply(available: List[AutoPlugin]): PluginsDebug = {
+    val keyR = definedKeys(available)
+    val nameToKey: Map[String, AttributeKey[_]] =
+      keyR._2s.toList.map(key => (key.label, key)).toMap
+    new PluginsDebug(available, nameToKey, keyR)
+  }
 
-  /** The context for debugging a plugin (de)activation.
-  * @param initial The initially defined [[AutoPlugin]]s.
-  * @param enabled The resulting model.
-  * @param deducePlugin The function used to compute the model.
-  * @param available All [[AutoPlugin]]s available for consideration. */
-  final case class Context(initial: Plugins, enabled: Seq[AutoPlugin], deducePlugin: (Plugins, Logger) => Seq[AutoPlugin], available: List[AutoPlugin], log: Logger)
+  /**
+   * The context for debugging a plugin (de)activation.
+   * @param initial The initially defined [[AutoPlugin]]s.
+   * @param enabled The resulting model.
+   * @param deducePlugin The function used to compute the model.
+   * @param available All [[AutoPlugin]]s available for consideration.
+   */
+  final case class Context(
+      initial: Plugins,
+      enabled: Seq[AutoPlugin],
+      deducePlugin: (Plugins, Logger) => Seq[AutoPlugin],
+      available: List[AutoPlugin],
+      log: Logger
+  )
 
   /** Describes the steps to activate a plugin in some context. */
   sealed abstract class PluginEnable
+
   /** Describes a [[plugin]] that is already activated in the [[context]].*/
   final case class PluginActivated(plugin: AutoPlugin, context: Context) extends PluginEnable
+
   sealed abstract class EnableDeactivated extends PluginEnable
+
   /** Describes a [[plugin]] that cannot be activated in a [[context]] due to [[contradictions]] in requirements. */
-  final case class PluginImpossible(plugin: AutoPlugin, context: Context, contradictions: Set[AutoPlugin]) extends EnableDeactivated
+  final case class PluginImpossible(
+      plugin: AutoPlugin,
+      context: Context,
+      contradictions: Set[AutoPlugin]
+  ) extends EnableDeactivated
 
-  /** Describes the requirements for activating [[plugin]] in [[context]].
-  * @param context The base plugins, exclusions, and ultimately activated plugins
-  * @param blockingExcludes Existing exclusions that prevent [[plugin]] from being activated and must be dropped
-  * @param enablingPlugins [[AutoPlugin]]s that are not currently enabled, but need to be enabled for [[plugin]] to activate
-  * @param extraEnabledPlugins Plugins that will be enabled as a result of [[plugin]] activating, but are not required for [[plugin]] to activate
-  * @param willRemove Plugins that will be deactivated as a result of [[plugin]] activating
-  * @param deactivate Describes plugins that must be deactivated for [[plugin]] to activate.  These require an explicit exclusion or dropping a transitive [[AutoPlugin]].*/
-  final case class PluginRequirements(plugin: AutoPlugin, context: Context, blockingExcludes: Set[AutoPlugin], enablingPlugins: Set[AutoPlugin], extraEnabledPlugins: Set[AutoPlugin], willRemove: Set[AutoPlugin], deactivate: List[DeactivatePlugin]) extends EnableDeactivated
+  /**
+   * Describes the requirements for activating [[plugin]] in [[context]].
+   * @param context The base plugins, exclusions, and ultimately activated plugins
+   * @param blockingExcludes Existing exclusions that prevent [[plugin]] from being activated and must be dropped
+   * @param enablingPlugins [[AutoPlugin]]s that are not currently enabled,
+   *                        but need to be enabled for [[plugin]] to activate
+   * @param extraEnabledPlugins Plugins that will be enabled as a result of [[plugin]] activating,
+   *                            but are not required for [[plugin]] to activate
+   * @param willRemove Plugins that will be deactivated as a result of [[plugin]] activating
+   * @param deactivate Describes plugins that must be deactivated for [[plugin]] to activate.
+   *                   These require an explicit exclusion or dropping a transitive [[AutoPlugin]].
+   */
+  final case class PluginRequirements(
+      plugin: AutoPlugin,
+      context: Context,
+      blockingExcludes: Set[AutoPlugin],
+      enablingPlugins: Set[AutoPlugin],
+      extraEnabledPlugins: Set[AutoPlugin],
+      willRemove: Set[AutoPlugin],
+      deactivate: List[DeactivatePlugin]
+  ) extends EnableDeactivated
 
-  /** Describes a [[plugin]] that must be removed in order to activate another plugin in some context.
-  * The [[plugin]] can always be directly, explicitly excluded.
-  * @param removeOneOf If non-empty, removing one of these [[AutoPlugin]]s will deactivate [[plugin]] without affecting the other plugin.  If empty, a direct exclusion is required.
-  * @param newlySelected If false, this plugin was selected in the original context.  */
-  final case class DeactivatePlugin(plugin: AutoPlugin, removeOneOf: Set[AutoPlugin], newlySelected: Boolean)
+  /**
+   * Describes a [[plugin]] that must be removed in order to activate another plugin in some context.
+   * The [[plugin]] can always be directly, explicitly excluded.
+   * @param removeOneOf If non-empty, removing one of these [[AutoPlugin]]s will deactivate [[plugin]] without
+   *                    affecting the other plugin.  If empty, a direct exclusion is required.
+   * @param newlySelected If false, this plugin was selected in the original context.
+   */
+  final case class DeactivatePlugin(
+      plugin: AutoPlugin,
+      removeOneOf: Set[AutoPlugin],
+      newlySelected: Boolean
+  )
 
-  /** Determines how to enable [[plugin]] in [[context]]. */
+  /** Determines how to enable [[AutoPlugin]] in [[Context]]. */
   def pluginEnable(context: Context, plugin: AutoPlugin): PluginEnable =
-    if(context.enabled.contains(plugin))
+    if (context.enabled.contains(plugin))
       PluginActivated(plugin, context)
     else
       enableDeactivated(context, plugin)
@@ -208,7 +315,7 @@ private[sbt] object PluginsDebug {
     C :- B
     initial: <empty>
     propose: B, exclude C
-    */
+     */
 
     // `plugin` will only be activated when all of these plugins are activated
     // Deactivating any one of these would deactivate `plugin`.
@@ -230,14 +337,17 @@ private[sbt] object PluginsDebug {
       val blockingExcludes = initialExcludes & minRequiredPlugins
 
       // The model that results when the minimal plugins are enabled and the minimal plugins are excluded.
-      //  This can include more plugins than just `minRequiredPlugins` because the plguins required for `plugin`
+      //  This can include more plugins than just `minRequiredPlugins` because the plugins required for `plugin`
       //  might activate other plugins as well.
-      val incrementalInputs = and(includeAll(minRequiredPlugins ++ initialPlugins), excludeAll(minAbsentPlugins ++ initialExcludes -- minRequiredPlugins))
+      val incrementalInputs = and(
+        includeAll(minRequiredPlugins ++ initialPlugins),
+        excludeAll(minAbsentPlugins ++ initialExcludes -- minRequiredPlugins)
+      )
       val incrementalModel = context.deducePlugin(incrementalInputs, context.log).toSet
 
       // Plugins that are newly enabled as a result of selecting the plugins needed for `plugin`, but aren't strictly required for `plugin`.
       //   These could be excluded and `plugin` and the user's current plugins would still be activated.
-      val extraPlugins = incrementalModel.toSet -- minRequiredPlugins -- initialModel
+      val extraPlugins = incrementalModel -- minRequiredPlugins -- initialModel
 
       // Plugins that will no longer be enabled as a result of enabling `plugin`.
       val willRemove = initialModel -- incrementalModel
@@ -246,9 +356,10 @@ private[sbt] object PluginsDebug {
       // If both A and B must be deactivated, but A transitively depends on B, deactivating B will deactivate A.
       // If A must be deactivated, but one if its (transitively) required plugins isn't present, it won't be activated.
       //   So, in either of these cases, A doesn't need to be considered further and won't be included in this set.
-      val minDeactivate = minAbsentPlugins.filter(p => Plugins.satisfied(p.requires, incrementalModel))
+      val minDeactivate =
+        minAbsentPlugins.filter(p => Plugins.satisfied(p.requires, incrementalModel))
 
-      val deactivate = for(d <- minDeactivate.toList) yield {
+      val deactivate = for (d <- minDeactivate.toList) yield {
         // removing any one of these plugins will deactivate `d`.  TODO: This is not an especially efficient implementation.
         val removeToDeactivate = plugins(minimalModel(d)) -- minRequiredPlugins
         val newlySelected = !initialModel(d)
@@ -258,69 +369,95 @@ private[sbt] object PluginsDebug {
         DeactivatePlugin(d, removeToDeactivate, newlySelected)
       }
 
-      PluginRequirements(plugin, context, blockingExcludes, addToExistingPlugins, extraPlugins, willRemove, deactivate)
+      PluginRequirements(
+        plugin,
+        context,
+        blockingExcludes,
+        addToExistingPlugins,
+        extraPlugins,
+        willRemove,
+        deactivate
+      )
     }
   }
 
   private[this] def includeAll[T <: Basic](basic: Set[T]): Plugins = And(basic.toList)
-  private[this] def excludeAll(plugins: Set[AutoPlugin]): Plugins = And(plugins map (p => Exclude(p)) toList)
+  private[this] def excludeAll(plugins: Set[AutoPlugin]): Plugins =
+    And(plugins map (p => Exclude(p)) toList)
 
-  private[this] def excludes(bs: Seq[Basic]): Set[AutoPlugin] = bs.collect { case Exclude(b) => b }.toSet
-  private[this] def plugins(bs: Seq[Basic]): Set[AutoPlugin] = bs.collect { case n: AutoPlugin => n }.toSet
+  private[this] def excludes(bs: Seq[Basic]): Set[AutoPlugin] =
+    bs.collect { case Exclude(b) => b }.toSet
+  private[this] def plugins(bs: Seq[Basic]): Set[AutoPlugin] =
+    bs.collect { case n: AutoPlugin => n }.toSet
 
   // If there is a model that includes `plugin`, it includes at least what is returned by this method.
   // This is the list of plugins that must be included as well as list of plugins that must not be present.
   // It might not be valid, such as if there are contradictions or if there are cycles that are unsatisfiable.
   // The actual model might be larger, since other plugins might be enabled by the selected plugins.
-  private[this] def minimalModel(plugin: AutoPlugin): Seq[Basic] = Dag.topologicalSortUnchecked(plugin: Basic) {
-    case _: Exclude  => Nil
-    case ap: AutoPlugin => Plugins.flatten(ap.requires) :+ plugin
-  }
+  private[this] def minimalModel(plugin: AutoPlugin): Seq[Basic] =
+    Dag.topologicalSortUnchecked(plugin: Basic) {
+      case _: Exclude     => Nil
+      case ap: AutoPlugin => Plugins.flatten(ap.requires) :+ plugin
+    }
 
   /** String representation of [[PluginEnable]], intended for end users. */
   def explainPluginEnable(ps: PluginEnable): String =
     ps match {
-      case PluginRequirements(plugin, context, blockingExcludes, enablingPlugins, extraEnabledPlugins, toBeRemoved, deactivate) =>
-        def indent(str: String) = if(str.isEmpty) "" else s"\t$str"
-        def note(str: String) = if(str.isEmpty) "" else s"Note: $str"
+      case PluginRequirements(
+          plugin,
+          _,
+          blockingExcludes,
+          enablingPlugins,
+          extraEnabledPlugins,
+          toBeRemoved,
+          deactivate
+          ) =>
+        def indent(str: String) = if (str.isEmpty) "" else s"\t$str"
+        def note(str: String) = if (str.isEmpty) "" else s"Note: $str"
         val parts =
           indent(excludedError(false /* TODO */, blockingExcludes.toList)) ::
-          indent(required(enablingPlugins.toList)) ::
-          indent(needToDeactivate(deactivate)) ::
-          note(willAdd(plugin, extraEnabledPlugins.toList)) ::
-          note(willRemove(plugin, toBeRemoved.toList)) ::
-          Nil
+            indent(required(enablingPlugins.toList)) ::
+            indent(needToDeactivate(deactivate)) ::
+            note(willAdd(plugin, extraEnabledPlugins.toList)) ::
+            note(willRemove(plugin, toBeRemoved.toList)) ::
+            Nil
         parts.filterNot(_.isEmpty).mkString("\n")
-      case PluginImpossible(plugin, context, contradictions) => pluginImpossible(plugin, contradictions)
-      case PluginActivated(plugin, context) => s"Plugin ${plugin.label} already activated."
+      case PluginImpossible(plugin, _, contradictions) => pluginImpossible(plugin, contradictions)
+      case PluginActivated(plugin, _)                  => s"Plugin ${plugin.label} already activated."
     }
 
-  /** Provides a [[Relation]] between plugins and the keys they potentially define.
-  * Because plugins can define keys in different scopes and keys can be overridden, this is not definitive.*/
-  def definedKeys(available: List[AutoPlugin]): Relation[AutoPlugin, AttributeKey[_]] =
-    {
-      def extractDefinedKeys(ss: Seq[Setting[_]]): Seq[AttributeKey[_]] =
-        ss.map(_.key.key)
-      def allSettings(p: AutoPlugin): Seq[Setting[_]] = p.projectSettings ++ p.buildSettings ++ p.globalSettings
-      val empty = Relation.empty[AutoPlugin, AttributeKey[_]]
-      (empty /: available)( (r,p) => r + (p, extractDefinedKeys(allSettings(p))) )
-    }
+  /**
+   * Provides a [[Relation]] between plugins and the keys they potentially define.
+   * Because plugins can define keys in different scopes and keys can be overridden, this is not definitive.
+   */
+  def definedKeys(available: List[AutoPlugin]): Relation[AutoPlugin, AttributeKey[_]] = {
+    def extractDefinedKeys(ss: Seq[Setting[_]]): Seq[AttributeKey[_]] =
+      ss.map(_.key.key)
+    def allSettings(p: AutoPlugin): Seq[Setting[_]] =
+      p.projectSettings ++ p.buildSettings ++ p.globalSettings
+    val empty = Relation.empty[AutoPlugin, AttributeKey[_]]
+    available.foldLeft(empty)((r, p) => r + (p, extractDefinedKeys(allSettings(p))))
+  }
 
   private[this] def excludedError(transitive: Boolean, dependencies: List[AutoPlugin]): String =
     str(dependencies)(excludedPluginError(transitive), excludedPluginsError(transitive))
 
   private[this] def excludedPluginError(transitive: Boolean)(dependency: AutoPlugin) =
     s"Required ${transitiveString(transitive)}dependency ${dependency.label} was excluded."
+
   private[this] def excludedPluginsError(transitive: Boolean)(dependencies: List[AutoPlugin]) =
-    s"Required ${transitiveString(transitive)}dependencies were excluded:\n\t${labels(dependencies).mkString("\n\t")}"
+    s"Required ${transitiveString(transitive)}dependencies were excluded:\n\t${labels(dependencies)
+      .mkString("\n\t")}"
+
   private[this] def transitiveString(transitive: Boolean) =
-    if(transitive) "(transitive) " else ""
+    if (transitive) "(transitive) " else ""
 
   private[this] def required(plugins: List[AutoPlugin]): String =
     str(plugins)(requiredPlugin, requiredPlugins)
 
   private[this] def requiredPlugin(plugin: AutoPlugin) =
     s"Required plugin ${plugin.label} not present."
+
   private[this] def requiredPlugins(plugins: List[AutoPlugin]) =
     s"Required plugins not present:\n\t${plugins.map(_.label).mkString("\n\t")}"
 
@@ -336,6 +473,7 @@ private[sbt] object PluginsDebug {
 
   private[this] def willAddPlugin(base: AutoPlugin)(plugin: AutoPlugin) =
     s"Enabling ${base.label} will also enable ${plugin.label}"
+
   private[this] def willAddPlugins(base: AutoPlugin)(plugins: List[AutoPlugin]) =
     s"Enabling ${base.label} will also enable:\n\t${labels(plugins).mkString("\n\t")}"
 
@@ -344,6 +482,7 @@ private[sbt] object PluginsDebug {
 
   private[this] def willRemovePlugin(base: AutoPlugin)(plugin: AutoPlugin) =
     s"Enabling ${base.label} will disable ${plugin.label}"
+
   private[this] def willRemovePlugins(base: AutoPlugin)(plugins: List[AutoPlugin]) =
     s"Enabling ${base.label} will disable:\n\t${labels(plugins).mkString("\n\t")}"
 
@@ -352,26 +491,40 @@ private[sbt] object PluginsDebug {
 
   private[this] def needToDeactivate(deactivate: List[DeactivatePlugin]): String =
     str(deactivate)(deactivate1, deactivateN)
+
   private[this] def deactivateN(plugins: List[DeactivatePlugin]): String =
     plugins.map(deactivateString).mkString("These plugins need to be deactivated:\n\t", "\n\t", "")
+
   private[this] def deactivate1(deactivate: DeactivatePlugin): String =
     s"Need to deactivate ${deactivateString(deactivate)}"
-  private[this] def deactivateString(d: DeactivatePlugin): String =
-    {
-      val removePluginsString: String =
-        d.removeOneOf.toList match {
-          case Nil => ""
-          case x :: Nil => s" or no longer include $x"
-          case xs => s" or remove one of ${xs.mkString(", ")}"
-        }
-      s"${d.plugin.label}: directly exclude it${removePluginsString}"
-    }
+
+  private[this] def deactivateString(d: DeactivatePlugin): String = {
+    val removePluginsString: String =
+      d.removeOneOf.toList match {
+        case Nil      => ""
+        case x :: Nil => s" or no longer include $x"
+        case xs       => s" or remove one of ${xs.mkString(", ")}"
+      }
+    s"${d.plugin.label}: directly exclude it${removePluginsString}"
+  }
 
   private[this] def pluginImpossible(plugin: AutoPlugin, contradictions: Set[AutoPlugin]): String =
     str(contradictions.toList)(pluginImpossible1(plugin), pluginImpossibleN(plugin))
 
-  private[this] def pluginImpossible1(plugin: AutoPlugin)(contradiction: AutoPlugin): String =
-    s"There is no way to enable plugin ${plugin.label}.  It (or its dependencies) requires plugin ${contradiction.label} to both be present and absent.  Please report the problem to the plugin's author."
-  private[this] def pluginImpossibleN(plugin: AutoPlugin)(contradictions: List[AutoPlugin]): String =
-    s"There is no way to enable plugin ${plugin.label}.  It (or its dependencies) requires these plugins to be both present and absent:\n\t${labels(contradictions).mkString("\n\t")}\nPlease report the problem to the plugin's author."
+  private[this] def pluginImpossible1(plugin: AutoPlugin)(contradiction: AutoPlugin): String = {
+    val s1 = s"There is no way to enable plugin ${plugin.label}."
+    val s2 =
+      s"It (or its dependencies) requires plugin ${contradiction.label} to both be present and absent."
+    val s3 = s"Please report the problem to the plugin's author."
+    s"$s1  $s2  $s3"
+  }
+
+  private[this] def pluginImpossibleN(
+      plugin: AutoPlugin
+  )(contradictions: List[AutoPlugin]): String = {
+    val s1 = s"There is no way to enable plugin ${plugin.label}."
+    val s2 = s"It (or its dependencies) requires these plugins to be both present and absent:"
+    val s3 = s"Please report the problem to the plugin's author."
+    s"$s1  $s2:\n\t${labels(contradictions).mkString("\n\t")}\n$s3"
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/PrettyPrint.scala b/main/src/main/scala/sbt/internal/PrettyPrint.scala
new file mode 100644
index 000000000..04683313b
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/PrettyPrint.scala
@@ -0,0 +1,15 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+private[sbt] object PrettyPrint {
+  private[sbt] def indent(any: Any, level: Int): String = {
+    val i = " " * level
+    any.toString.linesIterator.mkString(i, "\n" + i, "")
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/ProjectNavigation.scala b/main/src/main/scala/sbt/internal/ProjectNavigation.scala
index c254505f5..b8cd6168c 100644
--- a/main/src/main/scala/sbt/internal/ProjectNavigation.scala
+++ b/main/src/main/scala/sbt/internal/ProjectNavigation.scala
@@ -1,32 +1,36 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010, 2011  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
-import sbt.internal.util.complete
-
-import Project.updateCurrent
-import Keys.sessionSettings
-import complete.{ DefaultParsers, Parser }
-import DefaultParsers._
 import java.net.URI
+import sbt.internal.util.complete, complete.{ DefaultParsers, Parser }, DefaultParsers._
+import sbt.compiler.Eval
+import Keys.sessionSettings
+import Project.updateCurrent
 
 object ProjectNavigation {
   def command(s: State): Parser[() => State] =
-    if (s get sessionSettings isEmpty) failure("No project loaded") else (new ProjectNavigation(s)).command
+    if (s get sessionSettings isEmpty) failure("No project loaded")
+    else (new ProjectNavigation(s)).command
 }
+
 final class ProjectNavigation(s: State) {
-  val extracted = Project extract s
+  val extracted: Extracted = Project extract s
   import extracted.{ currentRef, structure, session }
 
-  def setProject(nuri: URI, nid: String) =
-    {
-      val neval = if (currentRef.build == nuri) session.currentEval else mkEval(nuri)
-      updateCurrent(s.put(sessionSettings, session.setCurrent(nuri, nid, neval)))
-    }
-  def mkEval(nuri: URI) = Load.lazyEval(structure.units(nuri).unit)
-  def getRoot(uri: URI) = Load.getRootProject(structure.units)(uri)
+  def setProject(nuri: URI, nid: String): State = {
+    val neval = if (currentRef.build == nuri) session.currentEval else mkEval(nuri)
+    updateCurrent(s.put(sessionSettings, session.setCurrent(nuri, nid, neval)))
+  }
+
+  def mkEval(nuri: URI): () => Eval = Load.lazyEval(structure.units(nuri).unit)
+  def getRoot(uri: URI): String = Load.getRootProject(structure.units)(uri)
 
   def apply(action: Option[ResolvedReference]): State =
     action match {
@@ -38,12 +42,15 @@ final class ProjectNavigation(s: State) {
 				if(to.length > 1) gotoParent(to.length - 1, nav, s) else s */ // semantics currently undefined
     }
 
-  def show(): Unit = s.log.info(currentRef.project + " (in build " + currentRef.build + ")")
+  def show(): Unit = s.log.info(s"${currentRef.project} (in build ${currentRef.build})")
+
   def selectProject(uri: URI, to: String): State =
     if (structure.units(uri).defined.contains(to))
       setProject(uri, to)
     else
-      fail("Invalid project name '" + to + "' in build " + uri + " (type 'projects' to list available projects).")
+      fail(
+        s"Invalid project name '$to' in build $uri (type 'projects' to list available projects)."
+      )
 
   def changeBuild(newBuild: URI): State =
     if (structure.units contains newBuild)
@@ -51,21 +58,17 @@ final class ProjectNavigation(s: State) {
     else
       fail("Invalid build unit '" + newBuild + "' (type 'projects' to list available builds).")
 
-  def fail(msg: String): State =
-    {
-      s.log.error(msg)
-      s.fail
-    }
+  def fail(msg: String): State = { s.log.error(msg); s.fail }
 
-  import complete.Parser._
-  import complete.Parsers._
+  import Parser._, complete.Parsers._
+
+  val parser: Parser[Option[ResolvedReference]] = {
+    val reference = Act.resolvedReference(structure.index.keyIndex, currentRef.build, success(()))
+    val root = token('/' ^^^ rootRef)
+    success(None) | some(token(Space) ~> (root | reference))
+  }
 
-  val parser: Parser[Option[ResolvedReference]] =
-    {
-      val reference = Act.resolvedReference(structure.index.keyIndex, currentRef.build, success(()))
-      val root = token('/' ^^^ rootRef)
-      success(None) | some(token(Space) ~> (root | reference))
-    }
   def rootRef = ProjectRef(currentRef.build, getRoot(currentRef.build))
+
   val command: Parser[() => State] = Command.applyEffect(parser)(apply)
 }
diff --git a/main/src/main/scala/sbt/internal/RelayAppender.scala b/main/src/main/scala/sbt/internal/RelayAppender.scala
new file mode 100644
index 000000000..2e61daa7c
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/RelayAppender.scala
@@ -0,0 +1,25 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import sbt.internal.util._
+import sbt.protocol.LogEvent
+import sbt.util.Level
+
+class RelayAppender(override val name: String)
+    extends ConsoleAppender(
+      name,
+      ConsoleAppender.Properties.from(ConsoleOut.NullConsoleOut, true, true),
+      _ => None
+    ) {
+  lazy val exchange = StandardMain.exchange
+  override def appendLog(level: Level.Value, message: => String): Unit = {
+    exchange.logMessage(LogEvent(level = level.toString, message = message))
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/RemoteCache.scala b/main/src/main/scala/sbt/internal/RemoteCache.scala
new file mode 100644
index 000000000..6e46f607f
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/RemoteCache.scala
@@ -0,0 +1,441 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.File
+import java.nio.file.Path
+import Keys._
+import SlashSyntax0._
+import ScopeFilter.Make._
+import Project._ // for tag and inTask()
+
+import org.apache.ivy.core.module.descriptor.{ Artifact => IArtifact, DefaultArtifact }
+import org.apache.ivy.core.resolve.DownloadOptions
+import org.apache.ivy.core.report.DownloadStatus
+import org.apache.ivy.plugins.resolver.DependencyResolver
+import std.TaskExtra._ // for join
+import sbt.coursierint.LMCoursier
+import sbt.librarymanagement._
+import sbt.librarymanagement.ivy.{ Credentials, IvyPaths, UpdateOptions }
+import sbt.librarymanagement.syntax._
+import sbt.nio.FileStamp
+import sbt.nio.Keys.{ inputFileStamps, outputFileStamps }
+import sbt.internal.librarymanagement._
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.internal.remotecache._
+import sbt.internal.inc.{ HashUtil, JarUtils }
+import sbt.util.InterfaceUtil.toOption
+import sbt.util.Logger
+import scala.annotation.nowarn
+
+object RemoteCache {
+  final val cachedCompileClassifier = "cached-compile"
+  final val cachedTestClassifier = "cached-test"
+  final val commitLength = 10
+
+  def gitCommitId: String =
+    scala.sys.process.Process("git rev-parse HEAD").!!.trim.take(commitLength)
+
+  def gitCommitIds(n: Int): List[String] =
+    scala.sys.process
+      .Process("git log -n " + n.toString + " --format=%H")
+      .!!
+      .linesIterator
+      .toList
+      .map(_.take(commitLength))
+
+  lazy val defaultCacheLocation: File = SysProp.globalLocalCache
+
+  lazy val globalSettings: Seq[Def.Setting[_]] = Seq(
+    remoteCacheId := "",
+    remoteCacheIdCandidates := Nil,
+    pushRemoteCacheTo :== None,
+    localCacheDirectory :== defaultCacheLocation,
+    pushRemoteCache / ivyPaths := {
+      val app = appConfiguration.value
+      val base = app.baseDirectory.getCanonicalFile
+      // base is used only to resolve relative paths, which should never happen
+      IvyPaths(base, localCacheDirectory.value)
+    },
+  )
+
+  lazy val projectSettings: Seq[Def.Setting[_]] = (Seq(
+    pushRemoteCache := (Def.taskDyn {
+      val arts = (pushRemoteCacheConfiguration / remoteCacheArtifacts).value
+      val configs = arts flatMap { art =>
+        art.packaged.scopedKey.scope match {
+          case Scope(_, Select(c), _, _) => Some(c)
+          case _                         => None
+        }
+      }
+      val filter = ScopeFilter(configurations = inConfigurationsByKeys(configs: _*))
+      Def.task {
+        val _ = pushRemoteCache.all(filter).value
+        ()
+      }
+    }).value,
+    pullRemoteCache := (Def.taskDyn {
+      val arts = (pushRemoteCacheConfiguration / remoteCacheArtifacts).value
+      val configs = arts flatMap { art =>
+        art.packaged.scopedKey.scope match {
+          case Scope(_, Select(c), _, _) => Some(c)
+          case _                         => None
+        }
+      }
+      val filter = ScopeFilter(configurations = inConfigurationsByKeys(configs: _*))
+      Def.task {
+        val _ = pullRemoteCache.all(filter).value
+        ()
+      }
+    }).value,
+    pushRemoteCacheConfiguration / remoteCacheArtifacts := {
+      enabledOnly(remoteCacheArtifact.toSettingKey, defaultArtifactTasks).apply(_.join).value
+    },
+    pushRemoteCacheConfiguration / publishMavenStyle := true,
+    Compile / packageCache / pushRemoteCacheArtifact := true,
+    Test / packageCache / pushRemoteCacheArtifact := true,
+    Compile / packageCache / artifact := Artifact(moduleName.value, cachedCompileClassifier),
+    Test / packageCache / artifact := Artifact(moduleName.value, cachedTestClassifier),
+    remoteCachePom / pushRemoteCacheArtifact := true,
+    remoteCachePom := {
+      val s = streams.value
+      val config = (remoteCachePom / makePomConfiguration).value
+      val publisher = Keys.publisher.value
+      publisher.makePomFile((pushRemoteCache / ivyModule).value, config, s.log)
+      config.file.get
+    },
+    remoteCachePom / artifactPath := {
+      Defaults.prefixArtifactPathSetting(makePom / artifact, "remote-cache").value
+    },
+    remoteCachePom / makePomConfiguration := {
+      val config = makePomConfiguration.value
+      config.withFile((remoteCachePom / artifactPath).value)
+    },
+    remoteCachePom / remoteCacheArtifact := {
+      PomRemoteCacheArtifact((makePom / artifact).value, remoteCachePom)
+    },
+    remoteCacheResolvers := pushRemoteCacheTo.value.toVector,
+  ) ++ inTask(pushRemoteCache)(
+    Seq(
+      ivyPaths := (Scope.Global / pushRemoteCache / ivyPaths).value,
+      ivyConfiguration := {
+        val config0 = Classpaths.mkIvyConfiguration.value
+        config0
+          .withResolvers(remoteCacheResolvers.value.toVector)
+          .withOtherResolvers(pushRemoteCacheTo.value.toVector)
+          .withResolutionCacheDir(crossTarget.value / "alt-resolution")
+          .withPaths(ivyPaths.value)
+          .withUpdateOptions(UpdateOptions().withGigahorse(true))
+      },
+      ivySbt := {
+        Credentials.register(credentials.value, streams.value.log)
+        val config0 = ivyConfiguration.value
+        new IvySbt(config0, sbt.internal.CustomHttp.okhttpClient.value)
+      },
+    )
+  ) ++ inTask(pullRemoteCache)(
+    Seq(
+      dependencyResolution := Defaults.dependencyResolutionTask.value,
+      csrConfiguration := {
+        val rs = pushRemoteCacheTo.value.toVector ++ remoteCacheResolvers.value.toVector
+        LMCoursier.scalaCompilerBridgeConfigurationTask.value
+          .withResolvers(rs)
+      }
+    )
+  ) ++ inConfig(Compile)(configCacheSettings(compileArtifact(Compile, cachedCompileClassifier)))
+    ++ inConfig(Test)(configCacheSettings(testArtifact(Test, cachedTestClassifier))))
+
+  @nowarn
+  def configCacheSettings[A <: RemoteCacheArtifact](
+      cacheArtifactTask: Def.Initialize[Task[A]]
+  ): Seq[Def.Setting[_]] =
+    inTask(packageCache)(
+      Seq(
+        packageCache.in(Defaults.TaskZero) := {
+          val original = packageBin.in(Defaults.TaskZero).value
+          val artp = artifactPath.value
+          val af = compileAnalysisFile.value
+          IO.copyFile(original, artp)
+          if (af.exists) {
+            JarUtils.includeInJar(artp, Vector(af -> s"META-INF/inc_compile.zip"))
+          }
+          // val testStream = (test / streams).?.value
+          // testStream foreach { s =>
+          //   val sf = Defaults.succeededFile(s.cacheDirectory)
+          //   if (sf.exists) {
+          //     JarUtils.includeInJar(artp, Vector(sf -> s"META-INF/succeeded_tests"))
+          //   }
+          // }
+          artp
+        },
+        pushRemoteCacheArtifact := true,
+        remoteCacheArtifact := cacheArtifactTask.value,
+        packagedArtifact := (artifact.value -> packageCache.value),
+        artifactPath := Defaults.artifactPathSetting(artifact).value
+      )
+    ) ++ inTask(pushRemoteCache)(
+      Seq(
+        moduleSettings := {
+          val smi = scalaModuleInfo.value
+          ModuleDescriptorConfiguration(remoteCacheProjectId.value, projectInfo.value)
+            .withScalaModuleInfo(smi)
+        },
+        pushRemoteCache.in(Defaults.TaskZero) := (Def.task {
+          val s = streams.value
+          val config = pushRemoteCacheConfiguration.value
+          val is = (pushRemoteCache / ivySbt).value
+          val m = new is.Module(moduleSettings.value)
+          IvyActions.publish(m, config, s.log)
+        } tag (Tags.Publish, Tags.Network)).value,
+      )
+    ) ++ Seq(
+      remoteCacheIdCandidates := List(remoteCacheId.value),
+      remoteCacheProjectId := {
+        val o = organization.value
+        val m = moduleName.value
+        val id = remoteCacheId.value
+        val c = (projectID / crossVersion).value
+        val v = toVersion(id)
+        ModuleID(o, m, v).cross(c)
+      },
+      remoteCacheId := {
+        val inputs = (unmanagedSources / inputFileStamps).value
+        val cp = (externalDependencyClasspath / outputFileStamps).?.value.getOrElse(Nil)
+        val extraInc = (extraIncOptions.value) flatMap {
+          case (k, v) =>
+            Vector(k, v)
+        }
+        combineHash(extractHash(inputs) ++ extractHash(cp) ++ extraInc)
+      },
+      pushRemoteCacheConfiguration := {
+        Classpaths.publishConfig(
+          (pushRemoteCacheConfiguration / publishMavenStyle).value,
+          Classpaths.deliverPattern(crossTarget.value),
+          if (isSnapshot.value) "integration" else "release",
+          ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
+          (pushRemoteCacheConfiguration / packagedArtifacts).value.toVector,
+          (pushRemoteCacheConfiguration / checksums).value.toVector,
+          Classpaths.getPublishTo(pushRemoteCacheTo.value).name,
+          ivyLoggingLevel.value,
+          isSnapshot.value
+        )
+      },
+      pushRemoteCacheConfiguration / packagedArtifacts := Def.taskDyn {
+        val artifacts = (pushRemoteCacheConfiguration / remoteCacheArtifacts).value
+        artifacts
+          .map(a => a.packaged.map(file => (a.artifact, file)))
+          .join
+          .apply(_.join.map(_.toMap))
+      }.value,
+      pushRemoteCacheConfiguration / remoteCacheArtifacts := {
+        List((packageCache / remoteCacheArtifact).value)
+      },
+      pullRemoteCache := {
+        import scala.collection.JavaConverters._
+        val log = streams.value.log
+        val r = remoteCacheResolvers.value.head
+        val p = remoteCacheProjectId.value
+        val ids = remoteCacheIdCandidates.value
+        val is = (pushRemoteCache / ivySbt).value
+        val m = new is.Module((pushRemoteCache / moduleSettings).value)
+        val smi = scalaModuleInfo.value
+        val artifacts = (pushRemoteCacheConfiguration / remoteCacheArtifacts).value
+        val nonPom = artifacts.filterNot(isPomArtifact).toVector
+        m.withModule(log) {
+          case (ivy, md, _) =>
+            val resolver = ivy.getSettings.getResolver(r.name)
+            if (resolver eq null) sys.error(s"undefined resolver '${r.name}'")
+            val cross = CrossVersion(p, smi)
+            val crossf: String => String = cross.getOrElse(identity _)
+            var found = false
+            ids foreach {
+              id: String =>
+                val v = toVersion(id)
+                val modId = p.withRevision(v).withName(crossf(p.name))
+                val ivyId = IvySbt.toID(modId)
+                if (found) ()
+                else {
+                  val rawa = nonPom map { _.artifact }
+                  val seqa = CrossVersion.substituteCross(rawa, cross)
+                  val as = seqa map { a =>
+                    val extra = a.classifier match {
+                      case Some(c) => Map("e:classifier" -> c)
+                      case None    => Map.empty
+                    }
+                    new DefaultArtifact(ivyId, null, a.name, a.`type`, a.extension, extra.asJava)
+                  }
+                  pullFromMavenRepo0(as, resolver, log) match {
+                    case Right(xs0) =>
+                      val jars = xs0.distinct
+
+                      nonPom.foreach { art =>
+                        val classifier = art.artifact.classifier
+
+                        findJar(classifier, v, jars) match {
+                          case Some(jar) =>
+                            extractJar(art, jar)
+                            log.info(s"remote cache artifact extracted for $p $classifier")
+
+                          case None =>
+                            log.info(s"remote cache artifact not found for $p $classifier")
+                        }
+                      }
+                      found = true
+                    case Left(e) =>
+                      log.info(s"remote cache not found for ${v}")
+                      log.debug(e.getMessage)
+                  }
+                }
+            }
+            ()
+        }
+      },
+    )
+
+  def isPomArtifact(artifact: RemoteCacheArtifact): Boolean =
+    artifact match {
+      case _: PomRemoteCacheArtifact => true
+      case _                         => false
+    }
+
+  def compileArtifact(
+      configuration: Configuration,
+      classifier: String
+  ): Def.Initialize[Task[CompileRemoteCacheArtifact]] = Def.task {
+    CompileRemoteCacheArtifact(
+      Artifact(moduleName.value, classifier),
+      configuration / packageCache,
+      (configuration / classDirectory).value,
+      (configuration / compileAnalysisFile).value
+    )
+  }
+
+  def testArtifact(
+      configuration: Configuration,
+      classifier: String
+  ): Def.Initialize[Task[TestRemoteCacheArtifact]] = Def.task {
+    TestRemoteCacheArtifact(
+      Artifact(moduleName.value, classifier),
+      configuration / packageCache,
+      (configuration / classDirectory).value,
+      (configuration / compileAnalysisFile).value,
+      Defaults.succeededFile((configuration / test / streams).value.cacheDirectory)
+    )
+  }
+
+  private def toVersion(v: String): String = s"0.0.0-$v"
+
+  private lazy val doption = new DownloadOptions
+  private def pullFromMavenRepo0(
+      artifacts: Vector[IArtifact],
+      r: DependencyResolver,
+      log: Logger
+  ): Either[Throwable, Vector[File]] = {
+    try {
+      val files = r.download(artifacts.toArray, doption).getArtifactsReports.toVector map {
+        report =>
+          if (report == null) sys.error(s"failed to download $artifacts: " + r.toString)
+          else
+            report.getDownloadStatus match {
+              case DownloadStatus.NO =>
+                val o = report.getArtifactOrigin
+                if (o.isLocal) {
+                  val localFile = new File(o.getLocation)
+                  if (!localFile.exists) sys.error(s"$localFile doesn't exist")
+                  else localFile
+                } else report.getLocalFile
+              case DownloadStatus.SUCCESSFUL =>
+                report.getLocalFile
+              case DownloadStatus.FAILED =>
+                sys.error(s"failed to download $artifacts: " + r.toString)
+            }
+      }
+      Right(files)
+    } catch {
+      case e: Throwable => Left(e)
+    }
+  }
+
+  private def findJar(classifier: Option[String], ver: String, jars: Vector[File]): Option[File] = {
+    val suffix = classifier.fold(ver)(c => s"$ver-$c.jar")
+    jars.find(_.toString.endsWith(suffix))
+  }
+
+  private def extractJar(cacheArtifact: RemoteCacheArtifact, jar: File): Unit =
+    cacheArtifact match {
+      case a: CompileRemoteCacheArtifact =>
+        extractCache(jar, a.extractDirectory, preserveLastModified = true) { output =>
+          extractAnalysis(output, a.analysisFile)
+        }
+
+      case a: TestRemoteCacheArtifact =>
+        extractCache(jar, a.extractDirectory, preserveLastModified = true) { output =>
+          extractAnalysis(output, a.analysisFile)
+          extractTestResult(output, a.testResult)
+        }
+
+      case a: CustomRemoteCacheArtifact =>
+        extractCache(jar, a.extractDirectory, a.preserveLastModified)(_ => ())
+
+      case _ =>
+        ()
+    }
+
+  private def extractCache(jar: File, output: File, preserveLastModified: Boolean)(
+      processOutput: File => Unit
+  ): Unit = {
+    IO.delete(output)
+    IO.unzip(jar, output, preserveLastModified = preserveLastModified)
+    processOutput(output)
+
+    // preserve semanticdb dir
+    // https://github.com/scalameta/scalameta/blob/a7927ee8e012cfff/semanticdb/scalac/library/src/main/scala/scala/meta/internal/semanticdb/scalac/SemanticdbPaths.scala#L9
+    Option((output / "META-INF").listFiles).foreach(
+      _.iterator.filterNot(_.getName == "semanticdb").foreach(IO.delete)
+    )
+  }
+
+  private def extractAnalysis(output: File, analysisFile: File): Unit = {
+    val metaDir = output / "META-INF"
+    val expandedAnalysis = metaDir / "inc_compile.zip"
+    if (expandedAnalysis.exists) {
+      IO.move(expandedAnalysis, analysisFile)
+    }
+  }
+
+  private def extractTestResult(output: File, testResult: File): Unit = {
+    //val expandedTestResult = output / "META-INF" / "succeeded_tests"
+    //if (expandedTestResult.exists) {
+    //  IO.move(expandedTestResult, testResult)
+    //}
+  }
+
+  private def defaultArtifactTasks: Seq[TaskKey[File]] =
+    Seq(Compile / packageCache, Test / packageCache)
+
+  private def enabledOnly[A](
+      key: SettingKey[A],
+      pkgTasks: Seq[TaskKey[File]]
+  ): Def.Initialize[Seq[A]] =
+    (Classpaths.forallIn(key, pkgTasks) zipWith
+      Classpaths.forallIn(pushRemoteCacheArtifact, pkgTasks))(_ zip _ collect {
+      case (a, true) => a
+    })
+
+  private def extractHash(inputs: Seq[(Path, FileStamp)]): Vector[String] =
+    inputs.toVector map {
+      case (_, stamp0) => toOption(stamp0.stamp.getHash).getOrElse("cafe")
+    }
+
+  private def combineHash(vs: Vector[String]): String = {
+    val hashValue = HashUtil.farmHash(vs.sorted.mkString("").getBytes("UTF-8"))
+    java.lang.Long.toHexString(hashValue)
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/Resolve.scala b/main/src/main/scala/sbt/internal/Resolve.scala
index c36ffb88a..8e92e1b78 100644
--- a/main/src/main/scala/sbt/internal/Resolve.scala
+++ b/main/src/main/scala/sbt/internal/Resolve.scala
@@ -1,44 +1,62 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
 import sbt.internal.util.AttributeKey
 
 object Resolve {
-  def apply(index: BuildUtil[_], current: ScopeAxis[Reference], key: AttributeKey[_], mask: ScopeMask): Scope => Scope =
-    {
-      val rs =
-        resolveProject(current, mask) _ ::
-          resolveExtra(mask) _ ::
-          resolveTask(mask) _ ::
-          resolveConfig(index, key, mask) _ ::
-          Nil
-      scope => (scope /: rs) { (s, f) => f(s) }
-    }
+  def apply(
+      index: BuildUtil[_],
+      current: ScopeAxis[Reference],
+      key: AttributeKey[_],
+      mask: ScopeMask,
+  ): Scope => Scope = {
+    val rs = (
+      resolveProject(current, mask) _
+        :: resolveExtra(mask) _
+        :: resolveTask(mask) _
+        :: resolveConfig(index, key, mask) _
+        :: Nil
+    )
+    scope => rs.foldLeft(scope)((s, f) => f(s))
+  }
+
   def resolveTask(mask: ScopeMask)(scope: Scope): Scope =
-    if (mask.task) scope else scope.copy(task = Global)
+    if (mask.task) scope
+    else scope.copy(task = Zero)
 
   def resolveProject(current: ScopeAxis[Reference], mask: ScopeMask)(scope: Scope): Scope =
-    if (mask.project) scope else scope.copy(project = current)
+    if (mask.project) scope
+    else scope.copy(project = current)
 
   def resolveExtra(mask: ScopeMask)(scope: Scope): Scope =
-    if (mask.extra) scope else scope.copy(extra = Global)
+    if (mask.extra) scope
+    else scope.copy(extra = Zero)
 
-  def resolveConfig[P](index: BuildUtil[P], key: AttributeKey[_], mask: ScopeMask)(scope: Scope): Scope =
+  def resolveConfig[P](index: BuildUtil[P], key: AttributeKey[_], mask: ScopeMask)(
+      scope: Scope,
+  ): Scope =
     if (mask.config)
       scope
     else {
       val (resolvedRef, proj) = scope.project match {
+        case Zero | This => (None, index.thisRootProject)
         case Select(ref) =>
           val r = index resolveRef ref
           (Some(r), index.projectFor(r))
-        case Global | This =>
-          (None, index.rootProject(index.root))
       }
       val task = scope.task.toOption
       val keyIndex = index.keyIndex
-      val definesKey = (c: ScopeAxis[ConfigKey]) => keyIndex.keys(resolvedRef, c.toOption.map(_.name), task) contains key.label
+      val definesKey = (c: ScopeAxis[ConfigKey]) =>
+        keyIndex.keys(resolvedRef, c.toOption.map(_.name), task) contains key.label
       val projectConfigs = index.configurations(proj).map(ck => Select(ck))
-      val config: ScopeAxis[ConfigKey] = (Global +: projectConfigs) find definesKey getOrElse Global
+      val config: ScopeAxis[ConfigKey] = (Zero +: projectConfigs) find definesKey getOrElse Zero
       scope.copy(config = config)
     }
 }
diff --git a/main/src/main/scala/sbt/internal/RetrieveUnit.scala b/main/src/main/scala/sbt/internal/RetrieveUnit.scala
index f0a42f6a8..bf8eb1939 100644
--- a/main/src/main/scala/sbt/internal/RetrieveUnit.scala
+++ b/main/src/main/scala/sbt/internal/RetrieveUnit.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
@@ -9,18 +13,17 @@ import java.net.URI
 import sbt.internal.BuildLoader.ResolveInfo
 
 object RetrieveUnit {
-  def apply(info: ResolveInfo): Option[() => File] =
-    {
-      info.uri match {
-        case Scheme("svn") | Scheme("svn+ssh") => Resolvers.subversion(info)
-        case Scheme("hg") => Resolvers.mercurial(info)
-        case Scheme("git") => Resolvers.git(info)
-        case Path(path) if path.endsWith(".git") => Resolvers.git(info)
-        case Scheme("http") | Scheme("https") | Scheme("ftp") => Resolvers.remote(info)
-        case Scheme("file") => Resolvers.local(info)
-        case _ => None
-      }
+  def apply(info: ResolveInfo): Option[() => File] = {
+    info.uri match {
+      case Scheme("svn") | Scheme("svn+ssh")                => Resolvers.subversion(info)
+      case Scheme("hg")                                     => Resolvers.mercurial(info)
+      case Scheme("git")                                    => Resolvers.git(info)
+      case Path(path) if path.endsWith(".git")              => Resolvers.git(info)
+      case Scheme("http") | Scheme("https") | Scheme("ftp") => Resolvers.remote(info)
+      case Scheme("file")                                   => Resolvers.local(info)
+      case _                                                => None
     }
+  }
 
   object Scheme {
     def unapply(uri: URI) = Option(uri.getScheme)
diff --git a/main/src/main/scala/sbt/internal/Script.scala b/main/src/main/scala/sbt/internal/Script.scala
index 9ead77992..203ee2000 100644
--- a/main/src/main/scala/sbt/internal/Script.scala
+++ b/main/src/main/scala/sbt/internal/Script.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011  Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
@@ -12,6 +16,8 @@ import java.io.File
 import Keys._
 import EvaluateConfigurations.{ evaluateConfiguration => evaluate }
 import Configurations.Compile
+import Scope.Global
+import sbt.SlashSyntax0._
 
 import sbt.io.{ Hash, IO }
 
@@ -19,7 +25,9 @@ object Script {
   final val Name = "script"
   lazy val command =
     Command.command(Name) { state =>
-      val scriptArg = state.remainingCommands.headOption getOrElse sys.error("No script file specified")
+      val scriptArg = state.remainingCommands.headOption map { _.commandLine } getOrElse sys.error(
+        "No script file specified"
+      )
       val scriptFile = new File(scriptArg).getAbsoluteFile
       val hash = Hash.halve(Hash.toHex(Hash(scriptFile.getAbsolutePath)))
       val base = new File(CommandUtil.bootDirectory(state), hash)
@@ -43,37 +51,49 @@ object Script {
       val embeddedSettings = blocks(script).flatMap { block =>
         evaluate(eval(), script, block.lines, currentUnit.imports, block.offset + 1)(currentLoader)
       }
-      val scriptAsSource = sources in Compile := script :: Nil
+      val scriptAsSource = (Compile / sources) := script :: Nil
       val asScript = scalacOptions ++= Seq("-Xscript", script.getName.stripSuffix(".scala"))
-      val scriptSettings = Seq(asScript, scriptAsSource, logLevel in Global := Level.Warn, showSuccess in Global := false)
-      val append = Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, scriptSettings ++ embeddedSettings)
+      val scriptSettings = Seq(
+        asScript,
+        scriptAsSource,
+        (Global / logLevel) := Level.Warn,
+        (Global / showSuccess) := false
+      )
+      val append = Load.transformSettings(
+        Load.projectScope(currentRef),
+        currentRef.build,
+        rootProject,
+        scriptSettings ++ embeddedSettings
+      )
 
       val newStructure = Load.reapply(session.original ++ append, structure)
-      val arguments = state.remainingCommands.drop(1)
+      val arguments = state.remainingCommands.drop(1).map(e => s""""${e.commandLine}"""")
       val newState = arguments.mkString("run ", " ", "") :: state.copy(remainingCommands = Nil)
       Project.setProject(session, newStructure, newState)
     }
 
   final case class Block(offset: Int, lines: Seq[String])
-  def blocks(file: File): Seq[Block] =
-    {
-      val lines = IO.readLines(file).toIndexedSeq
-      def blocks(b: Block, acc: List[Block]): List[Block] =
-        if (b.lines.isEmpty)
-          acc.reverse
-        else {
-          val (dropped, blockToEnd) = b.lines.span { line => !line.startsWith(BlockStart) }
-          val (block, remaining) = blockToEnd.span { line => !line.startsWith(BlockEnd) }
-          val offset = b.offset + dropped.length
-          blocks(Block(offset + block.length, remaining), Block(offset, block.drop(1)) :: acc)
+  def blocks(file: File): Seq[Block] = {
+    val lines = IO.readLines(file).toIndexedSeq
+    def blocks(b: Block, acc: List[Block]): List[Block] =
+      if (b.lines.isEmpty)
+        acc.reverse
+      else {
+        val (dropped, blockToEnd) = b.lines.span { line =>
+          !line.startsWith(BlockStart)
         }
-      blocks(Block(0, lines), Nil)
-    }
+        val (block, remaining) = blockToEnd.span { line =>
+          !line.startsWith(BlockEnd)
+        }
+        val offset = b.offset + dropped.length
+        blocks(Block(offset + block.length, remaining), Block(offset, block.drop(1)) :: acc)
+      }
+    blocks(Block(0, lines), Nil)
+  }
   val BlockStart = "/***"
   val BlockEnd = "*/"
-  def fail(s: State, msg: String): State =
-    {
-      System.err.println(msg)
-      s.fail
-    }
+  def fail(s: State, msg: String): State = {
+    System.err.println(msg)
+    s.fail
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/SessionSettings.scala b/main/src/main/scala/sbt/internal/SessionSettings.scala
index 2d036bddf..dce3424d6 100755
--- a/main/src/main/scala/sbt/internal/SessionSettings.scala
+++ b/main/src/main/scala/sbt/internal/SessionSettings.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
@@ -20,21 +24,26 @@ import sbt.io.IO
 /**
  * Represents (potentially) transient settings added into a build via commands/user.
  *
- * @param currentBuild
- * The current sbt build with which we scope new settings
- * @param currentProject
- * The current project with which we scope new settings.
- * @param original
- * The original list of settings for this build.
- * @param append
- * Settings which have been defined and appended that may ALSO be saved to disk.
- * @param rawAppend
- * Settings which have been defined and appended which CANNOT be saved to disk
- * @param currentEval
- * A compiler we can use to compile new setting strings.
+ * @param currentBuild The current sbt build with which we scope new settings
+ * @param currentProject The current project with which we scope new settings.
+ * @param original The original list of settings for this build.
+ * @param append Settings which have been defined and appended that may ALSO be saved to disk.
+ * @param rawAppend Settings which have been defined and appended which CANNOT be saved to disk
+ * @param currentEval A compiler we can use to compile new setting strings.
  */
-final case class SessionSettings(currentBuild: URI, currentProject: Map[URI, String], original: Seq[Setting[_]], append: SessionMap, rawAppend: Seq[Setting[_]], currentEval: () => Eval) {
-  assert(currentProject contains currentBuild, "Current build (" + currentBuild + ") not associated with a current project.")
+final case class SessionSettings(
+    currentBuild: URI,
+    currentProject: Map[URI, String],
+    original: Seq[Setting[_]],
+    append: SessionMap,
+    rawAppend: Seq[Setting[_]],
+    currentEval: () => Eval
+) {
+
+  assert(
+    currentProject contains currentBuild,
+    s"Current build ($currentBuild) not associated with a current project."
+  )
 
   /**
    * Modifiy the current state.
@@ -44,7 +53,12 @@ final case class SessionSettings(currentBuild: URI, currentProject: Map[URI, Str
    * @param eval  The mechanism to compile new settings.
    * @return  A new SessionSettings object
    */
-  def setCurrent(build: URI, project: String, eval: () => Eval): SessionSettings = copy(currentBuild = build, currentProject = currentProject.updated(build, project), currentEval = eval)
+  def setCurrent(build: URI, project: String, eval: () => Eval): SessionSettings =
+    copy(
+      currentBuild = build,
+      currentProject = currentProject.updated(build, project),
+      currentEval = eval
+    )
 
   /**
    * @return  The current ProjectRef with which we scope settings.
@@ -56,12 +70,13 @@ final case class SessionSettings(currentBuild: URI, currentProject: Map[URI, Str
    * @param s  A sequence of SessionSetting objects, which contain a Setting[_] and a string.
    * @return  A new SessionSettings which contains this new sequence.
    */
-  def appendSettings(s: Seq[SessionSetting]): SessionSettings = copy(append = modify(append, _ ++ s))
+  def appendSettings(s: Seq[SessionSetting]): SessionSettings =
+    copy(append = modify(append, _ ++ s))
 
   /**
    * Appends a set of raw Setting[_] objects to the current session.
    * @param ss  The raw settings to include
-   * @return A new SessionSettings with the appeneded settings.
+   * @return A new SessionSettings with the appended settings.
    */
   def appendRaw(ss: Seq[Setting[_]]): SessionSettings = copy(rawAppend = rawAppend ++ ss)
 
@@ -75,7 +90,8 @@ final case class SessionSettings(currentBuild: URI, currentProject: Map[URI, Str
    */
   def clearExtraSettings: SessionSettings = copy(append = Map.empty, rawAppend = Nil)
 
-  private[this] def merge(map: SessionMap): Seq[Setting[_]] = map.values.toSeq.flatten[SessionSetting].map(_._1)
+  private[this] def merge(map: SessionMap): Seq[Setting[_]] =
+    map.values.toSeq.flatten[SessionSetting].map(_._1)
 
   private[this] def modify(map: SessionMap, onSeq: Endo[Seq[SessionSetting]]): SessionMap = {
     val cur = current
@@ -84,8 +100,10 @@ final case class SessionSettings(currentBuild: URI, currentProject: Map[URI, Str
 }
 
 object SessionSettings {
+
   /** A session setting is simply a tuple of a Setting[_] and the strings which define it. */
   type SessionSetting = (Setting[_], Seq[String])
+
   type SessionMap = Map[ProjectRef, Seq[SessionSetting]]
   type SbtConfigFile = (File, Seq[String])
 
@@ -132,11 +150,13 @@ object SessionSettings {
   def checkSession(newSession: SessionSettings, oldState: State): Unit = {
     val oldSettings = (oldState get Keys.sessionSettings).toList.flatMap(_.append).flatMap(_._2)
     if (newSession.append.isEmpty && oldSettings.nonEmpty)
-      oldState.log.warn("Discarding " + pluralize(oldSettings.size, " session setting") + ".  Use 'session save' to persist session settings.")
+      oldState.log.warn(
+        "Discarding " + pluralize(oldSettings.size, " session setting") + ".  Use 'session save' to persist session settings."
+      )
   }
 
   def removeRanges[T](in: Seq[T], ranges: Seq[(Int, Int)]): Seq[T] = {
-    val asSet = (Set.empty[Int] /: ranges) { case (s, (hi, lo)) => s ++ (hi to lo) }
+    val asSet = ranges.foldLeft(Set.empty[Int]) { case (s, (hi, lo)) => s ++ (hi to lo) }
     in.zipWithIndex.flatMap { case (t, index) => if (asSet(index + 1)) Nil else t :: Nil }
   }
 
@@ -149,7 +169,8 @@ object SessionSettings {
   def removeSettings(s: State, ranges: Seq[(Int, Int)]): State =
     withSettings(s) { session =>
       val current = session.current
-      val newAppend = session.append.updated(current, removeRanges(session.append.getOrElse(current, Nil), ranges))
+      val newAppend = session.append
+        .updated(current, removeRanges(session.append.getOrElse(current, Nil), ranges))
       reapply(session.copy(append = newAppend), s)
     }
 
@@ -172,7 +193,8 @@ object SessionSettings {
     withSettings(s) { session =>
       val newSettings =
         for ((ref, settings) <- session.append if settings.nonEmpty && include(ref)) yield {
-          val (news, olds) = writeSettings(ref, settings.toList, session.original, Project.structure(s))
+          val (news, olds) =
+            writeSettings(ref, settings.toList, session.original, Project.structure(s))
           (ref -> news, olds)
         }
       val (newAppend, newOriginal) = newSettings.unzip
@@ -180,26 +202,39 @@ object SessionSettings {
       reapply(newSession.copy(original = newSession.mergeSettings, append = Map.empty), s)
     }
 
-  def writeSettings(pref: ProjectRef, settings: List[SessionSetting], original: Seq[Setting[_]], structure: BuildStructure): (Seq[SessionSetting], Seq[Setting[_]]) = {
-    val project = Project.getProject(pref, structure).getOrElse(sys.error("Invalid project reference " + pref))
-    val writeTo: File = BuildPaths.configurationSources(project.base).headOption.getOrElse(new File(project.base, "build.sbt"))
+  def writeSettings(
+      pref: ProjectRef,
+      settings: List[SessionSetting],
+      original: Seq[Setting[_]],
+      structure: BuildStructure
+  ): (Seq[SessionSetting], Seq[Setting[_]]) = {
+    val project =
+      Project.getProject(pref, structure).getOrElse(sys.error("Invalid project reference " + pref))
+    val writeTo: File = BuildPaths
+      .configurationSources(project.base)
+      .headOption
+      .getOrElse(new File(project.base, "build.sbt"))
     writeTo.createNewFile()
 
     val path = writeTo.getAbsolutePath
-    val (inFile, other, _) = ((List[Setting[_]](), List[Setting[_]](), Set.empty[ScopedKey[_]]) /: original.reverse) {
-      case ((in, oth, keys), s) =>
-        s.pos match {
-          case RangePosition(`path`, _) if !keys.contains(s.key) => (s :: in, oth, keys + s.key)
-          case _ => (in, s :: oth, keys)
-        }
-    }
+    val (inFile, other, _) =
+      original.reverse.foldLeft((List[Setting[_]](), List[Setting[_]](), Set.empty[ScopedKey[_]])) {
+        case ((in, oth, keys), s) =>
+          s.pos match {
+            case RangePosition(`path`, _) if !keys.contains(s.key) => (s :: in, oth, keys + s.key)
+            case _                                                 => (in, s :: oth, keys)
+          }
+      }
 
-    val (_, oldShifted, replace) = ((0, List[Setting[_]](), Seq[SessionSetting]()) /: inFile) {
+    val (_, oldShifted, replace) = inFile.foldLeft((0, List[Setting[_]](), Seq[SessionSetting]())) {
       case ((offs, olds, repl), s) =>
         val RangePosition(_, r @ LineRange(start, end)) = s.pos
         settings find (_._1.key == s.key) match {
           case Some(ss @ (ns, newLines)) if !ns.init.dependencies.contains(ns.key) =>
-            val shifted = ns withPos RangePosition(path, LineRange(start - offs, start - offs + newLines.size))
+            val shifted = ns withPos RangePosition(
+              path,
+              LineRange(start - offs, start - offs + newLines.size)
+            )
             (offs + end - start - newLines.size, shifted :: olds, ss +: repl)
           case _ =>
             val shifted = s withPos RangePosition(path, r shift -offs)
@@ -212,7 +247,7 @@ object SessionSettings {
     val adjusted = if (newSettings.nonEmpty && needsTrailingBlank(exist)) exist :+ "" else exist
     val lines = adjusted ++ newSettings.flatMap(x => x._2 :+ "")
     IO.writeLines(writeTo, lines)
-    val (newWithPos, _) = ((List[SessionSetting](), adjusted.size + 1) /: newSettings) {
+    val (newWithPos, _) = newSettings.foldLeft((List[SessionSetting](), adjusted.size + 1)) {
       case ((acc, line), (s, newLines)) =>
         val endLine = line + newLines.size
         ((s withPos RangePosition(path, LineRange(line, endLine)), newLines) :: acc, endLine + 1)
@@ -220,7 +255,8 @@ object SessionSettings {
     (newWithPos.reverse, other ++ oldShifted)
   }
 
-  def needsTrailingBlank(lines: Seq[String]) = lines.nonEmpty && !lines.takeRight(1).exists(_.trim.isEmpty)
+  def needsTrailingBlank(lines: Seq[String]) =
+    lines.nonEmpty && !lines.takeRight(1).exists(_.trim.isEmpty)
 
   /** Prints all the user-defined SessionSettings (not raw) to System.out. */
   def printAllSettings(s: State): State =
@@ -244,7 +280,8 @@ object SessionSettings {
     for (((_, stringRep), index) <- settings.zipWithIndex)
       println("  " + (index + 1) + ". " + stringRep.mkString("\n"))
 
-  def Help = """session <command>
+  def Help =
+    """session <command>
 
 Manipulates session settings, which are temporary settings that do not persist past the current sbt execution (that is, the current session).
 Valid commands are:
@@ -294,18 +331,24 @@ save, save-all
   /** Parser for the session command. */
   lazy val parser =
     token(Space) ~>
-      (token("list-all" ^^^ new Print(true)) | token("list" ^^^ new Print(false)) | token("clear" ^^^ new Clear(false)) |
-        token("save-all" ^^^ new Save(true)) | token("save" ^^^ new Save(false)) | token("clear-all" ^^^ new Clear(true)) |
+      (token("list-all" ^^^ new Print(true)) | token("list" ^^^ new Print(false)) | token(
+        "clear" ^^^ new Clear(false)
+      ) |
+        token("save-all" ^^^ new Save(true)) | token("save" ^^^ new Save(false)) | token(
+        "clear-all" ^^^ new Clear(true)
+      ) |
         remove)
 
   lazy val remove = token("remove") ~> token(Space) ~> natSelect.map(ranges => new Remove(ranges))
 
   def natSelect = rep1sep(token(range, "<range>"), ',')
 
-  def range: Parser[(Int, Int)] = (NatBasic ~ ('-' ~> NatBasic).?).map { case lo ~ hi => (lo, hi getOrElse lo) }
+  def range: Parser[(Int, Int)] = (NatBasic ~ ('-' ~> NatBasic).?).map {
+    case lo ~ hi => (lo, hi getOrElse lo)
+  }
 
   /** The raw implementation of the session command. */
-  def command(s: State) = Command.applyEffect(parser) {
+  def command(s: State): Parser[() => State] = Command.applyEffect(parser) {
     case p: Print  => if (p.all) printAllSettings(s) else printSettings(s)
     case v: Save   => if (v.all) saveAllSettings(s) else saveSettings(s)
     case c: Clear  => if (c.all) clearAllSettings(s) else clearSettings(s)
diff --git a/main/src/main/scala/sbt/internal/SettingCompletions.scala b/main/src/main/scala/sbt/internal/SettingCompletions.scala
index 27fb58be1..e3ff3cce4 100644
--- a/main/src/main/scala/sbt/internal/SettingCompletions.scala
+++ b/main/src/main/scala/sbt/internal/SettingCompletions.scala
@@ -1,136 +1,177 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
-import sbt.internal.util.{ AttributeKey, complete, Relation, Settings, Show, Types, Util }
-
+import sbt.internal.util.{ AttributeKey, complete, Relation, Settings, Types, Util }
+import sbt.util.Show
 import sbt.librarymanagement.Configuration
 
 import Project._
 import Def.{ ScopedKey, Setting }
-import Scope.GlobalScope
-import Types.{ const, idFun }
+import Scope.Global
+import Types.idFun
 import complete._
 import DefaultParsers._
+import scala.annotation.nowarn
 
 /**
  * The resulting `session` and verbose and quiet summaries of the result of a set operation.
  * The verbose summary will typically use more vertical space and show full details,
  * while the quiet summary will be a couple of lines and truncate information.
  */
-private[sbt] class SetResult(val session: SessionSettings, val verboseSummary: String, val quietSummary: String)
+private[sbt] class SetResult(
+    val session: SessionSettings,
+    val verboseSummary: String,
+    val quietSummary: String
+)
 
 /** Defines methods for implementing the `set` command.*/
 private[sbt] object SettingCompletions {
+
   /**
    * Implementation of the `set every` command.  Each setting in the provided `settings` sequence will be applied in all scopes,
    * overriding all previous definitions of the underlying AttributeKey.
    * The settings injected by this method cannot be later persisted by the `session save` command.
    */
-  def setAll(extracted: Extracted, settings: Seq[Setting[_]]): SetResult =
-    {
-      import extracted._
-      val r = relation(extracted.structure, true)
-      val allDefs = Def.flattenLocals(Def.compiled(extracted.structure.settings, true)(structure.delegates, structure.scopeLocal, implicitly[Show[ScopedKey[_]]])).keys
-      val projectScope = Load.projectScope(currentRef)
-      def resolve(s: Setting[_]): Seq[Setting[_]] = Load.transformSettings(projectScope, currentRef.build, rootProject, s :: Nil)
-      def rescope[T](setting: Setting[T]): Seq[Setting[_]] =
-        {
-          val akey = setting.key.key
-          val global = ScopedKey(Global, akey)
-          val globalSetting = resolve(Def.setting(global, setting.init, setting.pos))
-          globalSetting ++ allDefs.flatMap { d =>
-            if (d.key == akey)
-              Seq(SettingKey(akey) in d.scope := { global.value })
-            else
-              Nil
-          }
-        }
-      val redefined = settings.flatMap(x => rescope(x))
-      val session = extracted.session.appendRaw(redefined)
-      setResult(session, r, redefined)
-    }
+  def setAll(extracted: Extracted, settings: Seq[Setting[_]]): SetResult = {
+    import extracted._
+    val r = relation(extracted.structure, true)
+    val allDefs = Def
+      .flattenLocals(
+        Def.compiled(extracted.structure.settings, true)(
+          structure.delegates,
+          structure.scopeLocal,
+          implicitly[Show[ScopedKey[_]]]
+        )
+      )
+      .keys
+    val projectScope = Load.projectScope(currentRef)
+    def resolve(s: Setting[_]): Seq[Setting[_]] =
+      Load.transformSettings(projectScope, currentRef.build, rootProject, s :: Nil)
 
-  /** Implementation of the `set` command that will reload the current project with `settings` appended to the current settings. */
-  def setThis(s: State, extracted: Extracted, settings: Seq[Def.Setting[_]], arg: String): SetResult =
-    {
-      import extracted._
-      val append = Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, settings)
-      val newSession = session.appendSettings(append map (a => (a, arg.split('\n').toList)))
-      val r = relation(newSession.mergeSettings, true)(structure.delegates, structure.scopeLocal, implicitly)
-      setResult(newSession, r, append)
-    }
-
-  private[this] def setResult(session: SessionSettings, r: Relation[ScopedKey[_], ScopedKey[_]], redefined: Seq[Setting[_]])(implicit show: Show[ScopedKey[_]]): SetResult =
-    {
-      val redefinedKeys = redefined.map(_.key).toSet
-      val affectedKeys = redefinedKeys.flatMap(r.reverse)
-      def summary(verbose: Boolean): String = setSummary(redefinedKeys, affectedKeys, verbose)
-      new SetResult(session, summary(true), summary(false))
-    }
-
-  private[this] def setSummary(redefined: Set[ScopedKey[_]], affected: Set[ScopedKey[_]], verbose: Boolean)(implicit display: Show[ScopedKey[_]]): String =
-    {
-      val QuietLimit = 3
-      def strings(in: Set[ScopedKey[_]]): Seq[String] = in.toSeq.map(sk => display(sk)).sorted
-      def lines(in: Seq[String]): (String, Boolean) =
-        if (in.isEmpty)
-          ("no settings or tasks.", false)
-        else if (verbose)
-          (in.mkString("\n\t", "\n\t", "\n"), false)
+    @nowarn
+    def rescope[T](setting: Setting[T]): Seq[Setting[_]] = {
+      val akey = setting.key.key
+      val global = ScopedKey(Global, akey)
+      val globalSetting = resolve(Def.setting(global, setting.init, setting.pos))
+      globalSetting ++ allDefs.flatMap { d =>
+        if (d.key == akey)
+          Seq(SettingKey(akey) in d.scope := { global.value })
         else
-          quietList(in)
-      def quietList(in: Seq[String]): (String, Boolean) =
-        {
-          val (first, last) = in.splitAt(QuietLimit)
-          if (last.isEmpty)
-            (first.mkString(", "), false)
-          else {
-            val s = first.take(QuietLimit - 1).mkString("", ", ", " and " + last.size + " others.")
-            (s, true)
-          }
-        }
-      if (redefined.isEmpty)
-        "No settings or tasks were redefined."
-      else {
-        val (redef, trimR) = lines(strings(redefined))
-        val (used, trimU) = lines(strings(affected))
-        val details = if (trimR || trimU) "\n\tRun `last` for details." else ""
-        val valuesString = if (redefined.size == 1) "value" else "values"
-        "Defining %s\nThe new %s will be used by %s%s".format(redef, valuesString, used, details)
+          Nil
       }
     }
+    val redefined = settings.flatMap(x => rescope(x))
+    val session = extracted.session.appendRaw(redefined)
+    setResult(session, r, redefined)
+  }
+
+  /** Implementation of the `set` command that will reload the current project with `settings`
+   *  appended to the current settings.
+   */
+  def setThis(extracted: Extracted, settings: Seq[Def.Setting[_]], arg: String): SetResult = {
+    import extracted._
+    val append =
+      Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, settings)
+    val newSession = session.appendSettings(append map (a => (a, arg.split('\n').toList)))
+    val r = relation(newSession.mergeSettings, true)(
+      structure.delegates,
+      structure.scopeLocal,
+      implicitly
+    )
+    setResult(newSession, r, append)
+  }
+
+  private[this] def setResult(
+      session: SessionSettings,
+      r: Relation[ScopedKey[_], ScopedKey[_]],
+      redefined: Seq[Setting[_]],
+  )(implicit show: Show[ScopedKey[_]]): SetResult = {
+    val redefinedKeys = redefined.map(_.key).toSet
+    val affectedKeys = redefinedKeys.flatMap(r.reverse)
+    def summary(verbose: Boolean): String = setSummary(redefinedKeys, affectedKeys, verbose)
+    new SetResult(session, summary(true), summary(false))
+  }
+
+  private[this] def setSummary(
+      redefined: Set[ScopedKey[_]],
+      affected: Set[ScopedKey[_]],
+      verbose: Boolean,
+  )(implicit display: Show[ScopedKey[_]]): String = {
+    val QuietLimit = 3
+    def strings(in: Set[ScopedKey[_]]): Seq[String] = in.toSeq.map(sk => display.show(sk)).sorted
+    def lines(in: Seq[String]): (String, Boolean) =
+      if (in.isEmpty)
+        ("no settings or tasks.", false)
+      else if (verbose)
+        (in.mkString("\n\t", "\n\t", "\n"), false)
+      else
+        quietList(in)
+    def quietList(in: Seq[String]): (String, Boolean) = {
+      val (first, last) = in.splitAt(QuietLimit)
+      if (last.isEmpty)
+        (first.mkString(", "), false)
+      else {
+        val s = first.take(QuietLimit - 1).mkString("", ", ", " and " + last.size + " others.")
+        (s, true)
+      }
+    }
+    if (redefined.isEmpty)
+      "No settings or tasks were redefined."
+    else {
+      val (redef, trimR) = lines(strings(redefined))
+      val (used, trimU) = lines(strings(affected))
+      val details = if (trimR || trimU) "\n\tRun `last` for details." else ""
+      val valuesString = if (redefined.size == 1) "value" else "values"
+      "Defining %s\nThe new %s will be used by %s%s".format(redef, valuesString, used, details)
+    }
+  }
 
   /**
    * Parser that provides tab completion for the main argument to the `set` command.
-   * `settings` are the evaluated settings for the build, `rawKeyMap` maps the hypenated key identifier to the key object,
+   * `settings` are the evaluated settings for the build, `rawKeyMap` maps the hyphenated key identifier to the key object,
    * and `context` is the current project.
    * The tab completion will try to present the most relevant information first, with additional descriptions or keys available
    * when there are fewer choices or tab is pressed multiple times.
    * The last part of the completion will generate a template for the value or function literal that will initialize the setting or task.
    */
-  def settingParser(settings: Settings[Scope], rawKeyMap: Map[String, AttributeKey[_]], context: ResolvedProject): Parser[String] =
-    {
-      val keyMap: Map[String, AttributeKey[_]] = rawKeyMap.map { case (k, v) => (keyScalaID(k), v) }.toMap
-      def inputScopedKey(pred: AttributeKey[_] => Boolean): Parser[ScopedKey[_]] =
-        scopedKeyParser(keyMap.filter { case (_, k) => pred(k) }, settings, context)
-      val full = for {
-        defineKey <- scopedKeyParser(keyMap, settings, context)
-        a <- assign(defineKey)
-        deps <- valueParser(defineKey, a, inputScopedKey(keyFilter(defineKey.key)))
-      } yield () // parser is currently only for completion and the parsed data structures are not used
+  def settingParser(
+      settings: Settings[Scope],
+      rawKeyMap: Map[String, AttributeKey[_]],
+      context: ResolvedProject,
+  ): Parser[String] = {
+    val keyMap: Map[String, AttributeKey[_]] =
+      rawKeyMap.map { case (k, v) => (keyScalaID(k), v) }.toMap
+    val full = for {
+      defineKey <- scopedKeyParser(keyMap, settings, context)
+      a <- assign(defineKey)
+      _ <- valueParser(defineKey, a)
+    } yield () // parser is currently only for completion and the parsed data structures are not used
 
-      matched(full) | any.+.string
-    }
+    matched(full) | any.+.string
+  }
 
   /** Parser for a Scope+AttributeKey (ScopedKey). */
-  def scopedKeyParser(keyMap: Map[String, AttributeKey[_]], settings: Settings[Scope], context: ResolvedProject): Parser[ScopedKey[_]] =
-    {
-      val cutoff = KeyRanks.MainCutoff
-      val keyCompletions = fixedCompletions { (seen, level) => completeKey(seen, keyMap, level, cutoff, 10).toSet }
-      val keyID: Parser[AttributeKey[_]] = scalaID(keyMap, "key")
-      val keyParser = token(keyID, keyCompletions)
-      for (key <- keyParser; scope <- scopeParser(key, settings, context)) yield ScopedKey(scope, key)
+  def scopedKeyParser(
+      keyMap: Map[String, AttributeKey[_]],
+      settings: Settings[Scope],
+      context: ResolvedProject
+  ): Parser[ScopedKey[_]] = {
+    val cutoff = KeyRanks.MainCutoff
+    val keyCompletions = fixedCompletions { (seen, level) =>
+      completeKey(seen, keyMap, level, cutoff, 10).toSet
     }
+    val keyID: Parser[AttributeKey[_]] = scalaID(keyMap, "key")
+    val keyParser = token(keyID, keyCompletions)
+    for (key <- keyParser; scope <- scopeParser(key, settings, context))
+      yield ScopedKey(scope, key)
+  }
 
   /** Parser for the `in` method name that slightly augments the naive completion to give a hint of the purpose of `in`.*/
   val inParser = tokenDisplay(Space ~> InMethod, "%s <scope>".format(InMethod))
@@ -139,135 +180,167 @@ private[sbt] object SettingCompletions {
    * Parser for the initialization expression for the assignment method `assign` on the key `sk`.
    * `scopedKeyP` is used to parse and complete the input keys for an initialization that depends on other keys.
    */
-  def valueParser(sk: ScopedKey[_], assign: Assign.Value, scopedKeyP: Parser[ScopedKey[_]]): Parser[Seq[ScopedKey[_]]] =
-    {
-      val fullTypeString = keyTypeString(sk.key)
-      val typeString = if (assignNoAppend(assign)) fullTypeString else "..."
-      if (assign == Assign.Update) {
-        val function = "{(prev: " + typeString + ") => /*" + typeString + "*/ }"
-        token(OptSpace ~ function) ^^^ Nil
-      } else {
-        val value = "/* value of type " + typeString + " */"
-        token(Space ~ value) ^^^ Nil
-      }
+  def valueParser(sk: ScopedKey[_], assign: Assign.Value): Parser[Seq[ScopedKey[_]]] = {
+    val fullTypeString = keyTypeString(sk.key)
+    val typeString = if (assignNoAppend(assign)) fullTypeString else "..."
+    if (assign == Assign.Update) {
+      val function = "{(prev: " + typeString + ") => /*" + typeString + "*/ }"
+      token(OptSpace ~ function) ^^^ Nil
+    } else {
+      val value = "/* value of type " + typeString + " */"
+      token(Space ~ value) ^^^ Nil
     }
-
-  /**
-   * For a setting definition `definingKey <<= (..., in, ...) { ... }`,
-   * `keyFilter(definingKey)(in)` returns true when `in` is an allowed input for `definingKey` based on whether they are settings or not.
-   * For example, if `definingKey` is for a setting, `in` may only be a setting itself.
-   */
-  def keyFilter(definingKey: AttributeKey[_]): AttributeKey[_] => Boolean =
-    if (isSetting(definingKey)) isSetting _ else isTaskOrSetting _
+  }
 
   /**
    * Parser for a Scope for a `key` given the current project `context` and evaluated `settings`.
    * The completions are restricted to be more useful.  Currently, this parser will suggest
    * only known axis values for configurations and tasks and only in that order.
    */
-  def scopeParser(key: AttributeKey[_], settings: Settings[Scope], context: ResolvedProject): Parser[Scope] = {
+  def scopeParser(
+      key: AttributeKey[_],
+      settings: Settings[Scope],
+      context: ResolvedProject
+  ): Parser[Scope] = {
     val data = settings.data
     val allScopes = data.keys.toSeq
-    val definedScopes = data.toSeq flatMap { case (scope, attrs) => if (attrs contains key) scope :: Nil else Nil }
-    scope(key, allScopes, definedScopes, context)
+    val definedScopes = data.toSeq flatMap {
+      case (scope, attrs) => if (attrs contains key) scope :: Nil else Nil
+    }
+    scope(allScopes, definedScopes, context)
   }
 
-  private[this] def scope(key: AttributeKey[_], allScopes: Seq[Scope], definedScopes: Seq[Scope], context: ResolvedProject): Parser[Scope] =
-    {
-      def axisParser[T](axis: Scope => ScopeAxis[T], name: T => String, description: T => Option[String], label: String): Parser[ScopeAxis[T]] =
-        {
-          def getChoice(s: Scope): Seq[(String, T)] = axis(s) match {
-            case Select(t) => (name(t), t) :: Nil
-            case _         => Nil
-          }
-          def getChoices(scopes: Seq[Scope]): Map[String, T] = scopes.flatMap(getChoice).toMap
-          val definedChoices: Set[String] = definedScopes.flatMap(s => axis(s).toOption.map(name)).toSet
-          val fullChoices: Map[String, T] = getChoices(allScopes.toSeq)
-          val completions = fixedCompletions { (seen, level) => completeScope(seen, level, definedChoices, fullChoices)(description).toSet }
-          Act.optionalAxis(inParser ~> token(Space) ~> token(scalaID(fullChoices, label), completions), This)
-        }
-      val configurations: Map[String, Configuration] = context.configurations.map(c => (configScalaID(c.name), c)).toMap
-      val configParser = axisParser[ConfigKey](_.config, c => configScalaID(c.name), ck => configurations.get(ck.name).map(_.description), "configuration")
-      val taskParser = axisParser[AttributeKey[_]](_.task, k => keyScalaID(k.label), _.description, "task")
-      val nonGlobal = (configParser ~ taskParser) map { case (c, t) => Scope(This, c, t, Global) }
-      val global = inParser ~> token((Space ~ GlobalID) ^^^ GlobalScope)
-      global | nonGlobal
+  private[this] def scope(
+      allScopes: Seq[Scope],
+      definedScopes: Seq[Scope],
+      context: ResolvedProject,
+  ): Parser[Scope] = {
+    def axisParser[T](
+        axis: Scope => ScopeAxis[T],
+        name: T => String,
+        description: T => Option[String],
+        label: String,
+    ): Parser[ScopeAxis[T]] = {
+      def getChoice(s: Scope): Seq[(String, T)] = axis(s) match {
+        case Select(t) => (name(t), t) :: Nil
+        case _         => Nil
+      }
+      def getChoices(scopes: Seq[Scope]): Map[String, T] = scopes.flatMap(getChoice).toMap
+      val definedChoices: Set[String] =
+        definedScopes.flatMap(s => axis(s).toOption.map(name)).toSet
+      val fullChoices: Map[String, T] = getChoices(allScopes)
+      val completions = fixedCompletions { (seen, level) =>
+        completeScope(seen, level, definedChoices, fullChoices)(description).toSet
+      }
+      Act.optionalAxis(
+        inParser ~> token(Space) ~> token(scalaID(fullChoices, label), completions),
+        This,
+      )
     }
+    val configurations: Map[String, Configuration] =
+      context.configurations.map(c => (configScalaID(c.name), c)).toMap
+    val configParser = axisParser[ConfigKey](
+      _.config,
+      c => configScalaID(c.name),
+      ck => configurations.get(ck.name).map(_.description),
+      "configuration",
+    )
+    val taskParser =
+      axisParser[AttributeKey[_]](_.task, k => keyScalaID(k.label), _.description, "task")
+    val nonGlobal = (configParser ~ taskParser) map { case (c, t) => Scope(This, c, t, Zero) }
+    val global = inParser ~> token((Space ~ GlobalID) ^^^ Global)
+    global | nonGlobal
+  }
 
   /** Parser for the assignment method (such as `:=`) for defining `key`. */
-  def assign(key: ScopedKey[_]): Parser[Assign.Value] =
-    {
-      val completions = fixedCompletions { (seen, level) => completeAssign(seen, level, key).toSet }
-      val identifier = Act.filterStrings(Op, Assign.values.map(_.toString), "assignment method") map Assign.withName
-      token(Space) ~> token(optionallyQuoted(identifier), completions)
+  def assign(key: ScopedKey[_]): Parser[Assign.Value] = {
+    val completions = fixedCompletions { (seen, _) =>
+      completeAssign(seen, key).toSet
     }
+    val identifier = Act.filterStrings(Op, Assign.values.map(_.toString), "assignment method") map Assign.withName
+    token(Space) ~> token(optionallyQuoted(identifier), completions)
+  }
 
   private[this] def fixedCompletions(f: (String, Int) => Set[Completion]): TokenCompletions =
     TokenCompletions.fixed((s, l) => Completions(f(s, l)))
 
-  private[this] def scalaID[T](keyMap: Map[String, T], label: String): Parser[T] =
-    {
-      val identifier = Act.filterStrings(ScalaID, keyMap.keySet, label) map keyMap
-      optionallyQuoted(identifier)
-    }
+  private[this] def scalaID[T](keyMap: Map[String, T], label: String): Parser[T] = {
+    val identifier = Act.filterStrings(ScalaID, keyMap.keySet, label) map keyMap
+    optionallyQuoted(identifier)
+  }
 
   /** Produce a new parser that allows the input accepted by `p` to be quoted in backticks. */
   def optionallyQuoted[T](p: Parser[T]): Parser[T] =
-    (Backtick.? ~ p) flatMap { case (quote, id) => if (quote.isDefined) Backtick.? ^^^ id else success(id) }
+    (Backtick.? ~ p) flatMap {
+      case (quote, id) => if (quote.isDefined) Backtick.? ^^^ id else success(id)
+    }
 
   /**
    * Completions for an assignment method for `key` given the tab completion `level` and existing partial string `seen`.
    * This will filter possible assignment methods based on the underlying type of `key`, so that only `<<=` is shown for input tasks, for example.
    */
-  def completeAssign(seen: String, level: Int, key: ScopedKey[_]): Seq[Completion] =
-    {
-      val allowed: Iterable[Assign.Value] =
-        if (appendable(key.key)) Assign.values
-        else assignNoAppend
-      val applicable = allowed.toSeq.flatMap { a =>
-        val s = a.toString
-        if (s startsWith seen) (s, a) :: Nil else Nil
+  def completeAssign(seen: String, key: ScopedKey[_]): Seq[Completion] = {
+    val allowed: Iterable[Assign.Value] =
+      if (appendable(key.key)) Assign.values
+      else assignNoAppend
+    val applicable = allowed.toSeq.flatMap { a =>
+      val s = a.toString
+      if (s startsWith seen) (s, a) :: Nil else Nil
+    }
+    completeDescribed(seen, true, applicable)(assignDescription)
+  }
+
+  def completeKey(
+      seen: String,
+      keys: Map[String, AttributeKey[_]],
+      level: Int,
+      prominentCutoff: Int,
+      detailLimit: Int
+  ): Seq[Completion] =
+    completeSelectDescribed(seen, level, keys, detailLimit)(_.description) {
+      case (_, v) => v.rank <= prominentCutoff
+    }
+
+  def completeScope[T](
+      seen: String,
+      level: Int,
+      definedChoices: Set[String],
+      allChoices: Map[String, T]
+  )(description: T => Option[String]): Seq[Completion] =
+    completeSelectDescribed(seen, level, allChoices, 10)(description) {
+      case (k, _) => definedChoices(k)
+    }
+
+  def completeSelectDescribed[T](seen: String, level: Int, all: Map[String, T], detailLimit: Int)(
+      description: T => Option[String]
+  )(prominent: (String, T) => Boolean): Seq[Completion] = {
+    val applicable = all.toSeq.filter { case (k, _) => k startsWith seen }
+    val prominentOnly = applicable filter { case (k, v) => prominent(k, v) }
+
+    val showAll = (level >= 3) || (level == 2 && prominentOnly.lengthCompare(detailLimit) <= 0) || prominentOnly.isEmpty
+    val showKeys = if (showAll) applicable else prominentOnly
+    val showDescriptions = (level >= 2) || showKeys.lengthCompare(detailLimit) <= 0
+    completeDescribed(seen, showDescriptions, showKeys)(s => description(s).toList.mkString)
+  }
+  def completeDescribed[T](seen: String, showDescriptions: Boolean, in: Seq[(String, T)])(
+      description: T => String
+  ): Seq[Completion] = {
+    def appendString(id: String): String = id.stripPrefix(seen) + " "
+    if (in.isEmpty)
+      Nil
+    else if (showDescriptions) {
+      val withDescriptions = in map { case (id, key) => (id, description(key)) }
+      val padded = CommandUtil.aligned("", "   ", withDescriptions)
+      (padded, in).zipped.map {
+        case (line, (id, _)) =>
+          Completion.tokenDisplay(append = appendString(id), display = line + "\n")
       }
-      completeDescribed(seen, true, applicable)(assignDescription)
-    }
-
-  def completeKey(seen: String, keys: Map[String, AttributeKey[_]], level: Int, prominentCutoff: Int, detailLimit: Int): Seq[Completion] =
-    completeSelectDescribed(seen, level, keys, detailLimit)(_.description) { case (k, v) => v.rank <= prominentCutoff }
-
-  def completeScope[T](seen: String, level: Int, definedChoices: Set[String], allChoices: Map[String, T])(description: T => Option[String]): Seq[Completion] =
-    completeSelectDescribed(seen, level, allChoices, 10)(description) { case (k, v) => definedChoices(k) }
-
-  def completeSelectDescribed[T](seen: String, level: Int, all: Map[String, T], detailLimit: Int)(description: T => Option[String])(prominent: (String, T) => Boolean): Seq[Completion] =
-    {
-      val applicable = all.toSeq.filter { case (k, v) => k startsWith seen }
-      val prominentOnly = applicable filter { case (k, v) => prominent(k, v) }
-
-      val showAll = (level >= 3) || (level == 2 && prominentOnly.size <= detailLimit) || prominentOnly.isEmpty
-      val showKeys = if (showAll) applicable else prominentOnly
-      val showDescriptions = (level >= 2) || (showKeys.size <= detailLimit)
-      completeDescribed(seen, showDescriptions, showKeys)(s => description(s).toList.mkString)
-    }
-  def completeDescribed[T](seen: String, showDescriptions: Boolean, in: Seq[(String, T)])(description: T => String): Seq[Completion] =
-    {
-      def appendString(id: String): String = id.stripPrefix(seen) + " "
-      if (in.isEmpty)
-        Nil
-      else if (showDescriptions) {
-        val withDescriptions = in map { case (id, key) => (id, description(key)) }
-        val padded = CommandUtil.aligned("", "   ", withDescriptions)
-        (padded, in).zipped.map {
-          case (line, (id, key)) =>
-            Completion.tokenDisplay(append = appendString(id), display = line + "\n")
-        }
-      } else
-        in map {
-          case (id, key) =>
-            Completion.tokenDisplay(display = id, append = appendString(id))
-        }
-    }
+    } else
+      in map { case (id, _) => Completion.tokenDisplay(display = id, append = appendString(id)) }
+  }
 
   /**
-   * Transforms the hypenated key label `k` into camel-case and quotes it with backticks if it is a Scala keyword.
+   * Transforms the hyphenated key label `k` into camel-case and quotes it with backticks if it is a Scala keyword.
    * This is intended to be an estimate of the Scala identifier that may be used to reference the keyword in the default sbt context.
    */
   def keyScalaID(k: String): String = Util.quoteIfKeyword(Util.hyphenToCamel(k))
@@ -279,17 +352,20 @@ private[sbt] object SettingCompletions {
   def configScalaID(c: String): String = Util.quoteIfKeyword(c.capitalize)
 
   /** Applies a function on the underlying manifest for T for `key` depending if it is for a `Setting[T]`, `Task[T]`, or `InputTask[T]`.*/
-  def keyType[S](key: AttributeKey[_])(onSetting: Manifest[_] => S, onTask: Manifest[_] => S, onInput: Manifest[_] => S)(implicit tm: Manifest[Task[_]], im: Manifest[InputTask[_]]): S =
-    {
-      def argTpe = key.manifest.typeArguments.head
-      val TaskClass = tm.runtimeClass
-      val InputTaskClass = im.runtimeClass
-      key.manifest.runtimeClass match {
-        case TaskClass      => onTask(argTpe)
-        case InputTaskClass => onInput(argTpe)
-        case _              => onSetting(key.manifest)
-      }
+  def keyType[S](key: AttributeKey[_])(
+      onSetting: Manifest[_] => S,
+      onTask: Manifest[_] => S,
+      onInput: Manifest[_] => S
+  )(implicit tm: Manifest[Task[_]], im: Manifest[InputTask[_]]): S = {
+    def argTpe = key.manifest.typeArguments.head
+    val TaskClass = tm.runtimeClass
+    val InputTaskClass = im.runtimeClass
+    key.manifest.runtimeClass match {
+      case TaskClass      => onTask(argTpe)
+      case InputTaskClass => onInput(argTpe)
+      case _              => onSetting(key.manifest)
     }
+  }
 
   /** For a Task[T], InputTask[T], or Setting[T], this returns the manifest for T. */
   def keyUnderlyingType(key: AttributeKey[_]): Manifest[_] = keyType(key)(idFun, idFun, idFun)
@@ -298,30 +374,19 @@ private[sbt] object SettingCompletions {
    * Returns a string representation of the underlying type T for a `key` representing a `Setting[T]`, `Task[T]`, or `InputTask[T]`.
    * This string representation is currently a cleaned up toString of the underlying Manifest.
    */
-  def keyTypeString[T](key: AttributeKey[_]): String =
-    {
-      val mfToString = (mf: Manifest[_]) => complete.TypeString.cleanup(mf.toString)
-      keyType(key)(mfToString, mfToString, mfToString)
-    }
-
-  /** True if the `key` represents an input task, false if it represents a task or setting. */
-  def isInputTask(key: AttributeKey[_]): Boolean = keyType(key)(const(false), const(false), const(true))
-
-  /** True if the `key` represents a setting, false if it represents a task or an input task.*/
-  def isSetting(key: AttributeKey[_]): Boolean = keyType(key)(const(true), const(false), const(false))
-
-  /** True if the `key` represents a setting or task, false if it is for an input task. */
-  def isTaskOrSetting(key: AttributeKey[_]): Boolean = keyType(key)(const(true), const(true), const(false))
+  def keyTypeString[T](key: AttributeKey[_]): String = {
+    val mfToString = (mf: Manifest[_]) => complete.TypeString.cleanup(mf.toString)
+    keyType(key)(mfToString, mfToString, mfToString)
+  }
 
   /** True if the `key` represents a setting or task that may be appended using an assignment method such as `+=`. */
-  def appendable(key: AttributeKey[_]): Boolean =
-    {
-      val underlying = keyUnderlyingType(key).runtimeClass
-      appendableClasses.exists(_ isAssignableFrom underlying)
-    }
+  def appendable(key: AttributeKey[_]): Boolean = {
+    val underlying = keyUnderlyingType(key).runtimeClass
+    appendableClasses.exists(_ isAssignableFrom underlying)
+  }
 
-  /** The simple name of the global scope axis, which can be used to reference it in the default setting context. */
-  final val GlobalID = Global.getClass.getSimpleName.stripSuffix("$")
+  /** The simple name of the Global scope, which can be used to reference it in the default setting context. */
+  final val GlobalID = Scope.Global.getClass.getSimpleName.stripSuffix("$")
 
   /** Character used to quote a Scala identifier that would otherwise be interpreted as a keyword.*/
   final val Backtick = '`'
@@ -337,6 +402,7 @@ private[sbt] object SettingCompletions {
     val Update = Value("~=")
   }
   import Assign._
+
   /** Returns the description associated with the provided assignment method. */
   def assignDescription(a: Assign.Value): String = a match {
     case AppendValue  => "append value"
@@ -344,6 +410,7 @@ private[sbt] object SettingCompletions {
     case Define       => "define value, overwriting any existing value"
     case Update       => "transform existing value"
   }
+
   /** The assignment methods except for the ones that append. */
   val assignNoAppend: Set[Assign.Value] = Set(Define, Update)
 
diff --git a/main/src/main/scala/sbt/internal/SettingGraph.scala b/main/src/main/scala/sbt/internal/SettingGraph.scala
index 0323d4e06..fdf5f30ec 100644
--- a/main/src/main/scala/sbt/internal/SettingGraph.scala
+++ b/main/src/main/scala/sbt/internal/SettingGraph.scala
@@ -1,45 +1,64 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Mark Harrah, Eugene Yokota
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package internal
 
-import sbt.internal.util.Show
-
+import sbt.util.Show
 import java.io.File
-import Def.{ compiled, flattenLocals, ScopedKey }
-import Predef.{ any2stringadd => _, _ }
 
+import Def.{ ScopedKey, compiled, flattenLocals }
+import sbt.internal.util.Terminal
+
+import Predef.{ any2stringadd => _, _ }
 import sbt.io.IO
 
 object SettingGraph {
-  def apply(structure: BuildStructure, basedir: File, scoped: ScopedKey[_], generation: Int)(implicit display: Show[ScopedKey[_]]): SettingGraph =
-    {
-      val cMap = flattenLocals(compiled(structure.settings, false)(structure.delegates, structure.scopeLocal, display))
-      def loop(scoped: ScopedKey[_], generation: Int): SettingGraph =
-        {
-          val key = scoped.key
-          val scope = scoped.scope
-          val definedIn = structure.data.definingScope(scope, key) map { sc => display(ScopedKey(sc, key)) }
-          val depends = cMap.get(scoped) match { case Some(c) => c.dependencies.toSet; case None => Set.empty }
-          // val related = cMap.keys.filter(k => k.key == key && k.scope != scope)
-          // val reverse = reverseDependencies(cMap, scoped)
+  def apply(structure: BuildStructure, basedir: File, scoped: ScopedKey[_], generation: Int)(
+      implicit display: Show[ScopedKey[_]]
+  ): SettingGraph = {
+    val cMap = flattenLocals(
+      compiled(structure.settings, false)(structure.delegates, structure.scopeLocal, display)
+    )
+    def loop(scoped: ScopedKey[_], generation: Int): SettingGraph = {
+      val key = scoped.key
+      val scope = scoped.scope
+      val definedIn = structure.data.definingScope(scope, key) map { sc =>
+        display.show(ScopedKey(sc, key))
+      }
+      val depends = cMap.get(scoped) match {
+        case Some(c) => c.dependencies.toSet; case None => Set.empty
+      }
+      // val related = cMap.keys.filter(k => k.key == key && k.scope != scope)
+      // val reverse = reverseDependencies(cMap, scoped)
 
-          SettingGraph(display(scoped), definedIn,
-            Project.scopedKeyData(structure, scope, key),
-            key.description, basedir,
-            depends map { (x: ScopedKey[_]) => loop(x, generation + 1) })
+      SettingGraph(
+        display.show(scoped),
+        definedIn,
+        Project.scopedKeyData(structure, scope, key),
+        key.description,
+        basedir,
+        depends map { (x: ScopedKey[_]) =>
+          loop(x, generation + 1)
         }
-      loop(scoped, generation)
+      )
     }
+    loop(scoped, generation)
+  }
 }
 
-case class SettingGraph(name: String,
+case class SettingGraph(
+    name: String,
     definedIn: Option[String],
     data: Option[ScopedKeyData[_]],
     description: Option[String],
     basedir: File,
-    depends: Set[SettingGraph]) {
+    depends: Set[SettingGraph]
+) {
   def dataString: String =
     data map { d =>
       d.settingValue map {
@@ -48,9 +67,12 @@ case class SettingGraph(name: String,
       } getOrElse { d.typeName }
     } getOrElse { "" }
 
-  def dependsAscii: String = Graph.toAscii(this,
+  def dependsAscii(defaultWidth: Int): String = Graph.toAscii(
+    this,
     (x: SettingGraph) => x.depends.toSeq.sortBy(_.name),
-    (x: SettingGraph) => "%s = %s" format (x.definedIn getOrElse { "" }, x.dataString))
+    (x: SettingGraph) => "%s = %s" format (x.definedIn getOrElse { "" }, x.dataString),
+    defaultWidth
+  )
 }
 
 object Graph {
@@ -59,10 +81,12 @@ object Graph {
   // [info]   | +-baz
   // [info]   |
   // [info]   +-quux
-  def toAscii[A](top: A, children: A => Seq[A], display: A => String): String = {
-    val defaultWidth = 40
-    // TODO: Fix JLine
-    val maxColumn = math.max( /*JLine.usingTerminal(_.getWidth)*/ 0, defaultWidth) - 8
+  def toAscii[A](
+      top: A,
+      children: A => Seq[A],
+      display: A => String,
+      maxColumn: Int
+  ): String = {
     val twoSpaces = " " + " " // prevent accidentally being converted into a tab
     def limitLine(s: String): String =
       if (s.length > maxColumn) s.slice(0, maxColumn - 2) + ".."
@@ -76,21 +100,33 @@ object Graph {
           }) +
           s.slice(at + 1, s.length)
       else s
-    def toAsciiLines(node: A, level: Int): (String, Vector[String]) = {
-      val line = limitLine((twoSpaces * level) + (if (level == 0) "" else "+-") + display(node))
-      val cs = Vector(children(node): _*)
-      val childLines = cs map { toAsciiLines(_, level + 1) }
-      val withBar = childLines.zipWithIndex flatMap {
-        case ((line, withBar), pos) if pos < (cs.size - 1) =>
-          (line +: withBar) map { insertBar(_, 2 * (level + 1)) }
-        case ((line, withBar), pos) if withBar.lastOption.getOrElse(line).trim != "" =>
-          (line +: withBar) ++ Vector(twoSpaces * (level + 1))
-        case ((line, withBar), _) => line +: withBar
+    def toAsciiLines(node: A, level: Int, parents: Set[A]): Vector[String] =
+      if (parents contains node) // cycle
+        Vector(limitLine((twoSpaces * level) + "#-" + display(node) + " (cycle)"))
+      else {
+        val line = limitLine((twoSpaces * level) + (if (level == 0) "" else "+-") + display(node))
+        val cs = Vector(children(node): _*)
+        val childLines = cs map {
+          toAsciiLines(_, level + 1, parents + node)
+        }
+        val withBar = childLines.zipWithIndex flatMap {
+          case (lines, pos) if pos < (cs.size - 1) =>
+            lines map {
+              insertBar(_, 2 * (level + 1))
+            }
+          case (lines, pos) =>
+            if (lines.last.trim != "") lines ++ Vector(twoSpaces * (level + 1))
+            else lines
+        }
+        line +: withBar
       }
-      (line, withBar)
-    }
 
-    val (line, withBar) = toAsciiLines(top, 0)
-    (line +: withBar).mkString("\n")
+    toAsciiLines(top, 0, Set.empty).mkString("\n")
+  }
+
+  def defaultColumnSize: Int = {
+    val termWidth = Terminal.console.getWidth
+    if (termWidth > 20) termWidth - 8
+    else 80 // ignore termWidth
   }
 }
diff --git a/main/src/main/scala/sbt/internal/ShutdownHooks.scala b/main/src/main/scala/sbt/internal/ShutdownHooks.scala
new file mode 100644
index 000000000..385848371
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/ShutdownHooks.scala
@@ -0,0 +1,47 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicInteger }
+
+import scala.util.control.NonFatal
+
+private[sbt] object ShutdownHooks extends AutoCloseable {
+  private[this] val idGenerator = new AtomicInteger(0)
+  private[this] val hooks = new ConcurrentHashMap[Int, () => Unit]
+  private[this] val ranHooks = new AtomicBoolean(false)
+  private[this] val thread = new Thread("shutdown-hooks-run-all") {
+    override def run(): Unit = runAll()
+  }
+  private[this] val runtime = Runtime.getRuntime
+  runtime.addShutdownHook(thread)
+  private[sbt] def add[R](task: () => R): AutoCloseable = {
+    val id = idGenerator.getAndIncrement()
+    hooks.put(
+      id,
+      () =>
+        try {
+          task()
+          ()
+        } catch {
+          case NonFatal(e) =>
+            System.err.println(s"Caught exception running shutdown hook: $e")
+            e.printStackTrace(System.err)
+        }
+    )
+    () => Option(hooks.remove(id)).foreach(_.apply())
+  }
+  private def runAll(): Unit = if (ranHooks.compareAndSet(false, true)) {
+    hooks.forEachValue(runtime.availableProcessors.toLong, (_: () => Unit).apply())
+  }
+  override def close(): Unit = {
+    runtime.removeShutdownHook(thread)
+    runAll()
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/SysProp.scala b/main/src/main/scala/sbt/internal/SysProp.scala
new file mode 100644
index 000000000..c761e7f04
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/SysProp.scala
@@ -0,0 +1,219 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.File
+import java.util.Locale
+
+import scala.util.control.NonFatal
+import scala.concurrent.duration._
+import sbt.internal.util.{ Terminal => ITerminal, Util }
+import sbt.internal.util.complete.SizeParser
+import sbt.nio.Keys._
+import sbt.io.syntax._
+
+// See also BuildPaths.scala
+// See also LineReader.scala
+object SysProp {
+  def booleanOpt(name: String): Option[Boolean] =
+    sys.props.get(name) match {
+      case Some(x) => parseBoolean(x)
+      case _ =>
+        sys.env.get(name.toUpperCase(Locale.ENGLISH).replace('.', '_')) match {
+          case Some(x) => parseBoolean(x)
+          case _       => None
+        }
+    }
+  private def parseBoolean(value: String): Option[Boolean] =
+    value.toLowerCase(Locale.ENGLISH) match {
+      case "1" | "always" | "true" => Some(true)
+      case "0" | "never" | "false" => Some(false)
+      case "auto"                  => None
+      case _                       => None
+    }
+
+  def getOrFalse(name: String): Boolean = booleanOpt(name).getOrElse(false)
+  def getOrTrue(name: String): Boolean = booleanOpt(name).getOrElse(true)
+
+  def long(name: String, default: Long): Long =
+    sys.props.get(name) match {
+      case Some(str) =>
+        try {
+          str.toLong
+        } catch {
+          case NonFatal(_) => default
+        }
+      case _ => default
+    }
+
+  def int(name: String, default: Int): Int =
+    sys.props.get(name) match {
+      case Some(str) =>
+        try {
+          str.toInt
+        } catch {
+          case NonFatal(_) => default
+        }
+      case _ => default
+    }
+
+  def double(name: String, default: Double): Double =
+    sys.props.get(name) match {
+      case Some(str) =>
+        try {
+          str.toDouble
+        } catch {
+          case NonFatal(_) => default
+        }
+      case _ => default
+    }
+
+  // System property style:
+  //   1. use sbt. prefix
+  //   2. prefer short nouns
+  //   3. use dot for namespacing, and avoid making dot-separated English phrase
+  //   4. make active/enable properties, instead of "sbt.disable."
+  //
+  // Good: sbt.offline
+  //
+  // Bad:
+  // sbt.disable.interface.classloader.cache
+  // sbt.task.timings.on.shutdown
+  // sbt.skip.version.write -> sbt.genbuildprops=false
+
+  def offline: Boolean = getOrFalse("sbt.offline")
+  def traces: Boolean = getOrFalse("sbt.traces")
+  def client: Boolean = getOrFalse("sbt.client")
+  def ci: Boolean = getOrFalse("sbt.ci")
+  def allowRootDir: Boolean = getOrFalse("sbt.rootdir")
+  def legacyTestReport: Boolean = getOrFalse("sbt.testing.legacyreport")
+  def semanticdb: Boolean = getOrFalse("sbt.semanticdb")
+  def forceServerStart: Boolean = getOrFalse("sbt.server.forcestart")
+
+  def watchMode: String =
+    sys.props.get("sbt.watch.mode").getOrElse("auto")
+
+  @deprecated("Resident compilation is no longer supported", "1.4.0")
+  def residentLimit: Int = int("sbt.resident.limit", 0)
+
+  /**
+   * Indicates whether formatting has been disabled in environment variables.
+   * 1. -Dsbt.log.noformat=true means no formatting.
+   * 2. -Dsbt.color=always/auto/never/true/false
+   * 3. -Dsbt.colour=always/auto/never/true/false
+   * 4. -Dsbt.log.format=always/auto/never/true/false
+   */
+  lazy val color: Boolean = ITerminal.isColorEnabled
+
+  def closeClassLoaders: Boolean = getOrFalse("sbt.classloader.close")
+
+  def fileCacheSize: Long =
+    SizeParser(System.getProperty("sbt.file.cache.size", "128M")).getOrElse(128L * 1024 * 1024)
+  def dumbTerm: Boolean = sys.env.get("TERM").contains("dumb")
+  def supershell: Boolean = booleanOpt("sbt.supershell").getOrElse(!dumbTerm && color)
+
+  def supershellMaxTasks: Int = int("sbt.supershell.maxitems", 8)
+  def supershellSleep: Long = long("sbt.supershell.sleep", 500.millis.toMillis)
+  def supershellThreshold: FiniteDuration = long("sbt.supershell.threshold", 100L).millis
+  def supershellBlankZone: Int = int("sbt.supershell.blankzone", 1)
+
+  def defaultUseCoursier: Boolean = {
+    val coursierOpt = booleanOpt("sbt.coursier")
+    val ivyOpt = booleanOpt("sbt.ivy")
+    val notIvyOpt = ivyOpt map { !_ }
+    coursierOpt.orElse(notIvyOpt).getOrElse(true)
+  }
+
+  def banner: Boolean = getOrTrue("sbt.banner")
+
+  def useLog4J: Boolean = getOrFalse("sbt.log.uselog4j")
+  def turbo: Boolean = getOrFalse("sbt.turbo")
+  def pipelining: Boolean = getOrFalse("sbt.pipelining")
+
+  def taskTimings: Boolean = getOrFalse("sbt.task.timings")
+  def taskTimingsOnShutdown: Boolean = getOrFalse("sbt.task.timings.on.shutdown")
+  def taskTimingsThreshold: Long = long("sbt.task.timings.threshold", 0L)
+  def taskTimingsOmitPaths: Boolean = getOrFalse("sbt.task.timings.omit.paths")
+  def taskTimingsUnit: (String, Int) =
+    System.getProperty("sbt.task.timings.unit", "ms") match {
+      case "ns" => ("ns", 0)
+      case "us" => ("µs", 3)
+      case "ms" => ("ms", 6)
+      case "s"  => ("sec", 9)
+      case x =>
+        System.err.println(s"Unknown sbt.task.timings.unit: $x.\nUsing milliseconds.")
+        ("ms", 6)
+    }
+
+  def gcMonitor: Boolean = getOrTrue("sbt.gc.monitor")
+  def gcWindow: FiniteDuration = int("sbt.gc.monitor.window", 10).seconds
+  def gcRatio: Double = double("sbt.gc.monitor.ratio", 0.5)
+
+  /** Generate build.properties if missing. */
+  def genBuildProps: Boolean =
+    booleanOpt("sbt.genbuildprops") match {
+      case Some(x) => x
+      case None =>
+        booleanOpt("sbt.skip.version.write") match {
+          case Some(skip) => !skip
+          case None       => true
+        }
+    }
+
+  def onChangedBuildSource: WatchBuildSourceOption = {
+    val sysPropKey = "sbt.build.onchange"
+    sys.props.getOrElse(sysPropKey, "warn") match {
+      case "reload" => ReloadOnSourceChanges
+      case "warn"   => WarnOnSourceChanges
+      case "ignore" => IgnoreSourceChanges
+      case unknown =>
+        System.err.println(s"Unknown $sysPropKey: $unknown.\nUsing warn.")
+        sbt.nio.Keys.WarnOnSourceChanges
+    }
+  }
+
+  def serverUseJni = getOrFalse("sbt.ipcsocket.jni")
+
+  private[this] def file(value: String): File = new File(value)
+  private[this] def home: File = file(sys.props("user.home"))
+
+  /** Operating system specific cache directory, similar to Coursier cache.
+   */
+  def globalLocalCache: File = {
+    val appName = "sbt"
+    def propCacheDir: Option[File] = sys.props.get("sbt.global.localcache").map(file)
+    def propCacheDir2: Option[File] =
+      sys.props.get(BuildPaths.GlobalBaseProperty) match {
+        case Some(base) => Some(file(base) / "cache")
+        case _          => None
+      }
+    def envCacheDir: Option[File] = sys.env.get("SBT_LOCAL_CACHE").map(file)
+    def windowsCacheDir: Option[File] =
+      sys.env.get("LOCALAPPDATA") match {
+        case Some(app) if Util.isWindows => Some(file(app) / appName)
+        case _                           => None
+      }
+    def macCacheDir: Option[File] =
+      if (Util.isMac) Some(home / "Library" / "Caches" / appName)
+      else None
+    def linuxCache: File =
+      sys.env.get("XDG_CACHE_HOME") match {
+        case Some(cache) => file(cache) / appName
+        case _           => home / ".cache" / appName
+      }
+    def baseCache: File =
+      propCacheDir
+        .orElse(propCacheDir2)
+        .orElse(envCacheDir)
+        .orElse(windowsCacheDir)
+        .orElse(macCacheDir)
+        .getOrElse(linuxCache)
+    baseCache.getAbsoluteFile / "v1"
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/TaskName.scala b/main/src/main/scala/sbt/internal/TaskName.scala
index 1918ff85a..35b126e3c 100644
--- a/main/src/main/scala/sbt/internal/TaskName.scala
+++ b/main/src/main/scala/sbt/internal/TaskName.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -6,7 +13,10 @@ import Keys.taskDefinitionKey
 
 private[sbt] object TaskName {
   def name(node: Task[_]): String = definedName(node) getOrElse anonymousName(node)
-  def definedName(node: Task[_]): Option[String] = node.info.name orElse transformNode(node).map(displayFull)
-  def anonymousName(node: Task[_]): String = "<anon-" + System.identityHashCode(node).toHexString + ">"
-  def transformNode(node: Task[_]): Option[ScopedKey[_]] = node.info.attributes get taskDefinitionKey
-}
\ No newline at end of file
+  def definedName(node: Task[_]): Option[String] =
+    node.info.name orElse transformNode(node).map(displayFull)
+  def anonymousName(node: Task[_]): String =
+    "<anon-" + System.identityHashCode(node).toHexString + ">"
+  def transformNode(node: Task[_]): Option[ScopedKey[_]] =
+    node.info.attributes get taskDefinitionKey
+}
diff --git a/main/src/main/scala/sbt/internal/TaskProgress.scala b/main/src/main/scala/sbt/internal/TaskProgress.scala
new file mode 100644
index 000000000..cf9ce2e88
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/TaskProgress.scala
@@ -0,0 +1,209 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicInteger, AtomicReference }
+import java.util.concurrent.{ RejectedExecutionException, TimeUnit }
+
+import sbt.internal.util._
+
+import scala.collection.JavaConverters._
+import scala.concurrent.duration._
+import java.util.concurrent.{ ConcurrentHashMap, Executors, TimeoutException }
+import sbt.util.Logger
+
+/**
+ * implements task progress display on the shell.
+ */
+private[sbt] class TaskProgress(
+    sleepDuration: FiniteDuration,
+    threshold: FiniteDuration,
+    logger: Logger
+) extends AbstractTaskExecuteProgress
+    with ExecuteProgress[Task]
+    with AutoCloseable {
+  private[this] val lastTaskCount = new AtomicInteger(0)
+  private[this] val reportLoop = new AtomicReference[AutoCloseable]
+  private[this] val active = new ConcurrentHashMap[Task[_], AutoCloseable]
+  private[this] val nextReport = new AtomicReference(Deadline.now)
+  private[this] val scheduler =
+    Executors.newSingleThreadScheduledExecutor(r => new Thread(r, "sbt-progress-report-scheduler"))
+  private[this] val pending = new java.util.Vector[java.util.concurrent.Future[_]]
+  private[this] val closed = new AtomicBoolean(false)
+  private def schedule[R](duration: FiniteDuration, recurring: Boolean)(f: => R): AutoCloseable =
+    if (!closed.get) {
+      val cancelled = new AtomicBoolean(false)
+      val runnable: Runnable = () => {
+        if (!cancelled.get) {
+          try Util.ignoreResult(f)
+          catch { case _: InterruptedException => }
+        }
+      }
+      val delay = duration.toMillis
+      try {
+        val future =
+          if (recurring)
+            scheduler.scheduleAtFixedRate(runnable, delay, delay, TimeUnit.MILLISECONDS)
+          else scheduler.schedule(runnable, delay, TimeUnit.MILLISECONDS)
+        pending.add(future)
+        () => Util.ignoreResult(future.cancel(true))
+      } catch {
+        case e: RejectedExecutionException =>
+          logger.trace(e)
+          () => ()
+      }
+    } else {
+      logger.debug("tried to call schedule on closed TaskProgress")
+      () => ()
+    }
+  private[this] val executor =
+    Executors.newSingleThreadExecutor(r => new Thread(r, "sbt-task-progress-report-thread"))
+  override def close(): Unit = if (closed.compareAndSet(false, true)) {
+    Option(reportLoop.getAndSet(null)).foreach(_.close())
+    pending.forEach(f => Util.ignoreResult(f.cancel(true)))
+    pending.clear()
+    scheduler.shutdownNow()
+    executor.shutdownNow()
+    if (!executor.awaitTermination(1, TimeUnit.SECONDS) ||
+        !scheduler.awaitTermination(1, TimeUnit.SECONDS)) {
+      throw new TimeoutException
+    }
+  }
+
+  override protected def clearTimings: Boolean = true
+  override def initial(): Unit = ()
+
+  private[this] def doReport(): Unit = {
+    val runnable: Runnable = () => {
+      if (nextReport.get.isOverdue) {
+        report()
+      }
+    }
+    Util.ignoreResult(pending.add(executor.submit(runnable)))
+  }
+  override def beforeWork(task: Task[_]): Unit =
+    if (!closed.get) {
+      super.beforeWork(task)
+      reportLoop.get match {
+        case null =>
+          val loop = schedule(sleepDuration, recurring = true)(doReport())
+          reportLoop.getAndSet(loop) match {
+            case null =>
+            case l =>
+              reportLoop.set(l)
+              loop.close()
+          }
+        case s =>
+      }
+    } else {
+      logger.debug(s"called beforeWork for ${taskName(task)} after task progress was closed")
+    }
+
+  override def afterReady(task: Task[_]): Unit =
+    if (!closed.get) {
+      try {
+        Util.ignoreResult(executor.submit((() => {
+          if (skipReportTasks.contains(getShortName(task))) {
+            lastTaskCount.set(-1) // force a report for remote clients
+            report()
+          } else
+            Util.ignoreResult(active.put(task, schedule(threshold, recurring = false)(doReport())))
+        }): Runnable))
+      } catch { case _: RejectedExecutionException => }
+    } else {
+      logger.debug(s"called afterReady for ${taskName(task)} after task progress was closed")
+    }
+  override def stop(): Unit = {}
+
+  override def afterCompleted[A](task: Task[A], result: Result[A]): Unit =
+    active.remove(task) match {
+      case null =>
+      case a =>
+        a.close()
+        if (exceededThreshold(task, threshold)) report()
+    }
+
+  override def afterAllCompleted(results: RMap[Task, Result]): Unit = {
+    reportLoop.getAndSet(null) match {
+      case null =>
+      case l    => l.close()
+    }
+    // send an empty progress report to clear out the previous report
+    appendProgress(ProgressEvent("Info", Vector(), Some(lastTaskCount.get), None, None))
+  }
+  private[this] val skipReportTasks =
+    Set(
+      "installSbtn",
+      "run",
+      "runMain",
+      "bgRun",
+      "fgRun",
+      "scala",
+      "console",
+      "consoleProject",
+      "consoleQuick",
+      "state"
+    )
+  private[this] val hiddenTasks = Set(
+    "compileEarly",
+    "pickleProducts",
+  )
+  private[this] def appendProgress(event: ProgressEvent): Unit =
+    StandardMain.exchange.updateProgress(event)
+  private[this] def report(): Unit = {
+    val (currentTasks, skip) = filter(timings(active.keySet, threshold.toMicros))
+    val ltc = lastTaskCount.get
+    if (currentTasks.nonEmpty || ltc != 0) {
+      val currentTasksCount = currentTasks.size
+      def event(tasks: Vector[(Task[_], Long)]): ProgressEvent = {
+        if (tasks.nonEmpty) nextReport.set(Deadline.now + sleepDuration)
+        val toWrite = tasks.sortBy(_._2)
+        val distinct = new java.util.LinkedHashMap[String, ProgressItem]
+        toWrite.foreach {
+          case (task, elapsed) =>
+            val name = taskName(task)
+            distinct.put(name, ProgressItem(name, elapsed))
+        }
+        ProgressEvent(
+          "Info",
+          distinct.values.asScala.toVector,
+          Some(ltc),
+          None,
+          None,
+          None,
+          Some(skip)
+        )
+      }
+      lastTaskCount.set(currentTasksCount)
+      appendProgress(event(currentTasks))
+    }
+  }
+
+  private[this] def getShortName(task: Task[_]): String = {
+    val name = taskName(task)
+    name.lastIndexOf('/') match {
+      case -1 => name
+      case i =>
+        var j = i + 1
+        while (name(j) == ' ') j += 1
+        name.substring(j)
+    }
+
+  }
+  private[this] def filter(
+      tasks: Vector[(Task[_], Long)]
+  ): (Vector[(Task[_], Long)], Boolean) = {
+    tasks.foldLeft((Vector.empty[(Task[_], Long)], false)) {
+      case ((tasks, skip), pair @ (t, _)) =>
+        val shortName = getShortName(t)
+        val newSkip = skip || skipReportTasks.contains(shortName)
+        if (hiddenTasks.contains(shortName)) (tasks, newSkip) else (tasks :+ pair, newSkip)
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/TaskSequential.scala b/main/src/main/scala/sbt/internal/TaskSequential.scala
index cd38bbe66..628652dda 100644
--- a/main/src/main/scala/sbt/internal/TaskSequential.scala
+++ b/main/src/main/scala/sbt/internal/TaskSequential.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -9,97 +16,768 @@ import Def._
 trait TaskSequential {
   def sequential[B](last: Initialize[Task[B]]): Initialize[Task[B]] =
     sequential(Nil, last)
-  def sequential[A0, B](task0: Initialize[Task[A0]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
+  def sequential[A0, B](
+      task0: Initialize[Task[A0]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
     sequential(List(unitTask(task0)), last)
-  def sequential[A0, A1, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
+  def sequential[A0, A1, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
     sequential(List(unitTask(task0), unitTask(task1)), last)
-  def sequential[A0, A1, A2, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
+  def sequential[A0, A1, A2, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
     sequential(List(unitTask(task0), unitTask(task1), unitTask(task2)), last)
-  def sequential[A0, A1, A2, A3, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
+  def sequential[A0, A1, A2, A3, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
     sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3)), last)
-  def sequential[A0, A1, A2, A3, A4, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]], task15: Initialize[Task[A15]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14), unitTask(task15)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]], task15: Initialize[Task[A15]], task16: Initialize[Task[A16]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14), unitTask(task15), unitTask(task16)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]], task15: Initialize[Task[A15]], task16: Initialize[Task[A16]], task17: Initialize[Task[A17]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14), unitTask(task15), unitTask(task16), unitTask(task17)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]], task15: Initialize[Task[A15]], task16: Initialize[Task[A16]], task17: Initialize[Task[A17]], task18: Initialize[Task[A18]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14), unitTask(task15), unitTask(task16), unitTask(task17), unitTask(task18)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]], task15: Initialize[Task[A15]], task16: Initialize[Task[A16]], task17: Initialize[Task[A17]], task18: Initialize[Task[A18]], task19: Initialize[Task[A19]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14), unitTask(task15), unitTask(task16), unitTask(task17), unitTask(task18), unitTask(task19)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]], task15: Initialize[Task[A15]], task16: Initialize[Task[A16]], task17: Initialize[Task[A17]], task18: Initialize[Task[A18]], task19: Initialize[Task[A19]], task20: Initialize[Task[A20]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14), unitTask(task15), unitTask(task16), unitTask(task17), unitTask(task18), unitTask(task19), unitTask(task20)), last)
-  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, B](task0: Initialize[Task[A0]], task1: Initialize[Task[A1]], task2: Initialize[Task[A2]], task3: Initialize[Task[A3]], task4: Initialize[Task[A4]], task5: Initialize[Task[A5]], task6: Initialize[Task[A6]], task7: Initialize[Task[A7]], task8: Initialize[Task[A8]], task9: Initialize[Task[A9]], task10: Initialize[Task[A10]], task11: Initialize[Task[A11]], task12: Initialize[Task[A12]], task13: Initialize[Task[A13]], task14: Initialize[Task[A14]], task15: Initialize[Task[A15]], task16: Initialize[Task[A16]], task17: Initialize[Task[A17]], task18: Initialize[Task[A18]], task19: Initialize[Task[A19]], task20: Initialize[Task[A20]], task21: Initialize[Task[A21]],
-    last: Initialize[Task[B]]): Initialize[Task[B]] =
-    sequential(List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4), unitTask(task5), unitTask(task6), unitTask(task7), unitTask(task8), unitTask(task9), unitTask(task10), unitTask(task11), unitTask(task12), unitTask(task13), unitTask(task14), unitTask(task15), unitTask(task16), unitTask(task17), unitTask(task18), unitTask(task19), unitTask(task20), unitTask(task21)), last)
+  def sequential[A0, A1, A2, A3, A4, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(unitTask(task0), unitTask(task1), unitTask(task2), unitTask(task3), unitTask(task4)),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      task15: Initialize[Task[A15]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14),
+        unitTask(task15)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      task15: Initialize[Task[A15]],
+      task16: Initialize[Task[A16]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14),
+        unitTask(task15),
+        unitTask(task16)
+      ),
+      last
+    )
+  def sequential[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, B](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      task15: Initialize[Task[A15]],
+      task16: Initialize[Task[A16]],
+      task17: Initialize[Task[A17]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14),
+        unitTask(task15),
+        unitTask(task16),
+        unitTask(task17)
+      ),
+      last
+    )
+  def sequential[
+      A0,
+      A1,
+      A2,
+      A3,
+      A4,
+      A5,
+      A6,
+      A7,
+      A8,
+      A9,
+      A10,
+      A11,
+      A12,
+      A13,
+      A14,
+      A15,
+      A16,
+      A17,
+      A18,
+      B
+  ](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      task15: Initialize[Task[A15]],
+      task16: Initialize[Task[A16]],
+      task17: Initialize[Task[A17]],
+      task18: Initialize[Task[A18]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14),
+        unitTask(task15),
+        unitTask(task16),
+        unitTask(task17),
+        unitTask(task18)
+      ),
+      last
+    )
+  def sequential[
+      A0,
+      A1,
+      A2,
+      A3,
+      A4,
+      A5,
+      A6,
+      A7,
+      A8,
+      A9,
+      A10,
+      A11,
+      A12,
+      A13,
+      A14,
+      A15,
+      A16,
+      A17,
+      A18,
+      A19,
+      B
+  ](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      task15: Initialize[Task[A15]],
+      task16: Initialize[Task[A16]],
+      task17: Initialize[Task[A17]],
+      task18: Initialize[Task[A18]],
+      task19: Initialize[Task[A19]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14),
+        unitTask(task15),
+        unitTask(task16),
+        unitTask(task17),
+        unitTask(task18),
+        unitTask(task19)
+      ),
+      last
+    )
+  def sequential[
+      A0,
+      A1,
+      A2,
+      A3,
+      A4,
+      A5,
+      A6,
+      A7,
+      A8,
+      A9,
+      A10,
+      A11,
+      A12,
+      A13,
+      A14,
+      A15,
+      A16,
+      A17,
+      A18,
+      A19,
+      A20,
+      B
+  ](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      task15: Initialize[Task[A15]],
+      task16: Initialize[Task[A16]],
+      task17: Initialize[Task[A17]],
+      task18: Initialize[Task[A18]],
+      task19: Initialize[Task[A19]],
+      task20: Initialize[Task[A20]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14),
+        unitTask(task15),
+        unitTask(task16),
+        unitTask(task17),
+        unitTask(task18),
+        unitTask(task19),
+        unitTask(task20)
+      ),
+      last
+    )
+  def sequential[
+      A0,
+      A1,
+      A2,
+      A3,
+      A4,
+      A5,
+      A6,
+      A7,
+      A8,
+      A9,
+      A10,
+      A11,
+      A12,
+      A13,
+      A14,
+      A15,
+      A16,
+      A17,
+      A18,
+      A19,
+      A20,
+      A21,
+      B
+  ](
+      task0: Initialize[Task[A0]],
+      task1: Initialize[Task[A1]],
+      task2: Initialize[Task[A2]],
+      task3: Initialize[Task[A3]],
+      task4: Initialize[Task[A4]],
+      task5: Initialize[Task[A5]],
+      task6: Initialize[Task[A6]],
+      task7: Initialize[Task[A7]],
+      task8: Initialize[Task[A8]],
+      task9: Initialize[Task[A9]],
+      task10: Initialize[Task[A10]],
+      task11: Initialize[Task[A11]],
+      task12: Initialize[Task[A12]],
+      task13: Initialize[Task[A13]],
+      task14: Initialize[Task[A14]],
+      task15: Initialize[Task[A15]],
+      task16: Initialize[Task[A16]],
+      task17: Initialize[Task[A17]],
+      task18: Initialize[Task[A18]],
+      task19: Initialize[Task[A19]],
+      task20: Initialize[Task[A20]],
+      task21: Initialize[Task[A21]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
+    sequential(
+      List(
+        unitTask(task0),
+        unitTask(task1),
+        unitTask(task2),
+        unitTask(task3),
+        unitTask(task4),
+        unitTask(task5),
+        unitTask(task6),
+        unitTask(task7),
+        unitTask(task8),
+        unitTask(task9),
+        unitTask(task10),
+        unitTask(task11),
+        unitTask(task12),
+        unitTask(task13),
+        unitTask(task14),
+        unitTask(task15),
+        unitTask(task16),
+        unitTask(task17),
+        unitTask(task18),
+        unitTask(task19),
+        unitTask(task20),
+        unitTask(task21)
+      ),
+      last
+    )
 
-  def sequential[B](tasks: Seq[Initialize[Task[Unit]]], last: Initialize[Task[B]]): Initialize[Task[B]] =
+  def sequential[B](tasks: Seq[Initialize[Task[B]]]): Initialize[Task[B]] = {
+    val initTasks: Seq[Initialize[Task[B]]] = tasks.init
+    val lastTask: Initialize[Task[B]] = tasks.last
+    sequential(initTasks.map(unitTask), lastTask)
+  }
+
+  def sequential[B](
+      tasks: Seq[Initialize[Task[Unit]]],
+      last: Initialize[Task[B]]
+  ): Initialize[Task[B]] =
     tasks.toList match {
       case Nil => Def.task { last.value }
       case x :: xs =>
         Def.taskDyn {
-          val _ = x.value
+          Def.unit(x.value)
           sequential(xs, last)
         }
     }
   private def unitTask[A](task: Initialize[Task[A]]): Initialize[Task[Unit]] =
     Def.task {
-      task.value
+      Def.unit(task.value)
       ()
     }
 }
-
-// for {
-//   i <- 0 to 21
-// } {
-//   val idx = 0 to i
-//   val tparams = (idx map { "A" + _ }).mkString(", ")
-//   val params = (idx map { j => s"task$j: Initialize[Task[A$j]]" }).mkString(", ")
-//   val args = (idx map { j => s"unitTask(task$j)" }).mkString(", ")
-//   println(s"""  def sequential[$tparams, B]($params,
-//              |    last: Initialize[Task[B]]): Initialize[Task[B]] =
-//              |    sequential(List($args), last)""".stripMargin)
-// }
diff --git a/main/src/main/scala/sbt/internal/TaskTimings.scala b/main/src/main/scala/sbt/internal/TaskTimings.scala
index 5a9d8e46d..6f421e829 100644
--- a/main/src/main/scala/sbt/internal/TaskTimings.scala
+++ b/main/src/main/scala/sbt/internal/TaskTimings.scala
@@ -1,41 +1,85 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
-import sbt.internal.util.RMap
+import sbt.internal.util.{ ConsoleOut, RMap }
+import sbt.util.{ Level, Logger }
 
-import java.util.concurrent.ConcurrentHashMap
-import TaskName._
-
-private[sbt] final class TaskTimings extends ExecuteProgress[Task] {
-  private[this] val calledBy = new ConcurrentHashMap[Task[_], Task[_]]
-  private[this] val anonOwners = new ConcurrentHashMap[Task[_], Task[_]]
-  private[this] val timings = new ConcurrentHashMap[Task[_], Long]
+/**
+ * Measure the time elapsed for running tasks.
+ * This class is activated by adding -Dsbt.task.timings=true to the JVM options.
+ * Formatting options:
+ * - -Dsbt.task.timings.on.shutdown=true|false
+ * - -Dsbt.task.timings.unit=ns|us|ms|s
+ * - -Dsbt.task.timings.threshold=number
+ * @param reportOnShutdown    Should the report be given when exiting the JVM (true) or immediately (false)?
+ */
+private[sbt] final class TaskTimings(reportOnShutdown: Boolean, logger: Logger)
+    extends AbstractTaskExecuteProgress
+    with ExecuteProgress[Task] {
+  @deprecated("Use the constructor that takes an sbt.util.Logger parameter.", "1.3.3")
+  def this(reportOnShutdown: Boolean) =
+    this(reportOnShutdown, new Logger {
+      override def trace(t: => Throwable): Unit = {}
+      override def success(message: => String): Unit = {}
+      override def log(level: Level.Value, message: => String): Unit =
+        ConsoleOut.systemOut.println(message)
+    })
   private[this] var start = 0L
+  private[this] val threshold = SysProp.taskTimingsThreshold
+  private[this] val omitPaths = SysProp.taskTimingsOmitPaths
+  private[this] val (unit, divider) = SysProp.taskTimingsUnit
 
-  type S = Unit
+  if (reportOnShutdown) {
+    start = System.nanoTime
+    ShutdownHooks.add(() => report())
+  }
 
-  def initial = { start = System.nanoTime }
-  def registered(state: Unit, task: Task[_], allDeps: Iterable[Task[_]], pendingDeps: Iterable[Task[_]]) = {
-    pendingDeps foreach { t => if (transformNode(t).isEmpty) anonOwners.put(t, task) }
+  override def initial(): Unit = {
+    if (!reportOnShutdown)
+      start = System.nanoTime
   }
-  def ready(state: Unit, task: Task[_]) = ()
-  def workStarting(task: Task[_]) = timings.put(task, System.nanoTime)
-  def workFinished[T](task: Task[T], result: Either[Task[T], Result[T]]) = {
-    timings.put(task, System.nanoTime - timings.get(task))
-    result.left.foreach { t => calledBy.put(t, task) }
-  }
-  def completed[T](state: Unit, task: Task[T], result: Result[T]) = ()
-  def allCompleted(state: Unit, results: RMap[Task, Result]) =
-    {
-      val total = System.nanoTime - start
-      println("Total time: " + (total * 1e-6) + " ms")
-      import collection.JavaConverters._
-      def sumTimes(in: Seq[(Task[_], Long)]) = in.map(_._2).sum
-      val timingsByName = timings.asScala.toSeq.groupBy { case (t, time) => mappedName(t) } mapValues (sumTimes)
-      for ((taskName, time) <- timingsByName.toSeq.sortBy(_._2).reverse)
-        println("  " + taskName + ": " + (time * 1e-6) + " ms")
+
+  override def afterReady(task: Task[_]): Unit = ()
+  override def afterCompleted[T](task: Task[T], result: Result[T]): Unit = ()
+  override def afterAllCompleted(results: RMap[Task, Result]): Unit =
+    if (!reportOnShutdown) {
+      report()
     }
-  private[this] def inferredName(t: Task[_]): Option[String] = nameDelegate(t) map mappedName
-  private[this] def nameDelegate(t: Task[_]): Option[Task[_]] = Option(anonOwners.get(t)) orElse Option(calledBy.get(t))
-  private[this] def mappedName(t: Task[_]): String = definedName(t) orElse inferredName(t) getOrElse anonymousName(t)
+
+  override def stop(): Unit = ()
+
+  private[this] val reFilePath = raw"\{[^}]+\}".r
+
+  private[this] def report() = {
+    val total = divide(System.nanoTime - start)
+    logger.info(s"Total time: $total $unit")
+    val times = timingsByName.toSeq
+      .sortBy(_._2.get)
+      .reverse
+      .map {
+        case (name, time) =>
+          (if (omitPaths) reFilePath.replaceFirstIn(name, "") else name, divide(time.get))
+      }
+      .filter { _._2 > threshold }
+    if (times.size > 0) {
+      val maxTaskNameLength = times.map { _._1.length }.max
+      val maxTime = times.map { _._2 }.max.toString.length
+      times.foreach {
+        case (taskName, time) =>
+          logger.info(s"  ${taskName.padTo(maxTaskNameLength, ' ')}: ${""
+            .padTo(maxTime - time.toString.length, ' ')}$time $unit")
+      }
+    }
+  }
+
+  private[this] def divide(time: Long) = (1L to divider.toLong).fold(time) { (a, b) =>
+    a / 10L
+  }
 }
diff --git a/main/src/main/scala/sbt/internal/TaskTraceEvent.scala b/main/src/main/scala/sbt/internal/TaskTraceEvent.scala
new file mode 100644
index 000000000..7034c0af6
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/TaskTraceEvent.scala
@@ -0,0 +1,79 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.File
+import java.nio.file.Files
+import sbt.internal.util.{ RMap, ConsoleOut }
+import sbt.io.IO
+import sbt.io.syntax._
+import sjsonnew.shaded.scalajson.ast.unsafe.JString
+import sjsonnew.support.scalajson.unsafe.CompactPrinter
+
+/**
+ * Measure the time elapsed for running tasks, and write the result out
+ * as Chrome Trace Event Format.
+ * This class is activated by adding -Dsbt.traces=true to the JVM options.
+ */
+private[sbt] final class TaskTraceEvent
+    extends AbstractTaskExecuteProgress
+    with ExecuteProgress[Task] {
+  import AbstractTaskExecuteProgress.Timer
+  private[this] var start = 0L
+  private[this] val console = ConsoleOut.systemOut
+
+  override def initial(): Unit = ()
+  override def afterReady(task: Task[_]): Unit = ()
+  override def afterCompleted[T](task: Task[T], result: Result[T]): Unit = ()
+  override def afterAllCompleted(results: RMap[Task, Result]): Unit = ()
+  override def stop(): Unit = ()
+
+  start = System.nanoTime
+  ShutdownHooks.add(() => report())
+
+  private[this] def report() = {
+    if (anyTimings) {
+      writeTraceEvent()
+    }
+  }
+
+  private[this] def writeTraceEvent(): Unit = {
+    // import java.time.{ ZonedDateTime, ZoneOffset }
+    // import java.time.format.DateTimeFormatter
+    // val fileName = "build-" + ZonedDateTime
+    //   .now(ZoneOffset.UTC)
+    //   .format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HHmmss")) + ".trace"
+    val fileName = "build.trace"
+    val tracesDirectory = (new File("target").getAbsoluteFile) / "traces"
+    if (!tracesDirectory.exists) IO.createDirectory(tracesDirectory)
+    else ()
+    val outFile = tracesDirectory / fileName
+    val trace = Files.newBufferedWriter(outFile.toPath)
+    try {
+      trace.append("""{"traceEvents": [""")
+      def durationEvent(name: String, cat: String, t: Timer): String = {
+        val sb = new java.lang.StringBuilder(name.length + 2)
+        CompactPrinter.print(new JString(name), sb)
+        s"""{"name": ${sb.toString}, "cat": "$cat", "ph": "X", "ts": ${(t.startMicros)}, "dur": ${(t.durationMicros)}, "pid": 0, "tid": ${t.threadId}}"""
+      }
+      val entryIterator = currentTimings
+      while (entryIterator.hasNext) {
+        val (key, value) = entryIterator.next()
+        trace.append(durationEvent(taskName(key), "task", value))
+        if (entryIterator.hasNext) trace.append(",")
+      }
+      trace.append("]}")
+      ()
+    } finally {
+      trace.close()
+      try console.println(s"wrote $outFile")
+      catch { case _: java.nio.channels.ClosedChannelException => }
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/VirtualFileValueCache.scala b/main/src/main/scala/sbt/internal/VirtualFileValueCache.scala
new file mode 100644
index 000000000..02d107e83
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/VirtualFileValueCache.scala
@@ -0,0 +1,77 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.util.concurrent.ConcurrentHashMap
+import sbt.internal.inc.Stamper
+import xsbti.{ FileConverter, VirtualFile, VirtualFileRef }
+import xsbti.compile.DefinesClass
+import xsbti.compile.analysis.{ Stamp => XStamp }
+import sbt.internal.inc.Locate
+
+/**
+ * Cache based on path and its stamp.
+ */
+sealed trait VirtualFileValueCache[A] {
+  def clear(): Unit
+  def get: VirtualFile => A
+}
+
+object VirtualFileValueCache {
+  def definesClassCache(converter: FileConverter): VirtualFileValueCache[DefinesClass] = {
+    apply(converter) { x: VirtualFile =>
+      if (x.name.toString != "rt.jar") Locate.definesClass(x)
+      else (_: String) => false
+    }
+  }
+  def apply[A](converter: FileConverter)(f: VirtualFile => A): VirtualFileValueCache[A] = {
+    import collection.mutable.{ HashMap, Map }
+    val stampCache: Map[VirtualFileRef, (Long, XStamp)] = new HashMap
+    make(
+      Stamper.timeWrap(stampCache, converter, {
+        case (vf: VirtualFile) => Stamper.forContentHash(vf)
+      })
+    )(f)
+  }
+  def make[A](stamp: VirtualFile => XStamp)(f: VirtualFile => A): VirtualFileValueCache[A] =
+    new VirtualFileValueCache0[A](stamp, f)
+}
+
+private[this] final class VirtualFileValueCache0[A](
+    getStamp: VirtualFile => XStamp,
+    make: VirtualFile => A
+)(
+    implicit equiv: Equiv[XStamp]
+) extends VirtualFileValueCache[A] {
+  private[this] val backing = new ConcurrentHashMap[VirtualFile, VirtualFileCache]
+
+  def clear(): Unit = backing.clear()
+  def get = file => {
+    val ifAbsent = new VirtualFileCache(file)
+    val cache = backing.putIfAbsent(file, ifAbsent)
+    (if (cache eq null) ifAbsent else cache).get()
+  }
+
+  private[this] final class VirtualFileCache(file: VirtualFile) {
+    private[this] var stampedValue: Option[(XStamp, A)] = None
+    def get(): A = synchronized {
+      val latest = getStamp(file)
+      stampedValue match {
+        case Some((stamp, value)) if (equiv.equiv(latest, stamp)) => value
+        case _                                                    => update(latest)
+      }
+    }
+
+    private[this] def update(stamp: XStamp): A = {
+      val value = make(file)
+      stampedValue = Some((stamp, value))
+      value
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/WatchTransitiveDependencies.scala b/main/src/main/scala/sbt/internal/WatchTransitiveDependencies.scala
new file mode 100644
index 000000000..5215f4ea8
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/WatchTransitiveDependencies.scala
@@ -0,0 +1,231 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import sbt.Def._
+import sbt.Keys._
+import sbt.Project.richInitializeTask
+import sbt._
+import sbt.internal.io.Source
+import sbt.internal.nio.Globs
+import sbt.internal.util.AttributeMap
+import sbt.internal.util.complete.Parser
+import sbt.nio.FileStamper
+import sbt.nio.Keys._
+import sbt.nio.file.Glob
+
+import scala.annotation.{ nowarn, tailrec }
+
+private[sbt] object WatchTransitiveDependencies {
+  private implicit class SourceOps(val source: Source) {
+    def toGlob: Glob = {
+      val filter = source.includeFilter -- source.excludeFilter
+      Globs.apply(source.base.toPath, source.recursive, filter)
+    }
+  }
+  private[sbt] def task: Def.Initialize[Task[Seq[DynamicInput]]] =
+    Def.task(transitiveDynamicInputs(arguments.value))
+  private[sbt] def task(
+      key: ScopedKey[_]
+  ): Def.Initialize[Task[Seq[DynamicInput]]] =
+    withParams((e, cm) => Def.task(transitiveDynamicInputs(argumentsImpl(key, e, cm).value)))
+  private def withParams[R](
+      f: (Extracted, CompiledMap) => Def.Initialize[Task[R]]
+  ): Def.Initialize[Task[R]] = Def.taskDyn {
+    val extracted = Project.extract(state.value)
+    f(extracted, compile(extracted.structure))
+  }
+
+  private[sbt] def compile(structure: BuildStructure): CompiledMap = structure.compiledMap
+  private[sbt] final class Arguments(
+      val scopedKey: ScopedKey[_],
+      val extracted: Extracted,
+      val compiledMap: CompiledMap,
+      val log: sbt.util.Logger,
+      val dependencyConfigurations: Seq[(ProjectRef, Set[String])],
+      val state: State
+  ) {
+    def structure: BuildStructure = extracted.structure
+    def data: Map[Scope, AttributeMap] = extracted.structure.data.data
+  }
+
+  @nowarn
+  private def argumentsImpl(
+      scopedKey: ScopedKey[_],
+      extracted: Extracted,
+      compiledMap: CompiledMap
+  ): Def.Initialize[Task[Arguments]] = Def.task {
+    val log = (streamsManager map { mgr =>
+      val stream = mgr(scopedKey)
+      stream.open()
+      stream
+    }).value.log
+    val configs = (internalDependencyConfigurations in scopedKey.scope).value
+    new Arguments(
+      scopedKey,
+      extracted,
+      compiledMap,
+      log,
+      configs,
+      state.value
+    )
+  }
+  private val ShowTransitive = "(?:show)?(?:[ ]*)(.*)/(?:[ ]*)transitive(?:Inputs|Globs|Triggers)".r
+  private def arguments: Def.Initialize[Task[Arguments]] = Def.taskDyn {
+    Def.task {
+      val extracted = Project.extract(state.value)
+      val compiledMap = compile(extracted.structure)
+      state.value.currentCommand.map(_.commandLine) match {
+        case Some(ShowTransitive(key)) =>
+          Parser.parse(key.trim, Act.scopedKeyParser(state.value)) match {
+            case Right(scopedKey) => argumentsImpl(scopedKey, extracted, compiledMap)
+            case _                => argumentsImpl(Keys.resolvedScoped.value, extracted, compiledMap)
+          }
+        case Some(_) => argumentsImpl(Keys.resolvedScoped.value, extracted, compiledMap)
+      }
+    }.value
+  }
+  private[sbt] def transitiveDynamicInputs(args: Arguments): Seq[DynamicInput] = {
+    import args._
+    val taskScope = Project.fillTaskAxis(scopedKey).scope
+    def delegates(sk: ScopedKey[_]): Seq[ScopedKey[_]] =
+      Project.delegates(structure, sk.scope, sk.key)
+    // We add the triggers to the delegate scopes to make it possible for the user to do something
+    // like: Compile / compile / watchTriggers += baseDirectory.value ** "*.proto". We do not do the
+    // same for inputs because inputs are expected to be explicitly used as part of the task.
+    val allKeys: Seq[ScopedKey[_]] =
+      (delegates(scopedKey).toSet ++ delegates(ScopedKey(taskScope, watchTriggers.key))).toSeq
+    val keys = collectKeys(args, allKeys, Set.empty, Set.empty)
+    def getDynamicInputs(scopedKey: ScopedKey[Seq[Glob]], trigger: Boolean): Seq[DynamicInput] = {
+      data
+        .get(scopedKey.scope)
+        .map { am =>
+          am.get(scopedKey.key) match {
+            case Some(globs: Seq[Glob]) =>
+              if (!trigger) {
+                val stamper = am.get(inputFileStamper.key).getOrElse(FileStamper.Hash)
+                val forceTrigger = am.get(watchForceTriggerOnAnyChange.key).getOrElse(false)
+                globs.map(g => DynamicInput(g, stamper, forceTrigger))
+              } else {
+                globs.map(g => DynamicInput(g, FileStamper.LastModified, forceTrigger = true))
+              }
+            case None => Nil: Seq[DynamicInput]
+          }
+        }
+        .getOrElse(Nil)
+    }
+    val (inputGlobs, triggerGlobs) = keys.partition(_.key == fileInputs.key) match {
+      case (inputs, triggers) =>
+        (
+          inputs.flatMap(getDynamicInputs(_, trigger = false)),
+          triggers.flatMap(getDynamicInputs(_, trigger = true))
+        )
+    }
+    (inputGlobs ++ triggerGlobs ++ legacy(keys :+ scopedKey, args)).distinct.sorted
+  }
+
+  @nowarn
+  private def legacy(keys: Seq[ScopedKey[_]], args: Arguments): Seq[DynamicInput] = {
+    import args._
+    val projectScopes =
+      keys.view
+        .map(_.scope.copy(task = Zero, extra = Zero))
+        .distinct
+        .toIndexedSeq
+    val projects = projectScopes.flatMap(_.project.toOption).distinct.toSet
+    val scopes: Seq[Either[Scope, Seq[Glob]]] =
+      data.flatMap {
+        case (s, am) =>
+          if (s == Scope.Global || s.project.toOption.exists(projects.contains))
+            am.get(Keys.watchSources.key) match {
+              case Some(k) =>
+                k.work match {
+                  // Avoid extracted.runTask if possible.
+                  case Pure(w, _) => Some(Right(w().map(_.toGlob)))
+                  case _          => Some(Left(s))
+                }
+              case _ => None
+            }
+          else {
+            None
+          }
+      }.toSeq
+    def toDynamicInput(glob: Glob): DynamicInput =
+      DynamicInput(glob, FileStamper.LastModified, forceTrigger = true)
+    scopes.flatMap {
+      case Left(scope) =>
+        extracted.runTask(Keys.watchSources in scope, state)._2.map(s => toDynamicInput(s.toGlob))
+      case Right(globs) => globs.map(toDynamicInput)
+    }
+  }
+
+  @nowarn
+  @tailrec
+  private def collectKeys(
+      arguments: Arguments,
+      dependencies: Seq[ScopedKey[_]],
+      accumulator: Set[ScopedKey[Seq[Glob]]],
+      visited: Set[ScopedKey[_]]
+  ): Seq[ScopedKey[Seq[Glob]]] = dependencies match {
+    // Iterates until the dependency list is empty. The visited parameter prevents the graph
+    // traversal from getting stuck in a cycle.
+    case Seq(dependency, rest @ _*) =>
+      (if (!visited(dependency)) arguments.compiledMap.get(dependency) else None) match {
+        case Some(compiled) =>
+          val newVisited = visited + compiled.key
+          val baseGlobs: Seq[ScopedKey[Seq[Glob]]] = compiled.key match {
+            case key: ScopedKey[Seq[Glob]] @unchecked if isGlobKey(key) => key :: Nil
+            case _                                                      => Nil
+          }
+          val base: (Seq[ScopedKey[_]], Seq[ScopedKey[Seq[Glob]]]) = (Nil, baseGlobs)
+          val (newDependencies, newScopes) =
+            (compiled.dependencies.filterNot(newVisited) ++ compiled.settings.map(_.key))
+              .foldLeft(base) {
+                case ((d, s), key: ScopedKey[Seq[Glob]] @unchecked)
+                    if isGlobKey(key) && !newVisited(key) =>
+                  (d, s :+ key)
+                case ((d, s), key) if key.key == dynamicDependency.key =>
+                  key.scope.task.toOption
+                    .map { k =>
+                      val newKey = ScopedKey(key.scope.copy(task = Zero), k)
+                      if (newVisited(newKey)) (d, s) else (d :+ newKey, s)
+                    }
+                    .getOrElse((d, s))
+                case ((d, s), key) if key.key == transitiveClasspathDependency.key =>
+                  key.scope.task.toOption
+                    .map { task =>
+                      val zeroedTaskScope = key.scope.copy(task = Zero)
+                      val transitiveKeys = arguments.dependencyConfigurations.flatMap {
+                        case (p, configs) =>
+                          configs.map(c => ScopedKey(zeroedTaskScope in (p, ConfigKey(c)), task))
+                      }
+
+                      (d ++ transitiveKeys.filterNot(newVisited), s)
+                    }
+                    .getOrElse((d, s))
+                case ((d, s), key) =>
+                  (d ++ (if (!newVisited(key)) Some(key) else None), s)
+              }
+          // Append the Keys.triggers key in case there are no other references to Keys.triggers.
+          val transitiveTrigger = compiled.key.scope.task.toOption match {
+            case _: Some[_] => ScopedKey(compiled.key.scope, watchTriggers.key)
+            case None       => ScopedKey(Project.fillTaskAxis(compiled.key).scope, watchTriggers.key)
+          }
+          val newRest = rest ++ newDependencies ++ (if (newVisited(transitiveTrigger)) Nil
+                                                    else Some(transitiveTrigger))
+          collectKeys(arguments, newRest, accumulator ++ newScopes, newVisited)
+        case _ if rest.nonEmpty => collectKeys(arguments, rest, accumulator, visited)
+        case _                  => accumulator.toIndexedSeq
+      }
+    case _ => accumulator.toIndexedSeq
+  }
+  private[this] def isGlobKey(key: ScopedKey[_]): Boolean = key.key match {
+    case fileInputs.key | watchTriggers.key => true
+    case _                                  => false
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/graph/GraphTransformations.scala b/main/src/main/scala/sbt/internal/graph/GraphTransformations.scala
new file mode 100644
index 000000000..c7385383d
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/GraphTransformations.scala
@@ -0,0 +1,58 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+
+object GraphTransformations {
+  def reverseGraphStartingAt(graph: ModuleGraph, root: GraphModuleId): ModuleGraph = {
+    val deps = graph.reverseDependencyMap
+
+    def visit(
+        module: GraphModuleId,
+        visited: Set[GraphModuleId]
+    ): Seq[(GraphModuleId, GraphModuleId)] =
+      if (visited(module))
+        Nil
+      else
+        deps.get(module) match {
+          case Some(deps) =>
+            deps.flatMap { to =>
+              (module, to.id) +: visit(to.id, visited + module)
+            }
+          case None => Nil
+        }
+
+    val edges = visit(root, Set.empty)
+    val nodes =
+      edges
+        .foldLeft(Set.empty[GraphModuleId])((set, edge) => set + edge._1 + edge._2)
+        .map(graph.module)
+    ModuleGraph(nodes.toSeq, edges)
+  }
+
+  def ignoreScalaLibrary(scalaVersion: String, graph: ModuleGraph): ModuleGraph = {
+    def isScalaLibrary(m: Module) = isScalaLibraryId(m.id)
+    def isScalaLibraryId(id: GraphModuleId) =
+      id.organization == "org.scala-lang" && id.name == "scala-library"
+
+    def dependsOnScalaLibrary(m: Module): Boolean =
+      graph.dependencyMap(m.id).exists(isScalaLibrary)
+
+    def addScalaLibraryAnnotation(m: Module): Module = {
+      if (dependsOnScalaLibrary(m))
+        m.copy(extraInfo = m.extraInfo + " [S]")
+      else
+        m
+    }
+
+    val newNodes = graph.nodes.map(addScalaLibraryAnnotation).filterNot(isScalaLibrary)
+    val newEdges = graph.edges.filterNot(e => isScalaLibraryId(e._2))
+    ModuleGraph(newNodes, newEdges)
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/graph/backend/IvyReport.scala b/main/src/main/scala/sbt/internal/graph/backend/IvyReport.scala
new file mode 100644
index 000000000..07fb20312
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/backend/IvyReport.scala
@@ -0,0 +1,67 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package backend
+
+import scala.xml.{ NodeSeq, Document, Node }
+import scala.xml.parsing.ConstructingParser
+
+object IvyReport {
+  def fromReportFile(ivyReportFile: String): ModuleGraph =
+    fromReportXML(loadXML(ivyReportFile))
+
+  def fromReportXML(doc: Document): ModuleGraph = {
+    def edgesForModule(id: GraphModuleId, revision: NodeSeq): Seq[Edge] =
+      for {
+        caller <- revision \ "caller"
+        callerModule = moduleIdFromElement(caller, caller.attribute("callerrev").get.text)
+      } yield (moduleIdFromElement(caller, caller.attribute("callerrev").get.text), id)
+
+    val moduleEdges: Seq[(Module, Seq[Edge])] = for {
+      mod <- doc \ "dependencies" \ "module"
+      revision <- mod \ "revision"
+      rev = revision.attribute("name").get.text
+      moduleId = moduleIdFromElement(mod, rev)
+      module = Module(
+        moduleId,
+        (revision \ "license").headOption.flatMap(_.attribute("name")).map(_.text),
+        evictedByVersion =
+          (revision \ "evicted-by").headOption.flatMap(_.attribute("rev").map(_.text)),
+        error = revision.attribute("error").map(_.text)
+      )
+    } yield (module, edgesForModule(moduleId, revision))
+
+    val (nodes, edges) = moduleEdges.unzip
+
+    val info = (doc \ "info").head
+    def infoAttr(name: String): String =
+      info
+        .attribute(name)
+        .getOrElse(throw new IllegalArgumentException("Missing attribute " + name))
+        .text
+    val rootModule = Module(
+      GraphModuleId(infoAttr("organization"), infoAttr("module"), infoAttr("revision"))
+    )
+
+    ModuleGraph(rootModule +: nodes, edges.flatten)
+  }
+
+  private def moduleIdFromElement(element: Node, version: String): GraphModuleId =
+    GraphModuleId(
+      element.attribute("organization").get.text,
+      element.attribute("name").get.text,
+      version
+    )
+
+  private def loadXML(ivyReportFile: String) =
+    ConstructingParser
+      .fromSource(scala.io.Source.fromFile(ivyReportFile), preserveWS = false)
+      .document()
+}
diff --git a/main/src/main/scala/sbt/internal/graph/backend/SbtUpdateReport.scala b/main/src/main/scala/sbt/internal/graph/backend/SbtUpdateReport.scala
new file mode 100644
index 000000000..5db194c8e
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/backend/SbtUpdateReport.scala
@@ -0,0 +1,54 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package backend
+
+import scala.language.implicitConversions
+import scala.language.reflectiveCalls
+import sbt.librarymanagement.{ ModuleID, ModuleReport, ConfigurationReport }
+
+object SbtUpdateReport {
+  type OrganizationArtifactReport = {
+    def modules: Seq[ModuleReport]
+  }
+
+  def fromConfigurationReport(report: ConfigurationReport, rootInfo: ModuleID): ModuleGraph = {
+    implicit def id(sbtId: ModuleID): GraphModuleId =
+      GraphModuleId(sbtId.organization, sbtId.name, sbtId.revision)
+
+    def moduleEdges(orgArt: OrganizationArtifactReport): Seq[(Module, Seq[Edge])] = {
+      val chosenVersion = orgArt.modules.find(!_.evicted).map(_.module.revision)
+      orgArt.modules.map(moduleEdge(chosenVersion))
+    }
+
+    def moduleEdge(chosenVersion: Option[String])(report: ModuleReport): (Module, Seq[Edge]) = {
+      val evictedByVersion = if (report.evicted) chosenVersion else None
+      val jarFile = report.artifacts
+        .find(_._1.`type` == "jar")
+        .orElse(report.artifacts.find(_._1.extension == "jar"))
+        .map(_._2)
+      (
+        Module(
+          id = report.module,
+          license = report.licenses.headOption.map(_._1),
+          evictedByVersion = evictedByVersion,
+          jarFile = jarFile,
+          error = report.problem
+        ),
+        report.callers.map(caller => Edge(caller.caller, report.module))
+      )
+    }
+
+    val (nodes, edges) = report.details.flatMap(moduleEdges).unzip
+    val root = Module(rootInfo)
+
+    ModuleGraph(root +: nodes, edges.flatten)
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/graph/model.scala b/main/src/main/scala/sbt/internal/graph/model.scala
new file mode 100644
index 000000000..219e8b4f6
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/model.scala
@@ -0,0 +1,105 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+
+import java.io.File
+import sjsonnew._
+import scala.collection.mutable.{ HashMap, MultiMap, Set }
+
+private[sbt] case class GraphModuleId(organization: String, name: String, version: String) {
+  def idString: String = organization + ":" + name + ":" + version
+}
+
+private[sbt] object GraphModuleId {
+  import sjsonnew.BasicJsonProtocol.StringJsonFormat
+  implicit val graphModuleIdIso = LList.iso[GraphModuleId, String :*: String :*: String :*: LNil](
+    { m: GraphModuleId =>
+      ("organization", m.organization) :*: ("name", m.name) :*: ("version", m.version) :*: LNil
+    }, {
+      case (_, organization) :*: (_, name) :*: (_, version) :*: LNil =>
+        GraphModuleId(organization, name, version)
+    }
+  )
+}
+
+private[sbt] case class Module(
+    id: GraphModuleId,
+    license: Option[String] = None,
+    extraInfo: String = "",
+    evictedByVersion: Option[String] = None,
+    jarFile: Option[File] = None,
+    error: Option[String] = None
+) {
+  def hadError: Boolean = error.isDefined
+  def isUsed: Boolean = !isEvicted
+  def isEvicted: Boolean = evictedByVersion.isDefined
+}
+
+private[sbt] object Module {
+  import sjsonnew.BasicJsonProtocol._
+  implicit val moduleIso = LList.iso[Module, GraphModuleId :*: Option[String] :*: String :*: Option[
+    String
+  ] :*: Option[File] :*: Option[String] :*: LNil](
+    { m: Module =>
+      ("id", m.id) :*: ("license", m.license) :*: ("extraInfo", m.extraInfo) :*:
+        ("evictedByVersion", m.evictedByVersion) :*: (
+        "jarFile",
+        m.jarFile
+      ) :*: ("error", m.error) :*: LNil
+    }, {
+      case (_, id) :*: (_, license) :*: (_, extraInfo) :*: (_, evictedByVersion) :*: (_, jarFile) :*: (
+            _,
+            error
+          ) :*: LNil =>
+        Module(id, license, extraInfo, evictedByVersion, jarFile, error)
+    }
+  )
+}
+
+private[sbt] case class ModuleGraph(nodes: Seq[Module], edges: Seq[Edge]) {
+  lazy val modules: Map[GraphModuleId, Module] =
+    nodes.map(n => (n.id, n)).toMap
+
+  def module(id: GraphModuleId): Module = modules(id)
+
+  lazy val dependencyMap: Map[GraphModuleId, Seq[Module]] =
+    createMap(identity)
+
+  lazy val reverseDependencyMap: Map[GraphModuleId, Seq[Module]] =
+    createMap { case (a, b) => (b, a) }
+
+  def createMap(
+      bindingFor: ((GraphModuleId, GraphModuleId)) => (GraphModuleId, GraphModuleId)
+  ): Map[GraphModuleId, Seq[Module]] = {
+    val m = new HashMap[GraphModuleId, Set[Module]] with MultiMap[GraphModuleId, Module]
+    edges.foreach { entry =>
+      val (f, t) = bindingFor(entry)
+      m.addBinding(f, module(t))
+    }
+    m.toMap.mapValues(_.toSeq.sortBy(_.id.idString)).toMap.withDefaultValue(Nil)
+  }
+
+  def roots: Seq[Module] =
+    nodes.filter(n => !edges.exists(_._2 == n.id)).sortBy(_.id.idString)
+}
+
+private[sbt] object ModuleGraph {
+  val empty = ModuleGraph(Seq.empty, Seq.empty)
+
+  import BasicJsonProtocol._
+  implicit val moduleGraphIso = LList.iso[ModuleGraph, Vector[Module] :*: Vector[Edge] :*: LNil](
+    { g: ModuleGraph =>
+      ("nodes", g.nodes.toVector) :*: ("edges", g.edges.toVector) :*: LNil
+    }, {
+      case (_, nodes: Vector[Module]) :*: (_, edges: Vector[Edge]) :*: LNil =>
+        ModuleGraph(nodes, edges)
+    }
+  )
+}
diff --git a/main/src/main/scala/sbt/internal/graph/package.scala b/main/src/main/scala/sbt/internal/graph/package.scala
new file mode 100644
index 000000000..f1fac27a6
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/package.scala
@@ -0,0 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+package object graph {
+  type Edge = (GraphModuleId, GraphModuleId)
+  def Edge(from: GraphModuleId, to: GraphModuleId): Edge = from -> to
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/AsciiTree.scala b/main/src/main/scala/sbt/internal/graph/rendering/AsciiTree.scala
new file mode 100644
index 000000000..33f37513a
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/AsciiTree.scala
@@ -0,0 +1,42 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+import sbt.internal.util.Terminal.red
+
+object AsciiTree {
+  def asciiTree(graph: ModuleGraph): String = {
+    val deps = graph.dependencyMap
+
+    // there should only be one root node (the project itself)
+    val roots = graph.roots
+    roots
+      .map { root =>
+        Graph
+          .toAscii[Module](
+            root,
+            node => deps.getOrElse(node.id, Seq.empty[Module]),
+            displayModule,
+            Graph.defaultColumnSize
+          )
+      }
+      .mkString("\n")
+  }
+
+  def displayModule(module: Module): String =
+    red(
+      module.id.idString +
+        module.extraInfo +
+        module.error.map(" (error: " + _ + ")").getOrElse("") +
+        module.evictedByVersion.map(_ formatted " (evicted by: %s)").getOrElse(""),
+      module.hadError
+    )
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/DOT.scala b/main/src/main/scala/sbt/internal/graph/rendering/DOT.scala
new file mode 100644
index 000000000..b7e347d63
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/DOT.scala
@@ -0,0 +1,89 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+object DOT {
+  val EvictedStyle = "stroke-dasharray: 5,5"
+
+  def dotGraph(
+      graph: ModuleGraph,
+      dotHead: String,
+      nodeFormation: (String, String, String) => String,
+      labelRendering: HTMLLabelRendering
+  ): String = {
+    val nodes = {
+      for (n <- graph.nodes) yield {
+        val style = if (n.isEvicted) EvictedStyle else ""
+        val label = nodeFormation(n.id.organization, n.id.name, n.id.version)
+        """    "%s"[%s style="%s"]""".format(
+          n.id.idString,
+          labelRendering.renderLabel(label),
+          style
+        )
+      }
+    }.sorted.mkString("\n")
+
+    def originWasEvicted(edge: Edge): Boolean = graph.module(edge._1).isEvicted
+    def targetWasEvicted(edge: Edge): Boolean = graph.module(edge._2).isEvicted
+
+    // add extra edges from evicted to evicted-by module
+    val evictedByEdges: Seq[Edge] =
+      graph.nodes
+        .filter(_.isEvicted)
+        .map(m => Edge(m.id, m.id.copy(version = m.evictedByVersion.get)))
+
+    // remove edges to new evicted-by module which is now replaced by a chain
+    // dependend -> [evicted] -> dependee
+    val evictionTargetEdges =
+      graph.edges
+        .filter(targetWasEvicted)
+        .map {
+          case (from, evicted) =>
+            (from, evicted.copy(version = graph.module(evicted).evictedByVersion.get))
+        }
+        .toSet
+
+    val filteredEdges =
+      graph.edges
+        .filterNot(e => originWasEvicted(e) || evictionTargetEdges(e)) ++ evictedByEdges
+
+    val edges = {
+      for (e <- filteredEdges) yield {
+        val extra =
+          if (graph.module(e._1).isEvicted)
+            s""" [label="Evicted By" style="$EvictedStyle"]"""
+          else ""
+        """    "%s" -> "%s"%s""".format(e._1.idString, e._2.idString, extra)
+      }
+    }.sorted.mkString("\n")
+
+    s"$dotHead\n$nodes\n$edges\n}"
+  }
+
+  sealed trait HTMLLabelRendering {
+    def renderLabel(labelText: String): String
+  }
+
+  /**
+   *  Render HTML labels in Angle brackets as defined at http://graphviz.org/content/node-shapes#html
+   */
+  case object AngleBrackets extends HTMLLabelRendering {
+    def renderLabel(labelText: String): String = s"label=<$labelText>"
+  }
+
+  /**
+   * Render HTML labels with `labelType="html"` and label content in double quotes as supported by
+   * dagre-d3
+   */
+  case object LabelTypeHtml extends HTMLLabelRendering {
+    def renderLabel(labelText: String): String = s"""labelType="html" label="$labelText""""
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/DagreHTML.scala b/main/src/main/scala/sbt/internal/graph/rendering/DagreHTML.scala
new file mode 100644
index 000000000..f00a197d2
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/DagreHTML.scala
@@ -0,0 +1,38 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+import java.io.File
+import java.net.{ URLEncoder, URI }
+
+import sbt.io.IO
+
+object DagreHTML {
+  def createLink(dotGraph: String, targetDirectory: File): URI = {
+    targetDirectory.mkdirs()
+    val graphHTML = new File(targetDirectory, "graph.html")
+    TreeView.saveResource("graph.html", graphHTML)
+    IO.write(new File(targetDirectory, "dependencies.dot"), dotGraph, IO.utf8)
+
+    val graphString =
+      URLEncoder
+        .encode(dotGraph, "utf8")
+        .replaceAllLiterally("+", "%20")
+
+    IO.write(
+      new File(targetDirectory, "dependencies.dot.js"),
+      s"""data = "$graphString";""",
+      IO.utf8
+    )
+
+    new URI(graphHTML.toURI.toString)
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/FlatList.scala b/main/src/main/scala/sbt/internal/graph/rendering/FlatList.scala
new file mode 100644
index 000000000..a0a842408
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/FlatList.scala
@@ -0,0 +1,20 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+object FlatList {
+  def render(display: Module => String)(graph: ModuleGraph): String =
+    graph.modules.values.toSeq.distinct
+      .filterNot(_.isEvicted)
+      .sortBy(m => (m.id.organization, m.id.name))
+      .map(display)
+      .mkString("\n")
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/GraphML.scala b/main/src/main/scala/sbt/internal/graph/rendering/GraphML.scala
new file mode 100644
index 000000000..9f61873dc
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/GraphML.scala
@@ -0,0 +1,40 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+import scala.xml.XML
+
+object GraphML {
+  def saveAsGraphML(graph: ModuleGraph, outputFile: String): Unit = {
+    val nodesXml =
+      for (n <- graph.nodes)
+        yield <node id={n.id.idString}><data key="d0">
+                                           <y:ShapeNode>
+                                             <y:NodeLabel>{n.id.idString}</y:NodeLabel>
+                                           </y:ShapeNode>
+                                         </data></node>
+
+    val edgesXml =
+      for (e <- graph.edges)
+        yield <edge source={e._1.idString} target={e._2.idString}/>
+
+    val xml =
+      <graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:y="http://www.yworks.com/xml/graphml" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+        <key for="node" id="d0" yfiles.type="nodegraphics"/>
+        <graph id="Graph" edgedefault="undirected">
+          {nodesXml}
+          {edgesXml}
+        </graph>
+      </graphml>
+
+    XML.save(outputFile, xml)
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/LicenseInfo.scala b/main/src/main/scala/sbt/internal/graph/rendering/LicenseInfo.scala
new file mode 100644
index 000000000..27aa44708
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/LicenseInfo.scala
@@ -0,0 +1,26 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+object LicenseInfo {
+  def render(graph: ModuleGraph): String =
+    graph.nodes
+      .filter(_.isUsed)
+      .groupBy(_.license)
+      .toSeq
+      .sortBy(_._1)
+      .map {
+        case (license, modules) =>
+          license.getOrElse("No license specified") + "\n" +
+            modules.map(_.id.idString formatted "\t %s").mkString("\n")
+      }
+      .mkString("\n\n")
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/Statistics.scala b/main/src/main/scala/sbt/internal/graph/rendering/Statistics.scala
new file mode 100644
index 000000000..a52d4d387
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/Statistics.scala
@@ -0,0 +1,80 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+object Statistics {
+  def renderModuleStatsList(graph: ModuleGraph): String = {
+    case class ModuleStats(
+        id: GraphModuleId,
+        numDirectDependencies: Int,
+        numTransitiveDependencies: Int,
+        selfSize: Option[Long],
+        transitiveSize: Long,
+        transitiveDependencyStats: Map[GraphModuleId, ModuleStats]
+    ) {
+      def transitiveStatsWithSelf: Map[GraphModuleId, ModuleStats] =
+        transitiveDependencyStats + (id -> this)
+    }
+
+    def statsFor(moduleId: GraphModuleId): ModuleStats = {
+      val directDependencies = graph.dependencyMap(moduleId).filterNot(_.isEvicted).map(_.id)
+      val dependencyStats =
+        directDependencies.map(statsFor).flatMap(_.transitiveStatsWithSelf).toMap
+      val selfSize = graph.module(moduleId).jarFile.filter(_.exists).map(_.length)
+      val numDirectDependencies = directDependencies.size
+      val numTransitiveDependencies = dependencyStats.size
+      val transitiveSize = selfSize.getOrElse(0L) + dependencyStats
+        .map(_._2.selfSize.getOrElse(0L))
+        .sum
+
+      ModuleStats(
+        moduleId,
+        numDirectDependencies,
+        numTransitiveDependencies,
+        selfSize,
+        transitiveSize,
+        dependencyStats
+      )
+    }
+
+    def format(stats: ModuleStats): String = {
+      import stats._
+      def mb(bytes: Long): Double = bytes.toDouble / 1000000
+      val selfSize =
+        stats.selfSize match {
+          case Some(size) => f"${mb(size)}%7.3f"
+          case None       => "-------"
+        }
+      f"${mb(transitiveSize)}%7.3f MB $selfSize MB $numTransitiveDependencies%4d $numDirectDependencies%4d ${id.idString}%s"
+    }
+
+    val allStats =
+      graph.roots
+        .flatMap(r => statsFor(r.id).transitiveStatsWithSelf)
+        .toMap
+        .values
+        .toSeq
+        .sortBy(s => (-s.transitiveSize, -s.numTransitiveDependencies))
+
+    val header = "   TotSize    JarSize #TDe #Dep Module\n"
+
+    header +
+      allStats.map(format).mkString("\n") +
+      """
+        |
+        |Columns are
+        | - Jar-Size including dependencies
+        | - Jar-Size
+        | - Number of transitive dependencies
+        | - Number of direct dependencies
+        | - ModuleID""".stripMargin
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/graph/rendering/TreeView.scala b/main/src/main/scala/sbt/internal/graph/rendering/TreeView.scala
new file mode 100644
index 000000000..d5732f5b7
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/graph/rendering/TreeView.scala
@@ -0,0 +1,79 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package graph
+package rendering
+
+import java.io.{ OutputStream, InputStream, FileOutputStream, File }
+import java.net.URI
+
+import graph.{ Module, ModuleGraph }
+import sbt.io.IO
+
+import scala.annotation.{ nowarn, tailrec }
+import scala.util.parsing.json.{ JSONArray, JSONObject }
+
+@nowarn object TreeView {
+  def createJson(graph: ModuleGraph): String = {
+    val trees = graph.roots
+      .map(module => processSubtree(graph, module))
+      .toList
+    JSONArray(trees).toString
+  }
+
+  def createLink(graphJson: String, targetDirectory: File): URI = {
+    targetDirectory.mkdirs()
+    val graphHTML = new File(targetDirectory, "tree.html")
+    saveResource("tree.html", graphHTML)
+    IO.write(new File(targetDirectory, "tree.json"), graphJson, IO.utf8)
+    IO.write(new File(targetDirectory, "tree.data.js"), s"tree_data = $graphJson;", IO.utf8)
+    new URI(graphHTML.toURI.toString)
+  }
+
+  private def processSubtree(graph: ModuleGraph, module: Module): JSONObject = {
+    val children = graph.dependencyMap
+      .getOrElse(module.id, List())
+      .map(module => processSubtree(graph, module))
+      .toList
+    moduleAsJson(module, children)
+  }
+
+  private def moduleAsJson(module: Module, children: List[JSONObject]): JSONObject = {
+    val eviction = module.evictedByVersion.map(version => s" (evicted by $version)").getOrElse("")
+    val error = module.error.map(err => s" (errors: $err)").getOrElse("")
+    val text = module.id.idString + eviction + error
+    JSONObject(Map("text" -> text, "children" -> JSONArray(children)))
+  }
+
+  def saveResource(resourcePath: String, to: File): Unit = {
+    val is = getClass.getClassLoader.getResourceAsStream(resourcePath)
+    require(is ne null, s"Couldn't load '$resourcePath' from classpath.")
+
+    val fos = new FileOutputStream(to)
+    try copy(is, fos)
+    finally {
+      is.close()
+      fos.close()
+    }
+  }
+
+  def copy(from: InputStream, to: OutputStream): Unit = {
+    val buffer = new Array[Byte](65536)
+
+    @tailrec def rec(): Unit = {
+      val read = from.read(buffer)
+      if (read > 0) {
+        to.write(buffer, 0, read)
+        rec()
+      } else if (read == 0)
+        throw new IllegalStateException("InputStream.read returned 0")
+    }
+    rec()
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/librarymanagement/FakeRawRepository.scala b/main/src/main/scala/sbt/internal/librarymanagement/FakeRawRepository.scala
new file mode 100644
index 000000000..a8a236643
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/librarymanagement/FakeRawRepository.scala
@@ -0,0 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package librarymanagement
+
+import sbt.io.IO
+import sbt.librarymanagement.RawRepository
+
+object FakeRawRepository {
+  def create(name: String): RawRepository =
+    new RawRepository(new FakeResolver(name, IO.createTemporaryDirectory, Map.empty), name)
+}
diff --git a/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala
new file mode 100644
index 000000000..bbab26a3a
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala
@@ -0,0 +1,231 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package librarymanagement
+
+import java.nio.charset.StandardCharsets.UTF_8
+import java.nio.file.Files
+
+import lmcoursier.definitions.{ Configuration, Project }
+import org.apache.ivy.core.module.id.ModuleRevisionId
+import Def.Setting
+import sbt.Keys.{
+  csrProject,
+  csrPublications,
+  publishLocalConfiguration,
+  publishConfiguration,
+  useCoursier
+}
+import sbt.librarymanagement.PublishConfiguration
+import scala.collection.JavaConverters._
+import scala.xml.{ Node, PrefixedAttribute }
+
+object IvyXml {
+  import sbt.Project._
+
+  private def rawContent(
+      currentProject: Project,
+      shadedConfigOpt: Option[Configuration]
+  ): String = {
+
+    // Important: width = Int.MaxValue, so that no tag gets truncated.
+    // In particular, that prevents things like <foo /> to be split to
+    // <foo>
+    // </foo>
+    // by the pretty-printer.
+    // See https://github.com/sbt/sbt/issues/3412.
+    val printer = new scala.xml.PrettyPrinter(Int.MaxValue, 2)
+
+    """<?xml version="1.0" encoding="UTF-8"?>""" + '\n' +
+      printer.format(content(currentProject, shadedConfigOpt))
+  }
+
+  // These are required for publish to be fine, later on.
+  private[sbt] def writeFiles(
+      currentProject: Project,
+      shadedConfigOpt: Option[Configuration],
+      ivySbt: IvySbt,
+      log: sbt.util.Logger
+  ): Unit = {
+
+    val ivyCacheManager = ivySbt.withIvy(log)(ivy => ivy.getResolutionCacheManager)
+
+    val ivyModule = ModuleRevisionId.newInstance(
+      currentProject.module.organization.value,
+      currentProject.module.name.value,
+      currentProject.version,
+      currentProject.module.attributes.asJava
+    )
+
+    val cacheIvyFile = ivyCacheManager.getResolvedIvyFileInCache(ivyModule)
+    val cacheIvyPropertiesFile = ivyCacheManager.getResolvedIvyPropertiesInCache(ivyModule)
+
+    val content0 = rawContent(currentProject, shadedConfigOpt)
+    cacheIvyFile.getParentFile.mkdirs()
+    log.debug(s"writing Ivy file $cacheIvyFile")
+    Files.write(cacheIvyFile.toPath, content0.getBytes(UTF_8))
+
+    // Just writing an empty file here... Are these only used?
+    cacheIvyPropertiesFile.getParentFile.mkdirs()
+    Files.write(cacheIvyPropertiesFile.toPath, Array.emptyByteArray)
+    ()
+  }
+
+  private def content(project0: Project, shadedConfigOpt: Option[Configuration]): Node = {
+
+    val filterOutDependencies =
+      shadedConfigOpt.toSet[Configuration].flatMap { shadedConfig =>
+        project0.dependencies
+          .collect { case (conf, dep) if conf.value == shadedConfig.value => dep }
+      }
+
+    val project: Project = project0.withDependencies(project0.dependencies.collect {
+      case p @ (_, dep) if !filterOutDependencies(dep) => p
+    })
+
+    val infoAttrs =
+      (project.module.attributes.toSeq ++ project.properties).foldLeft[xml.MetaData](xml.Null) {
+        case (acc, (k, v)) =>
+          new PrefixedAttribute("e", k, v, acc)
+      }
+
+    val licenseElems = project.info.licenses.map {
+      case (name, urlOpt) =>
+        val n = <license name={name} />
+
+        urlOpt.fold(n) { url =>
+          n % <x url={url} />.attributes
+        }
+    }
+
+    val descriptionElem = {
+      val n = <description>{project.info.description}</description>
+      if (project.info.homePage.nonEmpty)
+        n % <x homepage={project.info.homePage} />.attributes
+      else
+        n
+    }
+
+    val infoElem = {
+      <info
+        organisation={project.module.organization.value}
+        module={project.module.name.value}
+        revision={project.version}
+      >
+        {licenseElems}
+        {descriptionElem}
+      </info>
+    } % infoAttrs
+
+    val confElems = project.configurations.toVector.collect {
+      case (name, extends0) if !shadedConfigOpt.exists(_.value == name.value) =>
+        val extends1 = shadedConfigOpt.fold(extends0)(c => extends0.filter(_.value != c.value))
+        val n = <conf name={name.value} visibility="public" description="" />
+        if (extends1.nonEmpty)
+          n % <x extends={extends1.map(_.value).mkString(",")} />.attributes
+        else
+          n
+    }
+
+    val publications = project.publications
+      .groupBy { case (_, p)             => p }
+      .mapValues { _.map { case (cfg, _) => cfg } }
+
+    val publicationElems = publications.map {
+      case (pub, configs) =>
+        val n =
+          <artifact name={pub.name} type={pub.`type`.value} ext={pub.ext.value} conf={
+            configs.map(_.value).mkString(",")
+          } />
+
+        if (pub.classifier.value.nonEmpty)
+          n % <x e:classifier={pub.classifier.value} />.attributes
+        else
+          n
+    }
+
+    val dependencyElems = project.dependencies.toVector.map {
+      case (conf, dep) =>
+        val excludes = dep.exclusions.toSeq.map {
+          case (org, name) =>
+            <exclude org={org.value} module={name.value} name="*" type="*" ext="*" conf="" matcher="exact"/>
+        }
+
+        val n =
+          <dependency org={dep.module.organization.value} name={dep.module.name.value} rev={
+            dep.version
+          } conf={s"${conf.value}->${dep.configuration.value}"}>
+          {excludes}
+        </dependency>
+
+        val moduleAttrs = dep.module.attributes.foldLeft[xml.MetaData](xml.Null) {
+          case (acc, (k, v)) =>
+            new PrefixedAttribute("e", k, v, acc)
+        }
+
+        n % moduleAttrs
+    }
+
+    <ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
+      {infoElem}
+      <configurations>{confElems}</configurations>
+      <publications>{publicationElems}</publications>
+      <dependencies>{dependencyElems}</dependencies>
+    </ivy-module>
+  }
+
+  private def makeIvyXmlBefore[T](
+      task: TaskKey[T],
+      shadedConfigOpt: Option[Configuration]
+  ): Setting[Task[T]] =
+    task := task.dependsOn {
+      Def.taskDyn {
+        val doGen = useCoursier.value
+        if (doGen)
+          Def.task {
+            val currentProject = {
+              val proj = csrProject.value
+              val publications = csrPublications.value
+              proj.withPublications(publications)
+            }
+            IvyXml.writeFiles(
+              currentProject,
+              shadedConfigOpt,
+              sbt.Keys.ivySbt.value,
+              sbt.Keys.streams.value.log
+            )
+          } else
+          Def.task(())
+      }
+    }.value
+
+  private lazy val needsIvyXmlLocal = Seq(publishLocalConfiguration) ++ getPubConf(
+    "makeIvyXmlLocalConfiguration"
+  )
+  private lazy val needsIvyXml = Seq(publishConfiguration) ++ getPubConf(
+    "makeIvyXmlConfiguration"
+  )
+
+  private[this] def getPubConf(method: String): List[TaskKey[PublishConfiguration]] =
+    try {
+      val cls = sbt.Keys.getClass
+      val m = cls.getMethod(method)
+      val task = m.invoke(sbt.Keys).asInstanceOf[TaskKey[PublishConfiguration]]
+      List(task)
+    } catch {
+      case _: Throwable => // FIXME Too wide
+        Nil
+    }
+
+  def generateIvyXmlSettings(
+      shadedConfigOpt: Option[Configuration] = None
+  ): Seq[Setting[_]] =
+    (needsIvyXml ++ needsIvyXmlLocal).map(makeIvyXmlBefore(_, shadedConfigOpt))
+
+}
diff --git a/main/src/main/scala/sbt/internal/nio/CheckBuildSources.scala b/main/src/main/scala/sbt/internal/nio/CheckBuildSources.scala
new file mode 100644
index 000000000..57be28464
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/nio/CheckBuildSources.scala
@@ -0,0 +1,215 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal.nio
+
+import java.nio.file.Path
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+import sbt.BasicCommandStrings.{ RebootCommand, Shutdown, TerminateAction }
+import sbt.Keys.{ baseDirectory, pollInterval, state }
+import sbt.Scope.Global
+import sbt.SlashSyntax0._
+import sbt.internal.CommandStrings.LoadProject
+import sbt.internal.SysProp
+import sbt.internal.util.{ AttributeKey, Terminal }
+import sbt.io.syntax._
+import sbt.nio.FileChanges
+import sbt.nio.FileStamp
+import sbt.nio.Keys._
+import sbt.nio.file.{ FileAttributes, FileTreeView, Glob, ** }
+import sbt.nio.file.syntax._
+import sbt.nio.Settings
+import sbt.util.Logger
+
+import scala.annotation.tailrec
+import scala.concurrent.duration.{ Deadline => SDeadline, _ }
+import scala.io.AnsiColor
+
+/**
+ * This class is used to determine whether sbt needs to automatically reload
+ * the build because its source files have changed. In general, it will use
+ * a FileTreeRepository to monitor the build source directories and it will
+ * only actually check whether any sources have changed if the monitor has
+ * detected any events. Because it's using asynchronous monitoring by default,
+ * the automatic reloading should not be relied upon in batch scripting. It is
+ * possible to configure this feature by setting
+ * `Global / onChangedBuildSource / pollInterval`. When this value is set to
+ * 0.seconds, then it will poll every time. Otherwise, it will only repoll
+ * the build files if the poll interval has elapsed.
+ */
+private[sbt] class CheckBuildSources extends AutoCloseable {
+  private[this] val repository = new AtomicReference[FileTreeRepository[FileAttributes]]
+  private[this] val pollingPeriod = new AtomicReference[FiniteDuration]
+  private[this] val sources = new AtomicReference[Seq[Glob]](Nil)
+  private[this] val needUpdate = new AtomicBoolean(true)
+  private[this] val lastPolled = new AtomicReference[SDeadline](SDeadline.now)
+  private[this] val previousStamps = new AtomicReference[Seq[(Path, FileStamp)]]
+  private[sbt] def fileTreeRepository: Option[FileTreeRepository[FileAttributes]] =
+    Option(repository.get)
+  private def getStamps(force: Boolean) = {
+    val now = SDeadline.now
+    val lp = lastPolled.getAndSet(now)
+    if (force || lp + pollingPeriod.get <= now) {
+      FileTreeView.default.list(sources.get) flatMap {
+        case (p, a) if a.isRegularFile => FileStamp.hash(p).map(p -> _)
+        case _                         => None
+      }
+    } else previousStamps.get
+  }
+  private def reset(state: State): Unit = {
+    val extracted = Project.extract(state)
+    val interval = extracted.get(checkBuildSources / pollInterval)
+    val newSources = extracted.get(Global / checkBuildSources / fileInputs)
+    if (interval >= 0.seconds || "polling" == SysProp.watchMode) {
+      Option(repository.getAndSet(null)).foreach(_.close())
+      pollingPeriod.set(interval)
+    } else {
+      pollingPeriod.set(0.seconds)
+      repository.get match {
+        case null =>
+          val repo = FileTreeRepository.default
+          repo.addObserver(_ => needUpdate.set(true))
+          repository.set(repo)
+          newSources.foreach(g => repo.register(g).foreach(_.close()))
+        case r =>
+      }
+    }
+    val previousSources = sources.getAndSet(newSources)
+    if (previousSources != newSources) {
+      fileTreeRepository.foreach(r => newSources.foreach(g => r.register(g).foreach(_.close())))
+      previousStamps.set(getStamps(force = true))
+    }
+  }
+  private def needCheck(state: State, cmd: String): Boolean = {
+    val allCmds = state.remainingCommands
+      .map(_.commandLine)
+      .dropWhile(!_.startsWith(BasicCommandStrings.MapExec)) :+ cmd
+    val commands =
+      allCmds.flatMap(_.split(";").flatMap(_.trim.split(" ").headOption).filterNot(_.isEmpty))
+    val filter = (c: String) =>
+      c == LoadProject || c == RebootCommand || c == TerminateAction || c == Shutdown ||
+        c.startsWith("sbtReboot")
+    val resetState = commands.exists(filter)
+    if (resetState) {
+      previousStamps.set(getStamps(force = true))
+      needUpdate.set(false)
+    }
+    // We don't need to do a check since we just updated the stamps since
+    // we are about to perform a reload or reboot.
+    !resetState
+  }
+  @inline private def forceCheck = fileTreeRepository.isEmpty
+  private[sbt] def needsReload(
+      state: State,
+      exec: Exec
+  ): Boolean = {
+    val name = exec.source.map(_.channelName)
+    val loggerOrTerminal =
+      name.flatMap(StandardMain.exchange.channelForName(_).map(_.terminal)) match {
+        case Some(t) => Right(t)
+        case _       => Left(state.globalLogging.full)
+      }
+
+    needsReload(state, loggerOrTerminal, exec.commandLine)
+  }
+  private def needsReload(
+      state: State,
+      loggerOrTerminal: Either[Logger, Terminal],
+      cmd: String
+  ): Boolean = {
+    (needCheck(state, cmd) && (forceCheck || needUpdate.compareAndSet(true, false))) && {
+      val extracted = Project.extract(state)
+      val onChanges = extracted.get(Global / onChangedBuildSource)
+      val current = getStamps(force = false)
+      val previous = previousStamps.getAndSet(current)
+      Settings.changedFiles(previous, current) match {
+        case fileChanges @ FileChanges(created, deleted, modified, _) if fileChanges.hasChanges =>
+          val rawPrefix = s"build source files have changed\n" +
+            (if (created.nonEmpty) s"new files: ${created.mkString("\n  ", "\n  ", "\n")}"
+             else "") +
+            (if (deleted.nonEmpty)
+               s"deleted files: ${deleted.mkString("\n  ", "\n  ", "\n")}"
+             else "") +
+            (if (modified.nonEmpty)
+               s"modified files: ${modified.mkString("\n  ", "\n  ", "\n")}"
+             else "")
+          val prefix = rawPrefix.linesIterator.filterNot(_.trim.isEmpty).mkString("\n")
+          if (onChanges == ReloadOnSourceChanges) {
+            val msg = s"$prefix\nReloading sbt..."
+            loggerOrTerminal match {
+              case Right(t) => msg.linesIterator.foreach(l => t.printStream.println(s"[info] $l"))
+              case Left(l)  => l.info(msg)
+            }
+            true
+          } else {
+            val tail = "Apply these changes by running `reload`.\nAutomatically reload the " +
+              "build when source changes are detected by setting " +
+              "`Global / onChangedBuildSource := ReloadOnSourceChanges`.\nDisable this " +
+              "warning by setting `Global / onChangedBuildSource := IgnoreSourceChanges`."
+            val msg = s"$prefix\n$tail"
+            loggerOrTerminal match {
+              case Right(t) =>
+                val prefix = s"[${Def.withColor("warn", Some(AnsiColor.YELLOW), t.isColorEnabled)}]"
+                msg.linesIterator.foreach(l => t.printStream.println(s"$prefix $l"))
+              case Left(l) => l.warn(msg)
+            }
+            false
+          }
+        case _ => false
+      }
+    }
+  }
+  override def close(): Unit = {}
+}
+
+private[sbt] object CheckBuildSources {
+  private[sbt] val CheckBuildSourcesKey =
+    AttributeKey[CheckBuildSources]("check-build-source", "", KeyRanks.Invisible)
+  /*
+   * Reuse the same instance of CheckBuildSources across reloads but reset the state. This
+   * should allow the `set` command to work with checkBuildSources / fileInputs and
+   * checkBuildSources / pollInterval. The latter makes it possible to switch between
+   * the asynchronous and polling implementations during the same sbt session.
+   */
+  private[sbt] def init(state: State): State = state.get(CheckBuildSourcesKey) match {
+    case Some(cbs) =>
+      cbs.reset(state)
+      state
+    case _ =>
+      val cbs = new CheckBuildSources
+      cbs.reset(state)
+      state.put(CheckBuildSourcesKey, cbs)
+  }
+  private[sbt] def needReloadImpl: Def.Initialize[Task[StateTransform]] = Def.task {
+    val st = state.value
+    st.get(CheckBuildSourcesKey) match {
+      case Some(cbs) if (cbs.needsReload(st, Exec("", None))) =>
+        StateTransform("reload" :: (_: State))
+      case _ => StateTransform(identity)
+    }
+  }
+  private[sbt] def buildSourceFileInputs: Def.Initialize[Seq[Glob]] = Def.setting {
+    if (onChangedBuildSource.value != IgnoreSourceChanges) {
+      val baseDir = (LocalRootProject / baseDirectory).value
+      val projectDir = baseDir / "project"
+      @tailrec
+      def projectGlobs(projectDir: File, globs: Seq[Glob]): Seq[Glob] = {
+        val glob = projectDir.toGlob
+        val updatedGlobs = globs ++ Seq(
+          glob / "*.{sbt,scala,java}",
+          // We only want to recursively look in source because otherwise we have to search
+          // the project target directories which is expensive.
+          glob / "src" / ** / "*.{scala,java}"
+        )
+        val nextLevel = projectDir / "project"
+        if (nextLevel.exists) projectGlobs(nextLevel, updatedGlobs) else updatedGlobs
+      }
+      projectGlobs(projectDir, baseDir.toGlob / "*.sbt" :: Nil)
+    } else Nil
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/parser/SbtParser.scala b/main/src/main/scala/sbt/internal/parser/SbtParser.scala
index 22e6e5ca0..e281368e6 100644
--- a/main/src/main/scala/sbt/internal/parser/SbtParser.scala
+++ b/main/src/main/scala/sbt/internal/parser/SbtParser.scala
@@ -1,14 +1,28 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
 import sbt.internal.util.{ LineRange, MessageOnlyException }
-
 import java.io.File
+import java.util.concurrent.ConcurrentHashMap
 
 import sbt.internal.parser.SbtParser._
 
-import scala.reflect.runtime.universe._
+import scala.compat.Platform.EOL
+import scala.reflect.internal.util.{ BatchSourceFile, Position }
+import scala.reflect.io.VirtualDirectory
+import scala.reflect.internal.Positions
+import scala.tools.nsc.{ CompilerCommand, Global, Settings }
+import scala.tools.nsc.reporters.{ ConsoleReporter, FilteringReporter, StoreReporter }
+import scala.util.Random
+import scala.util.{ Failure, Success }
 
 private[sbt] object SbtParser {
   val END_OF_LINE_CHAR = '\n'
@@ -16,21 +30,183 @@ private[sbt] object SbtParser {
   private[parser] val NOT_FOUND_INDEX = -1
   private[sbt] val FAKE_FILE = new File("fake")
   private[parser] val XML_ERROR = "';' expected but 'val' found."
+
+  private val XmlErrorMessage =
+    """Probably problem with parsing xml group, please add parens or semicolons:
+      |Replace:
+      |val xmlGroup = <a/><b/>
+      |with:
+      |val xmlGroup = (<a/><b/>)
+      |or
+      |val xmlGroup = <a/><b/>;
+    """.stripMargin
+
+  private final val defaultClasspath =
+    sbt.io.Path.makeString(sbt.io.IO.classLocationPath[Product].toFile :: Nil)
+
+  /**
+   * Provides the previous error reporting functionality in
+   * [[scala.tools.reflect.ToolBox]].
+   *
+   * This parser is a wrapper around a collection of reporters that are
+   * indexed by a unique key. This is used to ensure that the reports of
+   * one parser don't collide with other ones in concurrent settings.
+   *
+   * This parser is a sign that this whole parser should be rewritten.
+   * There are exceptions everywhere and the logic to work around
+   * the scalac parser bug heavily relies on them and it's tied
+   * to the test suite. Ideally, we only want to throw exceptions
+   * when we know for a fact that the user-provided snippet doesn't
+   * parse.
+   */
+  private[sbt] class UniqueParserReporter(val settings: Settings) extends FilteringReporter {
+
+    private val reporters = new ConcurrentHashMap[String, StoreReporter]()
+
+    override def doReport(pos: Position, msg: String, severity: Severity): Unit = {
+      val reporter = getReporter(pos.source.file.name)
+      severity.id match {
+        case 0 => reporter.echo(pos, msg)
+        case 1 => reporter.warning(pos, msg)
+        case 2 => reporter.error(pos, msg)
+      }
+    }
+
+    // weird hack to make sure errors are counted by the underlying
+    // reporters in both Scala 2.12 and 2.13.x
+    // see https://github.com/scala/bug/issues/12317
+    override def filter(pos: Position, msg: String, severity: Severity): Int = {
+      val reporter = getReporter(pos.source.file.name)
+      val result = reporter.filter(pos, msg, severity)
+      if (result <= 1) reporter.increment(severity)
+      if (result == 0) reporter.doReport(pos, msg, severity)
+      result
+    }
+
+    override def hasErrors: Boolean = {
+      var result = false
+      reporters.forEachValue(100, r => if (r.hasErrors) result = true)
+      result
+    }
+
+    def createReporter(uniqueFileName: String): StoreReporter = {
+      val r = new StoreReporter(settings)
+      reporters.put(uniqueFileName, r)
+      r
+    }
+
+    def getOrCreateReporter(uniqueFileName: String): StoreReporter = {
+      val r = reporters.get(uniqueFileName)
+      if (r == null) createReporter(uniqueFileName)
+      else r
+    }
+
+    private def getReporter(fileName: String) = {
+      val reporter = reporters.get(fileName)
+      if (reporter == null) {
+        scalacGlobalInitReporter.getOrElse(
+          sys.error(s"sbt forgot to initialize `scalacGlobalInitReporter`.")
+        )
+      } else reporter
+    }
+
+    def throwParserErrorsIfAny(reporter: StoreReporter, fileName: String): Unit = {
+      if (reporter.hasErrors) {
+        val seq = reporter.infos.map { info =>
+          s"""[$fileName]:${info.pos.line}: ${info.msg}"""
+        }
+        val errorMessage = seq.mkString(EOL)
+        val error: String =
+          if (errorMessage.contains(XML_ERROR))
+            s"$errorMessage\n${SbtParser.XmlErrorMessage}"
+          else errorMessage
+        throw new MessageOnlyException(error)
+      } else ()
+    }
+  }
+
+  private[sbt] var scalacGlobalInitReporter: Option[ConsoleReporter] = None
+
+  private[sbt] final val (defaultGlobalForParser, globalReporter) = {
+    val options = "-cp" :: s"$defaultClasspath" :: "-Yrangepos" :: Nil
+    val reportError = (msg: String) => System.err.println(msg)
+    val command = new CompilerCommand(options, reportError)
+    val settings = command.settings
+    settings.outputDirs.setSingleOutput(new VirtualDirectory("(memory)", None))
+    scalacGlobalInitReporter = Some(new ConsoleReporter(settings))
+
+    val reporter = new UniqueParserReporter(settings)
+    // Mix Positions, otherwise global ignores -Yrangepos
+    val global = new Global(settings, reporter) with Positions
+    val run = new global.Run
+    // Add required dummy unit for initialization...
+    val initFile = new BatchSourceFile("<wrapper-init>", "")
+    val _ = new global.CompilationUnit(initFile)
+    global.phase = run.parserPhase
+    (global, reporter)
+  }
+
+  import defaultGlobalForParser.Tree
+
+  /**
+   * Parse code reusing the same [[Run]] instance.
+   *
+   * @param code The code to be parsed.
+   * @param filePath The file name where the code comes from.
+   * @param reporterId0 The reporter id is the key used to get the pertinent
+   *                    reporter. Given that the parsing reuses a global
+   *                    instance, this reporter id makes sure that every parsing
+   *                    session gets its own errors in a concurrent setting.
+   *                    The reporter id must be unique per parsing session.
+   * @return
+   */
+  private[sbt] def parse(
+      code: String,
+      filePath: String,
+      reporterId0: Option[String]
+  ): (Seq[Tree], String) = {
+    import defaultGlobalForParser._
+    val reporterId = reporterId0.getOrElse(s"$filePath-${Random.nextInt}")
+    val reporter = globalReporter.getOrCreateReporter(reporterId)
+    reporter.reset()
+    val wrapperFile = new BatchSourceFile(reporterId, code)
+    val unit = new CompilationUnit(wrapperFile)
+    val parser = SbtParser.synchronized { // see https://github.com/sbt/sbt/issues/4148
+      new syntaxAnalyzer.UnitParser(unit)
+    }
+    val parsedTrees = SbtParser.synchronized { // see https://github.com/scala/bug/issues/10605
+      parser.templateStats()
+    }
+    parser.accept(scala.tools.nsc.ast.parser.Tokens.EOF)
+    globalReporter.throwParserErrorsIfAny(reporter, filePath)
+    parsedTrees -> reporterId
+  }
+}
+
+private class SbtParserInit {
+  new Thread("sbt-parser-init-thread") {
+    setDaemon(true)
+    start()
+    override def run(): Unit = {
+      val _ = SbtParser.defaultGlobalForParser
+    }
+  }
 }
 
 /**
- * This method soley exists to add scaladoc to members in SbtParser which
+ * This method solely exists to add scaladoc to members in SbtParser which
  * are defined using pattern matching.
  */
 sealed trait ParsedSbtFileExpressions {
+
   /** The set of parsed import expressions. */
   def imports: Seq[(String, Int)]
 
-  /** The set of parsed defintions and/or sbt build settings. */
+  /** The set of parsed definitions and/or sbt build settings. */
   def settings: Seq[(String, LineRange)]
 
   /** The set of scala tree's for parsed definitions/settings and the underlying string representation.. */
-  def settingsTrees: Seq[(String, Tree)]
+  def settingsTrees: Seq[(String, Global#Tree)]
 
 }
 
@@ -55,61 +231,27 @@ sealed trait ParsedSbtFileExpressions {
  */
 private[sbt] case class SbtParser(file: File, lines: Seq[String]) extends ParsedSbtFileExpressions {
   //settingsTrees,modifiedContent needed for "session save"
-  // TODO - We should look into splitting out "defintiions" vs. "settings" here instead of further string lookups, since we have the
+  // TODO - We should look into splitting out "definitions" vs. "settings" here instead of further string lookups, since we have the
   // parsed trees.
   val (imports, settings, settingsTrees) = splitExpressions(file, lines)
 
-  private def splitExpressions(file: File, lines: Seq[String]): (Seq[(String, Int)], Seq[(String, LineRange)], Seq[(String, Tree)]) = {
-    import sbt.internal.parser.MissingBracketHandler._
+  import SbtParser.defaultGlobalForParser._
 
-    import scala.compat.Platform.EOL
-    import scala.reflect.runtime._
-    import scala.tools.reflect.{ ToolBox, ToolBoxError }
+  private def splitExpressions(
+      file: File,
+      lines: Seq[String]
+  ): (Seq[(String, Int)], Seq[(String, LineRange)], Seq[(String, Tree)]) = {
+    import sbt.internal.parser.MissingBracketHandler.findMissingText
 
-    val mirror = universe.runtimeMirror(this.getClass.getClassLoader)
-    val toolbox = mirror.mkToolBox(options = "-Yrangepos")
     val indexedLines = lines.toIndexedSeq
     val content = indexedLines.mkString(END_OF_LINE)
     val fileName = file.getAbsolutePath
-
-    val parsed =
-      try {
-        toolbox.parse(content)
-      } catch {
-        case e: ToolBoxError =>
-          val seq = toolbox.frontEnd.infos.map { i =>
-            s"""[$fileName]:${i.pos.line}: ${i.msg}"""
-          }
-          val errorMessage = seq.mkString(EOL)
-
-          val error = if (errorMessage.contains(XML_ERROR)) {
-            s"""
-               |$errorMessage
-               |Probably problem with parsing xml group, please add parens or semicolons:
-               |Replace:
-               |val xmlGroup = <a/><b/>
-               |with:
-               |val xmlGroup = (<a/><b/>)
-               |or
-               |val xmlGroup = <a/><b/>;
-               |
-             """.stripMargin
-          } else {
-            errorMessage
-          }
-          throw new MessageOnlyException(error)
-      }
-    val parsedTrees = parsed match {
-      case Block(stmt, expr) =>
-        stmt :+ expr
-      case t: Tree =>
-        Seq(t)
-    }
+    val (parsedTrees, reporterId) = parse(content, fileName, None)
 
     // Check No val (a,b) = foo *or* val a,b = foo as these are problematic to range positions and the WHOLE architecture.
     def isBadValDef(t: Tree): Boolean =
       t match {
-        case x @ toolbox.u.ValDef(_, _, _, rhs) if rhs != toolbox.u.EmptyTree =>
+        case x @ ValDef(_, _, _, rhs) if rhs != EmptyTree =>
           val c = content.substring(x.pos.start, x.pos.end)
           !(c contains "=")
         case _ => false
@@ -117,24 +259,27 @@ private[sbt] case class SbtParser(file: File, lines: Seq[String]) extends Parsed
     parsedTrees.filter(isBadValDef).foreach { badTree =>
       // Issue errors
       val positionLine = badTree.pos.line
-      throw new MessageOnlyException(s"""[$fileName]:$positionLine: Pattern matching in val statements is not supported""".stripMargin)
+      throw new MessageOnlyException(
+        s"""[$fileName]:$positionLine: Pattern matching in val statements is not supported""".stripMargin
+      )
     }
 
-    val (imports, statements) = parsedTrees partition {
+    val (imports: Seq[Tree], statements: Seq[Tree]) = parsedTrees partition {
       case _: Import => true
       case _         => false
     }
 
-    /**
+    /*
      * See BugInParser
      * @param t - tree
      * @param originalStatement - original
      * @return originalStatement or originalStatement with missing bracket
      */
     def parseStatementAgain(t: Tree, originalStatement: String): String = {
-      val statement = scala.util.Try(toolbox.parse(originalStatement)) match {
-        case scala.util.Failure(th) =>
-          val missingText = findMissingText(content, t.pos.end, t.pos.line, fileName, th)
+      val statement = scala.util.Try(parse(originalStatement, fileName, Some(reporterId))) match {
+        case Failure(th) =>
+          val missingText =
+            findMissingText(content, t.pos.end, t.pos.line, fileName, th, Some(reporterId))
           originalStatement + missingText
         case _ =>
           originalStatement
@@ -154,7 +299,9 @@ private[sbt] case class SbtParser(file: File, lines: Seq[String]) extends Parsed
       }
     val stmtTreeLineRange = statements flatMap convertStatement
     val importsLineRange = importsToLineRanges(content, imports)
-    (importsLineRange, stmtTreeLineRange.map { case (stmt, _, lr) => (stmt, lr) }, stmtTreeLineRange.map { case (stmt, tree, _) => (stmt, tree) })
+    (importsLineRange, stmtTreeLineRange.map { case (stmt, _, lr) => (stmt, lr) }, stmtTreeLineRange.map {
+      case (stmt, tree, _)                                        => (stmt, tree)
+    })
   }
 
   /**
@@ -163,20 +310,23 @@ private[sbt] case class SbtParser(file: File, lines: Seq[String]) extends Parsed
    * @param imports - trees
    * @return imports per line
    */
-  private def importsToLineRanges(modifiedContent: String, imports: Seq[Tree]): Seq[(String, Int)] = {
-    val toLineRange = imports map convertImport(modifiedContent)
+  private def importsToLineRanges(
+      modifiedContent: String,
+      imports: Seq[Tree]
+  ): Seq[(String, Int)] = {
+    val toLineRange = imports map convertImport
     val groupedByLineNumber = toLineRange.groupBy { case (_, lineNumber) => lineNumber }
-    val mergedImports = groupedByLineNumber.map { case (l, seq) => (l, extractLine(modifiedContent, seq)) }
+    val mergedImports = groupedByLineNumber.map {
+      case (l, seq) => (l, extractLine(modifiedContent, seq))
+    }
     mergedImports.toSeq.sortBy(_._1).map { case (k, v) => (v, k) }
   }
 
   /**
-   *
-   * @param modifiedContent - modifiedContent
    * @param t - tree
-   * @return ((start,end),lineNumber)
+   * @return ((start, end), lineNumber)
    */
-  private def convertImport(modifiedContent: String)(t: Tree): ((Int, Int), Int) = {
+  private def convertImport(t: Tree): ((Int, Int), Int) = {
     val lineNumber = t.pos.line - 1
     ((t.pos.start, t.pos.end), lineNumber)
   }
@@ -187,7 +337,10 @@ private[sbt] case class SbtParser(file: File, lines: Seq[String]) extends Parsed
    * @param importsInOneLine - imports in line
    * @return - text
    */
-  private def extractLine(modifiedContent: String, importsInOneLine: Seq[((Int, Int), Int)]): String = {
+  private def extractLine(
+      modifiedContent: String,
+      importsInOneLine: Seq[((Int, Int), Int)]
+  ): String = {
     val (begin, end) = importsInOneLine.foldLeft((Int.MaxValue, Int.MinValue)) {
       case ((min, max), ((start, end), _)) =>
         (min.min(start), max.max(end))
@@ -203,6 +356,7 @@ private[sbt] case class SbtParser(file: File, lines: Seq[String]) extends Parsed
  * @see https://github.com/scala/scala/pull/3991
  */
 private[sbt] object MissingBracketHandler {
+
   /**
    *
    * @param content - parsed file
@@ -212,19 +366,35 @@ private[sbt] object MissingBracketHandler {
    * @param originalException - original exception
    * @return missing text
    */
-  private[sbt] def findMissingText(content: String, positionEnd: Int, positionLine: Int, fileName: String, originalException: Throwable): String = {
+  private[sbt] def findMissingText(
+      content: String,
+      positionEnd: Int,
+      positionLine: Int,
+      fileName: String,
+      originalException: Throwable,
+      reporterId: Option[String] = Some(Random.nextInt.toString)
+  ): String = {
     findClosingBracketIndex(content, positionEnd) match {
       case Some(index) =>
         val text = content.substring(positionEnd, index + 1)
         val textWithoutBracket = text.substring(0, text.length - 1)
-        scala.util.Try(SbtParser(FAKE_FILE, textWithoutBracket.lines.toSeq)) match {
-          case scala.util.Success(_) =>
+        scala.util.Try(SbtParser.parse(textWithoutBracket, fileName, reporterId)) match {
+          case Success(_) =>
             text
-          case scala.util.Failure(th) =>
-            findMissingText(content, index + 1, positionLine, fileName, originalException)
+          case Failure(_) =>
+            findMissingText(
+              content,
+              index + 1,
+              positionLine,
+              fileName,
+              originalException,
+              reporterId
+            )
         }
       case _ =>
-        throw new MessageOnlyException(s"""[$fileName]:$positionLine: ${originalException.getMessage}""".stripMargin)
+        throw new MessageOnlyException(
+          s"""[$fileName]:$positionLine: ${originalException.getMessage}""".stripMargin
+        )
     }
   }
 
diff --git a/main/src/main/scala/sbt/internal/parser/SbtRefactorings.scala b/main/src/main/scala/sbt/internal/parser/SbtRefactorings.scala
index e90fa1818..647e5d012 100644
--- a/main/src/main/scala/sbt/internal/parser/SbtRefactorings.scala
+++ b/main/src/main/scala/sbt/internal/parser/SbtRefactorings.scala
@@ -1,9 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
-import scala.reflect.runtime.universe._
-
 private[sbt] object SbtRefactorings {
 
   import sbt.internal.parser.SbtParser.{ END_OF_LINE, FAKE_FILE }
@@ -21,17 +26,23 @@ private[sbt] object SbtRefactorings {
    *                 the first will be replaced and the other will be removed.
    * @return a SbtConfigFile with new lines which represent the contents of the refactored .sbt file.
    */
-  def applySessionSettings(configFile: SbtConfigFile, commands: Seq[SessionSetting]): SbtConfigFile = {
+  def applySessionSettings(
+      configFile: SbtConfigFile,
+      commands: Seq[SessionSetting]
+  ): SbtConfigFile = {
     val (file, lines) = configFile
     val split = SbtParser(FAKE_FILE, lines)
     val recordedCommands = recordCommands(commands, split)
     val sortedRecordedCommands = recordedCommands.sortBy(_._1)(reverseOrderingInt)
 
     val newContent = replaceFromBottomToTop(lines.mkString(END_OF_LINE), sortedRecordedCommands)
-    (file, newContent.lines.toList)
+    (file, newContent.linesIterator.toList)
   }
 
-  private def replaceFromBottomToTop(modifiedContent: String, sortedRecordedCommands: Seq[(Int, String, String)]) = {
+  private def replaceFromBottomToTop(
+      modifiedContent: String,
+      sortedRecordedCommands: Seq[(Int, String, String)]
+  ) = {
     sortedRecordedCommands.foldLeft(modifiedContent) {
       case (acc, (from, old, replacement)) =>
         val before = acc.substring(0, from)
@@ -50,10 +61,7 @@ private[sbt] object SbtRefactorings {
     commands.flatMap {
       case (_, command) =>
         val map = toTreeStringMap(command)
-        map.flatMap {
-          case (name, statement) =>
-            treesToReplacements(split, name, command)
-        }
+        map.flatMap { case (name, _) => treesToReplacements(split, name, command) }
     }
 
   private def treesToReplacements(split: SbtParser, name: String, command: Seq[String]) =
@@ -80,7 +88,8 @@ private[sbt] object SbtRefactorings {
     seq.toMap
   }
 
-  private def extractSettingName(tree: Tree): String =
+  import scala.tools.nsc.Global
+  private def extractSettingName(tree: Global#Tree): String =
     tree.children match {
       case h :: _ =>
         extractSettingName(h)
diff --git a/main/src/main/scala/sbt/internal/server/BspCompileTask.scala b/main/src/main/scala/sbt/internal/server/BspCompileTask.scala
new file mode 100644
index 000000000..e8a7ae7a0
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/BspCompileTask.scala
@@ -0,0 +1,117 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.server
+
+import sbt._
+import sbt.internal.bsp._
+import sbt.internal.io.Retry
+import sbt.librarymanagement.Configuration
+import sjsonnew.support.scalajson.unsafe.Converter
+import xsbti.compile.CompileResult
+import xsbti.{ CompileFailed, Problem, Severity }
+
+import scala.util.control.NonFatal
+
+object BspCompileTask {
+  import sbt.internal.bsp.codec.JsonProtocol._
+
+  private lazy val exchange = StandardMain.exchange
+
+  def compute(targetId: BuildTargetIdentifier, project: ProjectRef, config: Configuration)(
+      compile: => CompileResult
+  ): CompileResult = {
+    val task = BspCompileTask(targetId, project, config)
+    try {
+      notifyStart(task)
+      val result = Retry(compile)
+      notifySuccess(task, result)
+      result
+    } catch {
+      case NonFatal(cause) =>
+        val compileFailed = cause match {
+          case failed: CompileFailed => Some(failed)
+          case _                     => None
+        }
+        notifyFailure(task, compileFailed)
+        throw cause
+    }
+  }
+
+  private def apply(
+      targetId: BuildTargetIdentifier,
+      project: ProjectRef,
+      config: Configuration
+  ): BspCompileTask = {
+    val taskId = TaskId(BuildServerTasks.uniqueId, Vector())
+    val targetName = BuildTargetName.fromScope(project.project, config.name)
+    BspCompileTask(targetId, targetName, taskId, System.currentTimeMillis())
+  }
+
+  private def notifyStart(task: BspCompileTask): Unit = {
+    val message = s"Compiling ${task.targetName}"
+    val data = Converter.toJsonUnsafe(CompileTask(task.targetId))
+    val params = TaskStartParams(task.id, task.startTimeMillis, message, "compile-task", data)
+    exchange.notifyEvent("build/taskStart", params)
+  }
+
+  private def notifySuccess(task: BspCompileTask, result: CompileResult): Unit = {
+    import collection.JavaConverters._
+    val endTimeMillis = System.currentTimeMillis()
+    val elapsedTimeMillis = endTimeMillis - task.startTimeMillis
+    val problems = result match {
+      case compileResult: CompileResult =>
+        val sourceInfos = compileResult.analysis().readSourceInfos().getAllSourceInfos.asScala
+        sourceInfos.values.flatMap(_.getReportedProblems).toSeq
+      case _ => Seq()
+    }
+    val report = compileReport(problems, task.targetId, elapsedTimeMillis)
+    val params = TaskFinishParams(
+      task.id,
+      endTimeMillis,
+      s"Compiled ${task.targetName}",
+      StatusCode.Success,
+      "compile-report",
+      Converter.toJsonUnsafe(report)
+    )
+    exchange.notifyEvent("build/taskFinish", params)
+  }
+
+  private def notifyFailure(task: BspCompileTask, cause: Option[CompileFailed]): Unit = {
+    val endTimeMillis = System.currentTimeMillis()
+    val elapsedTimeMillis = endTimeMillis - task.startTimeMillis
+    val problems = cause.map(_.problems().toSeq).getOrElse(Seq.empty[Problem])
+    val report = compileReport(problems, task.targetId, elapsedTimeMillis)
+    val params = TaskFinishParams(
+      task.id,
+      endTimeMillis,
+      s"Compiled ${task.targetName}",
+      StatusCode.Error,
+      "compile-report",
+      Converter.toJsonUnsafe(report)
+    )
+    exchange.notifyEvent("build/taskFinish", params)
+  }
+
+  private def compileReport(
+      problems: Seq[Problem],
+      targetId: BuildTargetIdentifier,
+      elapsedTimeMillis: Long
+  ): CompileReport = {
+    val countBySeverity = problems.groupBy(_.severity()).mapValues(_.size)
+    val warnings = countBySeverity.getOrElse(Severity.Warn, 0)
+    val errors = countBySeverity.getOrElse(Severity.Error, 0)
+    CompileReport(targetId, None, errors, warnings, Some(elapsedTimeMillis.toInt))
+  }
+}
+
+case class BspCompileTask private (
+    targetId: BuildTargetIdentifier,
+    targetName: String,
+    id: TaskId,
+    startTimeMillis: Long
+)
diff --git a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala
new file mode 100644
index 000000000..52aef4e4f
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala
@@ -0,0 +1,702 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import java.net.URI
+
+import sbt.BasicCommandStrings.Shutdown
+import sbt.BuildSyntax._
+import sbt.Def._
+import sbt.Keys._
+import sbt.Project._
+import sbt.ScopeFilter.Make._
+import sbt.SlashSyntax0._
+import sbt.StandardMain.exchange
+import sbt.internal.bsp._
+import sbt.internal.langserver.ErrorCodes
+import sbt.internal.protocol.JsonRpcRequestMessage
+import sbt.internal.util.Attributed
+import sbt.internal.util.complete.{ Parser, Parsers }
+import sbt.librarymanagement.Configuration
+import sbt.std.TaskExtra
+import sbt.util.Logger
+import sjsonnew.shaded.scalajson.ast.unsafe.{ JNull, JValue }
+import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Converter, Parser => JsonParser }
+
+// import scala.annotation.nowarn
+import scala.util.control.NonFatal
+import scala.util.{ Failure, Success, Try }
+import scala.annotation.nowarn
+
+object BuildServerProtocol {
+  import sbt.internal.bsp.codec.JsonProtocol._
+
+  private val capabilities = BuildServerCapabilities(
+    CompileProvider(BuildServerConnection.languages),
+    TestProvider(BuildServerConnection.languages),
+    RunProvider(BuildServerConnection.languages),
+    dependencySourcesProvider = true,
+    canReload = true
+  )
+
+  private val bspReload = "bspReload"
+  private val bspReloadFailed = "bspReloadFailed"
+  private val bspReloadSucceed = "bspReloadSucceed"
+
+  lazy val commands: Seq[Command] = Seq(
+    Command.single(bspReload) { (state, reqId) =>
+      import sbt.BasicCommandStrings._
+      import sbt.internal.CommandStrings._
+      val result = List(
+        StashOnFailure,
+        s"$OnFailure $bspReloadFailed $reqId",
+        LoadProjectImpl,
+        s"$bspReloadSucceed $reqId",
+        PopOnFailure,
+        FailureWall
+      ) ::: state
+      result
+    },
+    Command.single(bspReloadFailed) { (state, reqId) =>
+      exchange.respondError(
+        ErrorCodes.InternalError,
+        "reload failed",
+        Some(reqId),
+        state.source
+      )
+      state
+    },
+    Command.single(bspReloadSucceed) { (state, reqId) =>
+      exchange.respondEvent(JNull, Some(reqId), state.source)
+      state
+    }
+  )
+
+  lazy val globalSettings: Seq[Def.Setting[_]] = Seq(
+    bspConfig := {
+      if (bspEnabled.value) {
+        BuildServerConnection.writeConnectionFile(
+          sbtVersion.value,
+          (ThisBuild / baseDirectory).value
+        )
+      } else {
+        val logger = streams.value.log
+        logger.warn("BSP is disabled for this build")
+        logger.info("add 'Global / bspEnabled := true' to enable BSP")
+      }
+    },
+    bspEnabled := true,
+    bspWorkspace := bspWorkspaceSetting.value,
+    bspWorkspaceBuildTargets := Def.taskDyn {
+      val workspace = Keys.bspWorkspace.value
+      val state = Keys.state.value
+      val allTargets = ScopeFilter.in(workspace.values.toSeq)
+      Def.task {
+        val buildTargets = Keys.bspBuildTarget.all(allTargets).value.toVector
+        state.respondEvent(WorkspaceBuildTargetsResult(buildTargets))
+        buildTargets
+      }
+    }.value,
+    // https://github.com/build-server-protocol/build-server-protocol/blob/master/docs/specification.md#build-target-sources-request
+    bspBuildTargetSources := Def.inputTaskDyn {
+      val s = state.value
+      val workspace = bspWorkspace.value
+      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
+      val filter = ScopeFilter.in(targets.map(workspace))
+      // run the worker task concurrently
+      Def.task {
+        val items = bspBuildTargetSourcesItem.all(filter).value
+        val result = SourcesResult(items.toVector)
+        s.respondEvent(result)
+      }
+    }.evaluated,
+    bspBuildTargetSources / aggregate := false,
+    bspBuildTargetDependencySources := Def.inputTaskDyn {
+      val s = state.value
+      val workspace = bspWorkspace.value
+      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
+      val filter = ScopeFilter.in(targets.map(workspace))
+      // run the worker task concurrently
+      Def.task {
+        import sbt.internal.bsp.codec.JsonProtocol._
+        val items = bspBuildTargetDependencySourcesItem.all(filter).value
+        val result = DependencySourcesResult(items.toVector)
+        s.respondEvent(result)
+      }
+    }.evaluated,
+    bspBuildTargetDependencySources / aggregate := false,
+    bspBuildTargetCompile := Def.inputTaskDyn {
+      val s: State = state.value
+      val workspace = bspWorkspace.value
+      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
+      val filter = ScopeFilter.in(targets.map(workspace))
+      Def.task {
+        val statusCode = Keys.bspBuildTargetCompileItem.all(filter).value.max
+        s.respondEvent(BspCompileResult(None, statusCode))
+      }
+    }.evaluated,
+    bspBuildTargetCompile / aggregate := false,
+    bspBuildTargetTest := bspTestTask.evaluated,
+    bspBuildTargetTest / aggregate := false,
+    bspBuildTargetScalacOptions := Def.inputTaskDyn {
+      val s = state.value
+      val workspace = bspWorkspace.value
+      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
+      val filter = ScopeFilter.in(targets.map(workspace))
+      Def.task {
+        val items = bspBuildTargetScalacOptionsItem.all(filter).value
+        val result = ScalacOptionsResult(items.toVector)
+        s.respondEvent(result)
+      }
+    }.evaluated,
+    bspBuildTargetScalacOptions / aggregate := false,
+    bspScalaTestClasses := Def.inputTaskDyn {
+      val s = state.value
+      val workspace = bspWorkspace.value
+      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
+      val filter = ScopeFilter.in(targets.map(workspace))
+      Def.task {
+        val items = bspScalaTestClassesItem.all(filter).value
+        val result = ScalaTestClassesResult(items.toVector, None)
+        s.respondEvent(result)
+      }
+    }.evaluated,
+    bspScalaMainClasses := Def.inputTaskDyn {
+      val s = state.value
+      val workspace = bspWorkspace.value
+      val targets = spaceDelimited().parsed.map(uri => BuildTargetIdentifier(URI.create(uri)))
+      val filter = ScopeFilter.in(targets.map(workspace))
+      Def.task {
+        val items = bspScalaMainClassesItem.all(filter).value
+        val result = ScalaMainClassesResult(items.toVector, None)
+        s.respondEvent(result)
+      }
+    }.evaluated,
+    bspScalaMainClasses / aggregate := false
+  )
+
+  // This will be scoped to Compile, Test, IntegrationTest etc
+  lazy val configSettings: Seq[Def.Setting[_]] = Seq(
+    bspTargetIdentifier := {
+      val ref = thisProjectRef.value
+      val c = configuration.value
+      toId(ref, c)
+    },
+    bspBuildTarget := buildTargetTask.value,
+    bspBuildTargetSourcesItem := {
+      val id = bspTargetIdentifier.value
+      val dirs = unmanagedSourceDirectories.value
+      val managed = managedSources.value
+      val items = (dirs.toVector map { dir =>
+        SourceItem(dir.toURI, SourceItemKind.Directory, generated = false)
+      }) ++
+        (managed.toVector map { x =>
+          SourceItem(x.toURI, SourceItemKind.File, generated = true)
+        })
+      SourcesItem(id, items)
+    },
+    bspBuildTargetDependencySourcesItem := dependencySourcesItemTask.value,
+    bspBuildTargetCompileItem := bspCompileTask.value,
+    bspBuildTargetRun := bspRunTask.evaluated,
+    bspBuildTargetScalacOptionsItem := scalacOptionsTask.value,
+    bspInternalDependencyConfigurations := internalDependencyConfigurationsSetting.value,
+    bspScalaTestClassesItem := scalaTestClassesTask.value,
+    bspScalaMainClassesItem := scalaMainClassesTask.value,
+    Keys.compile / bspReporter := {
+      val targetId = bspTargetIdentifier.value
+      val converter = fileConverter.value
+      val underlying = (Keys.compile / compilerReporter).value
+      val logger = streams.value.log
+      val meta = isMetaBuild.value
+      if (bspEnabled.value) {
+        new BuildServerReporterImpl(targetId, converter, meta, logger, underlying)
+      } else {
+        new BuildServerForwarder(meta, logger, underlying)
+      }
+    }
+  )
+
+  def handler(
+      loadedBuild: LoadedBuild,
+      workspace: Map[BuildTargetIdentifier, Scope],
+      sbtVersion: String,
+      semanticdbEnabled: Boolean,
+      semanticdbVersion: String
+  ): ServerHandler = {
+    val configurationMap: Map[ConfigKey, Configuration] =
+      loadedBuild.allProjectRefs
+        .flatMap { case (_, p) => p.configurations }
+        .distinct
+        .map(c => ConfigKey(c.name) -> c)
+        .toMap
+    ServerHandler { callback =>
+      ServerIntent(
+        onRequest = {
+          case r: JsonRpcRequestMessage if r.method == "build/initialize" =>
+            val params = Converter.fromJson[InitializeBuildParams](json(r)).get
+            checkMetalsCompatibility(semanticdbEnabled, semanticdbVersion, params, callback.log)
+
+            val response = InitializeBuildResult(
+              "sbt",
+              sbtVersion,
+              BuildServerConnection.bspVersion,
+              capabilities,
+              None
+            )
+            callback.jsonRpcRespond(response, Some(r.id)); ()
+
+          case r: JsonRpcRequestMessage if r.method == "workspace/buildTargets" =>
+            val _ = callback.appendExec(Keys.bspWorkspaceBuildTargets.key.toString, Some(r.id))
+
+          case r: JsonRpcRequestMessage if r.method == "workspace/reload" =>
+            val _ = callback.appendExec(s"$bspReload ${r.id}", Some(r.id))
+
+          case r: JsonRpcRequestMessage if r.method == "build/shutdown" =>
+            callback.jsonRpcRespond(JNull, Some(r.id))
+
+          case r: JsonRpcRequestMessage if r.method == "build/exit" =>
+            val _ = callback.appendExec(Shutdown, Some(r.id))
+
+          case r: JsonRpcRequestMessage if r.method == "buildTarget/sources" =>
+            val param = Converter.fromJson[SourcesParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspBuildTargetSources.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+
+          case r if r.method == "buildTarget/dependencySources" =>
+            val param = Converter.fromJson[DependencySourcesParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspBuildTargetDependencySources.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+
+          case r if r.method == "buildTarget/compile" =>
+            val param = Converter.fromJson[CompileParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspBuildTargetCompile.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+
+          case r: JsonRpcRequestMessage if r.method == "buildTarget/test" =>
+            val task = bspBuildTargetTest.key
+            val paramStr = CompactPrinter(json(r))
+            val _ = callback.appendExec(s"$task $paramStr", Some(r.id))
+
+          case r if r.method == "buildTarget/run" =>
+            val paramJson = json(r)
+            val param = Converter.fromJson[RunParams](json(r)).get
+            val scope = workspace.getOrElse(
+              param.target,
+              throw LangServerError(
+                ErrorCodes.InvalidParams,
+                s"'${param.target}' is not a valid build target identifier"
+              )
+            )
+            val project = scope.project.toOption.get.asInstanceOf[ProjectRef].project
+            val config = configurationMap(scope.config.toOption.get).id
+            val task = bspBuildTargetRun.key
+            val paramStr = CompactPrinter(paramJson)
+            val _ = callback.appendExec(
+              s"$project / $config / $task $paramStr",
+              Some(r.id)
+            )
+
+          case r: JsonRpcRequestMessage if r.method == "buildTarget/scalacOptions" =>
+            val param = Converter.fromJson[ScalacOptionsParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspBuildTargetScalacOptions.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+
+          case r: JsonRpcRequestMessage if r.method == "buildTarget/scalaTestClasses" =>
+            val param = Converter.fromJson[ScalaTestClassesParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspScalaTestClasses.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+
+          case r: JsonRpcRequestMessage if r.method == "buildTarget/scalaMainClasses" =>
+            val param = Converter.fromJson[ScalaMainClassesParams](json(r)).get
+            val targets = param.targets.map(_.uri).mkString(" ")
+            val command = Keys.bspScalaMainClasses.key
+            val _ = callback.appendExec(s"$command $targets", Some(r.id))
+        },
+        onResponse = PartialFunction.empty,
+        onNotification = PartialFunction.empty,
+      )
+    }
+  }
+
+  private def checkMetalsCompatibility(
+      semanticdbEnabled: Boolean,
+      semanticdbVersion: String,
+      params: InitializeBuildParams,
+      log: Logger
+  ): Unit = {
+    for {
+      data <- params.data
+      // try parse metadata as MetalsMetadata
+      metalsMetadata <- Converter.fromJson[MetalsMetadata](data).toOption
+    } {
+      if (metalsMetadata.semanticdbVersion.nonEmpty && !semanticdbEnabled) {
+        log.warn(s"${params.displayName} requires the semanticdb compiler plugin")
+        log.warn(
+          s"consider setting 'Global / semanticdbEnabled := true' in your global sbt settings ($$HOME/.sbt/1.0)"
+        )
+      }
+
+      for {
+        requiredVersion <- SemanticVersion.tryParse(metalsMetadata.semanticdbVersion)
+        currentVersion <- SemanticVersion.tryParse(semanticdbVersion)
+        if requiredVersion > currentVersion
+      } {
+        log.warn(
+          s"${params.displayName} requires semanticdb version ${metalsMetadata.semanticdbVersion}, current version is $semanticdbVersion"
+        )
+        log.warn(
+          s"""consider setting 'Global / semanticdbVersion := "${metalsMetadata.semanticdbVersion}"' in your global sbt settings ($$HOME/.sbt/1.0)"""
+        )
+      }
+    }
+  }
+
+  private def json(r: JsonRpcRequestMessage): JValue =
+    r.params.getOrElse(
+      throw LangServerError(
+        ErrorCodes.InvalidParams,
+        s"param is expected on '${r.method}' method."
+      )
+    )
+
+  @nowarn
+  private def bspWorkspaceSetting: Def.Initialize[Map[BuildTargetIdentifier, Scope]] =
+    Def.settingDyn {
+      val loadedBuild = Keys.loadedBuild.value
+
+      // list all defined scopes for setting bspTargetIdentifier for all projects
+      val scopes: Seq[Scope] = for {
+        (ref, project) <- loadedBuild.allProjectRefs
+        setting <- project.settings
+        if setting.key.key.label == Keys.bspTargetIdentifier.key.label
+      } yield Scope.replaceThis(Scope.Global.in(ref))(setting.key.scope)
+
+      Def.setting {
+        val targetIds = scopes
+          .map(_ / Keys.bspTargetIdentifier)
+          .join
+          .value
+        val bspEnabled = scopes
+          .map(_ / Keys.bspEnabled)
+          .join
+          .value
+        val result = for {
+          (targetId, scope, bspEnabled) <- (targetIds, scopes, bspEnabled).zipped
+          if bspEnabled
+        } yield targetId -> scope
+        result.toMap
+      }
+    }
+
+  private def buildTargetTask: Def.Initialize[Task[BuildTarget]] = Def.taskDyn {
+    val buildTargetIdentifier = Keys.bspTargetIdentifier.value
+    val thisProject = Keys.thisProject.value
+    val thisProjectRef = Keys.thisProjectRef.value
+    val thisConfig = Keys.configuration.value
+    val scalaJars = Keys.scalaInstance.value.allJars.map(_.toURI.toString)
+    val compileData = ScalaBuildTarget(
+      scalaOrganization = scalaOrganization.value,
+      scalaVersion = scalaVersion.value,
+      scalaBinaryVersion = scalaBinaryVersion.value,
+      platform = ScalaPlatform.JVM,
+      jars = scalaJars.toVector
+    )
+    val configuration = Keys.configuration.value
+    val displayName = BuildTargetName.fromScope(thisProject.id, configuration.name)
+    val baseDirectory = Keys.baseDirectory.value.toURI
+    val projectDependencies = for {
+      (dep, configs) <- Keys.bspInternalDependencyConfigurations.value
+      config <- configs
+      if dep != thisProjectRef || config.name != thisConfig.name
+    } yield (dep / config / Keys.bspTargetIdentifier)
+    val capabilities = BuildTargetCapabilities(canCompile = true, canTest = true, canRun = true)
+    val tags = BuildTargetTag.fromConfig(configuration.name)
+    Def.task {
+      BuildTarget(
+        buildTargetIdentifier,
+        Some(displayName),
+        Some(baseDirectory),
+        tags,
+        capabilities,
+        BuildServerConnection.languages,
+        projectDependencies.join.value.distinct.toVector,
+        dataKind = Some("scala"),
+        data = Some(Converter.toJsonUnsafe(compileData)),
+      )
+    }
+  }
+
+  private def scalacOptionsTask: Def.Initialize[Task[ScalacOptionsItem]] = Def.taskDyn {
+    val target = Keys.bspTargetIdentifier.value
+    val scalacOptions = Keys.scalacOptions.value
+    val classDirectory = Keys.classDirectory.value
+    val externalDependencyClasspath = Keys.externalDependencyClasspath.value
+
+    val internalDependencyClasspath = for {
+      (ref, configs) <- bspInternalDependencyConfigurations.value
+      config <- configs
+    } yield ref / config / Keys.classDirectory
+
+    Def.task {
+      val classpath = internalDependencyClasspath.join.value.distinct ++
+        externalDependencyClasspath.map(_.data)
+      ScalacOptionsItem(
+        target,
+        scalacOptions.toVector,
+        classpath.map(_.toURI).toVector,
+        classDirectory.toURI
+      )
+    }
+  }
+
+  private def dependencySourcesItemTask: Def.Initialize[Task[DependencySourcesItem]] = Def.task {
+    val targetId = Keys.bspTargetIdentifier.value
+    val updateReport = Keys.updateClassifiers.value
+    val sources = for {
+      configuration <- updateReport.configurations.view
+      module <- configuration.modules.view
+      (artifact, file) <- module.artifacts
+      classifier <- artifact.classifier if classifier == "sources"
+    } yield file.toURI
+    DependencySourcesItem(targetId, sources.toVector.distinct)
+  }
+
+  private def bspCompileTask: Def.Initialize[Task[Int]] = Def.task {
+    Keys.compile.result.value match {
+      case Value(_) => StatusCode.Success
+      case Inc(_)   =>
+        // Cancellation is not yet implemented
+        StatusCode.Error
+    }
+  }
+
+  private val jsonParser: Parser[Try[JValue]] = (Parsers.any *)
+    .map(_.mkString)
+    .map(JsonParser.parseFromString)
+
+  private def bspRunTask: Def.Initialize[InputTask[Unit]] = Def.inputTaskDyn {
+    val runParams = jsonParser
+      .map(_.flatMap(json => Converter.fromJson[RunParams](json)))
+      .parsed
+      .get
+    val defaultClass = Keys.mainClass.value
+    val defaultJvmOptions = Keys.javaOptions.value
+
+    val mainClass = runParams.dataKind match {
+      case Some("scala-main-class") =>
+        val data = runParams.data.getOrElse(JNull)
+        Converter.fromJson[ScalaMainClass](data) match {
+          case Failure(e) =>
+            throw LangServerError(
+              ErrorCodes.ParseError,
+              e.getMessage
+            )
+          case Success(value) =>
+            value.withEnvironmentVariables(
+              envVars.value.map { case (k, v) => s"$k=$v" }.toVector ++ value.environmentVariables
+            )
+        }
+
+      case Some(dataKind) =>
+        throw LangServerError(
+          ErrorCodes.InvalidParams,
+          s"Unexpected data of kind '$dataKind', 'scala-main-class' is expected"
+        )
+
+      case None =>
+        ScalaMainClass(
+          defaultClass.getOrElse(
+            throw LangServerError(
+              ErrorCodes.InvalidParams,
+              "No default main class is defined"
+            )
+          ),
+          runParams.arguments,
+          defaultJvmOptions.toVector,
+          envVars.value.map { case (k, v) => s"$k=$v" }.toVector
+        )
+    }
+
+    runMainClassTask(mainClass, runParams.originId)
+  }
+
+  private def bspTestTask: Def.Initialize[InputTask[Unit]] = Def.inputTaskDyn {
+    val testParams = jsonParser
+      .map(_.flatMap(json => Converter.fromJson[TestParams](json)))
+      .parsed
+      .get
+    val workspace = bspWorkspace.value
+
+    val resultTask: Def.Initialize[Task[Result[Seq[Unit]]]] = testParams.dataKind match {
+      case Some("scala-test") =>
+        val data = testParams.data.getOrElse(JNull)
+        val items = Converter.fromJson[ScalaTestParams](data) match {
+          case Failure(e) =>
+            throw LangServerError(ErrorCodes.ParseError, e.getMessage)
+          case Success(value) => value.testClasses
+        }
+        val testTasks: Seq[Def.Initialize[Task[Unit]]] = items.map { item =>
+          val scope = workspace(item.target)
+          item.classes.toList match {
+            case Nil => Def.task(())
+            case classes =>
+              (scope / testOnly).toTask(" " + classes.mkString(" "))
+          }
+        }
+        testTasks.joinWith(ts => TaskExtra.joinTasks(ts).join).result
+
+      case Some(dataKind) =>
+        throw LangServerError(
+          ErrorCodes.InvalidParams,
+          s"Unexpected data of kind '$dataKind', 'scala-main-class' is expected"
+        )
+
+      case None =>
+        // run allTests in testParams.targets
+        val filter = ScopeFilter.in(testParams.targets.map(workspace))
+        test.all(filter).result
+    }
+
+    Def.task {
+      val state = Keys.state.value
+      val statusCode = resultTask.value match {
+        case Value(_) => StatusCode.Success
+        case Inc(_)   => StatusCode.Error
+      }
+      val _ = state.respondEvent(TestResult(testParams.originId, statusCode))
+    }
+  }
+
+  private def runMainClassTask(mainClass: ScalaMainClass, originId: Option[String]) = Def.task {
+    val state = Keys.state.value
+    val logger = Keys.streams.value.log
+    val classpath = Attributed.data(fullClasspath.value)
+    val forkOpts = ForkOptions(
+      javaHome = javaHome.value,
+      outputStrategy = outputStrategy.value,
+      // bootJars is empty by default because only jars on the user's classpath should be on the boot classpath
+      bootJars = Vector(),
+      workingDirectory = Some(baseDirectory.value),
+      runJVMOptions = mainClass.jvmOptions,
+      connectInput = connectInput.value,
+      envVars = mainClass.environmentVariables
+        .flatMap(_.split("=", 2).toList match {
+          case key :: value :: Nil => Some(key -> value)
+          case _                   => None
+        })
+        .toMap
+    )
+    val runner = new ForkRun(forkOpts)
+    val statusCode = runner
+      .run(mainClass.`class`, classpath, mainClass.arguments, logger)
+      .fold(
+        _ => StatusCode.Error,
+        _ => StatusCode.Success
+      )
+    state.respondEvent(RunResult(originId, statusCode))
+  }
+
+  @nowarn
+  private def internalDependencyConfigurationsSetting = Def.settingDyn {
+    val allScopes = bspWorkspace.value.map { case (_, scope) => scope }.toSet
+    val directDependencies = Keys.internalDependencyConfigurations.value
+      .map {
+        case (project, rawConfigs) =>
+          val configs = rawConfigs
+            .flatMap(_.split(","))
+            .map(name => ConfigKey(name.trim))
+            .filter { config =>
+              val scope = Scope.Global.in(project, config)
+              allScopes.contains(scope)
+            }
+          (project, configs)
+      }
+      .filter {
+        case (_, configs) => configs.nonEmpty
+      }
+    val ref = Keys.thisProjectRef.value
+    val thisConfig = Keys.configuration.value
+    val transitiveDependencies = for {
+      (dep, configs) <- directDependencies
+      config <- configs if dep != ref || config.name != thisConfig.name
+    } yield dep / config / Keys.bspInternalDependencyConfigurations
+    Def.setting {
+      val allDependencies = directDependencies ++
+        transitiveDependencies.join.value.flatten
+      allDependencies
+        .groupBy(_._1)
+        .mapValues { deps =>
+          deps.flatMap { case (_, configs) => configs }.toSet
+        }
+        .toSeq
+    }
+  }
+
+  private def scalaTestClassesTask: Initialize[Task[ScalaTestClassesItem]] = Def.task {
+    val testClasses = Keys.definedTests.?.value
+      .getOrElse(Seq.empty)
+      .map(_.name)
+      .toVector
+    ScalaTestClassesItem(
+      bspTargetIdentifier.value,
+      testClasses
+    )
+  }
+
+  private def scalaMainClassesTask: Initialize[Task[ScalaMainClassesItem]] = Def.task {
+    val jvmOptions = Keys.javaOptions.value.toVector
+    val mainClasses = Keys.discoveredMainClasses.value.map(
+      ScalaMainClass(
+        _,
+        Vector(),
+        jvmOptions,
+        envVars.value.map { case (k, v) => s"$k=$v" }.toVector
+      )
+    )
+    ScalaMainClassesItem(
+      bspTargetIdentifier.value,
+      mainClasses.toVector
+    )
+  }
+
+  private def toId(ref: ProjectReference, config: Configuration): BuildTargetIdentifier =
+    ref match {
+      case ProjectRef(build, project) =>
+        val sanitized = build.toString.indexOf("#") match {
+          case i if i > 0 => build.toString.take(i)
+          case _          => build.toString
+        }
+        BuildTargetIdentifier(new URI(s"$sanitized#$project/${config.id}"))
+      case _ => sys.error(s"unexpected $ref")
+    }
+
+  private case class SemanticVersion(major: Int, minor: Int) extends Ordered[SemanticVersion] {
+    override def compare(that: SemanticVersion): Int = {
+      if (that.major != major) major.compare(that.major)
+      else minor.compare(minor)
+    }
+  }
+
+  private object SemanticVersion {
+    def tryParse(versionStr: String): Option[SemanticVersion] = {
+      try {
+        val parts = versionStr.split('.')
+        Some(SemanticVersion(parts(0).toInt, parts(1).toInt))
+      } catch {
+        case NonFatal(_) => None
+      }
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala b/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala
new file mode 100644
index 000000000..41a35ee8e
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala
@@ -0,0 +1,179 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.server
+
+import java.nio.file.Path
+
+import sbt.StandardMain
+import sbt.internal.bsp._
+import sbt.internal.util.ManagedLogger
+import xsbti.compile.CompileAnalysis
+import xsbti.{
+  FileConverter,
+  Problem,
+  Reporter,
+  Severity,
+  VirtualFile,
+  VirtualFileRef,
+  Position => XPosition
+}
+
+import scala.collection.JavaConverters._
+import scala.collection.mutable
+
+sealed trait BuildServerReporter extends Reporter {
+  private final val sigFilesWritten = "[sig files written]"
+  private final val pureExpression = "a pure expression does nothing in statement position"
+
+  protected def isMetaBuild: Boolean
+
+  protected def logger: ManagedLogger
+
+  protected def underlying: Reporter
+
+  protected def publishDiagnostic(problem: Problem): Unit
+
+  def sendSuccessReport(analysis: CompileAnalysis): Unit
+
+  def sendFailureReport(sources: Array[VirtualFile]): Unit
+
+  override def reset(): Unit = underlying.reset()
+
+  override def hasErrors: Boolean = underlying.hasErrors
+
+  override def hasWarnings: Boolean = underlying.hasWarnings
+
+  override def printSummary(): Unit = underlying.printSummary()
+
+  override def problems(): Array[Problem] = underlying.problems()
+
+  override def log(problem: Problem): Unit = {
+    if (problem.message == sigFilesWritten) {
+      logger.debug(sigFilesWritten)
+    } else if (isMetaBuild && problem.message.startsWith(pureExpression)) {
+      // work around https://github.com/scala/bug/issues/12112 by ignoring it in the reporter
+      logger.debug(problem.message)
+    } else {
+      publishDiagnostic(problem)
+      underlying.log(problem)
+    }
+  }
+
+  override def comment(pos: XPosition, msg: String): Unit = underlying.comment(pos, msg)
+}
+
+final class BuildServerReporterImpl(
+    buildTarget: BuildTargetIdentifier,
+    converter: FileConverter,
+    protected override val isMetaBuild: Boolean,
+    protected override val logger: ManagedLogger,
+    protected override val underlying: Reporter
+) extends BuildServerReporter {
+  import sbt.internal.bsp.codec.JsonProtocol._
+  import sbt.internal.inc.JavaInterfaceUtil._
+
+  private lazy val exchange = StandardMain.exchange
+  private val problemsByFile = mutable.Map[Path, Vector[Diagnostic]]()
+
+  override def sendSuccessReport(analysis: CompileAnalysis): Unit = {
+    for {
+      (source, infos) <- analysis.readSourceInfos.getAllSourceInfos.asScala
+    } {
+      val filePath = converter.toPath(source)
+      val diagnostics = infos.getReportedProblems.toSeq.flatMap(toDiagnostic)
+      val params = PublishDiagnosticsParams(
+        textDocument = TextDocumentIdentifier(filePath.toUri),
+        buildTarget,
+        originId = None,
+        diagnostics.toVector,
+        reset = true
+      )
+      exchange.notifyEvent("build/publishDiagnostics", params)
+    }
+  }
+
+  override def sendFailureReport(sources: Array[VirtualFile]): Unit = {
+    for (source <- sources) {
+      val filePath = converter.toPath(source)
+      val diagnostics = problemsByFile.getOrElse(filePath, Vector())
+      val params = PublishDiagnosticsParams(
+        textDocument = TextDocumentIdentifier(filePath.toUri),
+        buildTarget,
+        originId = None,
+        diagnostics,
+        reset = true
+      )
+      exchange.notifyEvent("build/publishDiagnostics", params)
+    }
+  }
+
+  protected override def publishDiagnostic(problem: Problem): Unit = {
+    for {
+      id <- problem.position.sourcePath.toOption
+      diagnostic <- toDiagnostic(problem)
+    } {
+      val filePath = converter.toPath(VirtualFileRef.of(id))
+      problemsByFile(filePath) = problemsByFile.getOrElse(filePath, Vector()) :+ diagnostic
+      val params = PublishDiagnosticsParams(
+        TextDocumentIdentifier(filePath.toUri),
+        buildTarget,
+        originId = None,
+        Vector(diagnostic),
+        reset = false
+      )
+      exchange.notifyEvent("build/publishDiagnostics", params)
+    }
+  }
+
+  private def toDiagnostic(problem: Problem): Option[Diagnostic] = {
+    val pos = problem.position
+    for {
+      line <- pos.line.toOption.map(_.toLong - 1L)
+      pointer <- pos.pointer.toOption.map(_.toLong)
+    } yield {
+      val range = (
+        pos.startLine.toOption,
+        pos.startColumn.toOption,
+        pos.endLine.toOption,
+        pos.endColumn.toOption
+      ) match {
+        case (Some(sl), Some(sc), Some(el), Some(ec)) =>
+          Range(Position(sl.toLong - 1, sc.toLong), Position(el.toLong - 1, ec.toLong))
+        case _ =>
+          Range(Position(line, pointer), Position(line, pointer + 1))
+      }
+
+      Diagnostic(
+        range,
+        Option(toDiagnosticSeverity(problem.severity)),
+        None,
+        Option("sbt"),
+        problem.message
+      )
+    }
+  }
+
+  private def toDiagnosticSeverity(severity: Severity): Long = severity match {
+    case Severity.Info  => DiagnosticSeverity.Information
+    case Severity.Warn  => DiagnosticSeverity.Warning
+    case Severity.Error => DiagnosticSeverity.Error
+  }
+}
+
+final class BuildServerForwarder(
+    protected override val isMetaBuild: Boolean,
+    protected override val logger: ManagedLogger,
+    protected override val underlying: Reporter
+) extends BuildServerReporter {
+
+  override def sendSuccessReport(analysis: CompileAnalysis): Unit = ()
+
+  override def sendFailureReport(sources: Array[VirtualFile]): Unit = ()
+
+  protected override def publishDiagnostic(problem: Problem): Unit = ()
+}
diff --git a/main/src/main/scala/sbt/internal/server/Definition.scala b/main/src/main/scala/sbt/internal/server/Definition.scala
new file mode 100644
index 000000000..0564c9811
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/Definition.scala
@@ -0,0 +1,337 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import java.net.URI
+import java.nio.file._
+
+import scala.annotation.{ nowarn, tailrec }
+import scala.collection.JavaConverters._
+import scala.concurrent.{ ExecutionContext, Future }
+import scala.reflect.NameTransformer
+import scala.tools.reflect.{ ToolBox, ToolBoxError }
+import scala.util.matching.Regex
+
+import sjsonnew.JsonFormat
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Converter }
+
+import sbt.internal.inc.{ Analysis, MixedAnalyzingCompiler }
+import sbt.internal.inc.JavaInterfaceUtil._
+import sbt.internal.protocol.JsonRpcResponseError
+import sbt.internal.protocol.codec.JsonRPCProtocol
+import sbt.internal.langserver
+import sbt.internal.langserver.{ ErrorCodes, Location, Position, Range, TextDocumentPositionParams }
+import sbt.util.Logger
+import sbt.Keys._
+import xsbti.{ FileConverter, VirtualFileRef }
+import com.github.benmanes.caffeine.cache.Cache
+import scala.concurrent.Promise
+import com.github.benmanes.caffeine.cache.Caffeine
+
+private[sbt] object Definition {
+  def send[A: JsonFormat](source: CommandSource, execId: String)(params: A): Unit = {
+    for {
+      channel <- StandardMain.exchange.channels.collectFirst {
+        case c: NetworkChannel if c.name == source.channelName => c
+      }
+    } {
+      channel.respond(params, Option(execId))
+    }
+  }
+
+  object textProcessor {
+    private val isIdentifier = {
+      lazy val tb =
+        scala.reflect.runtime.universe
+          .runtimeMirror(this.getClass.getClassLoader)
+          .mkToolBox()
+      import tb._
+      lazy val check = parse _ andThen compile _
+      (identifier: String) =>
+        try {
+          check(s"val $identifier = 0; val ${identifier}${identifier} = $identifier")
+          true
+        } catch {
+          case _: ToolBoxError => false
+        }
+    }
+
+    private def findInBackticks(line: String, point: Int): Option[String] = {
+      val (even, odd) = line.zipWithIndex
+        .collect { case (char, backtickIndex) if char == '`' => backtickIndex }
+        .zipWithIndex
+        .partition { case (_, index) => index % 2 == 0 }
+
+      even
+        .collect { case (backtickIndex, _) => backtickIndex }
+        .zip {
+          odd.collect { case (backtickIndex, _) => backtickIndex + 1 }
+        }
+        .collectFirst {
+          case (from, to) if from <= point && point < to => line.slice(from, to)
+        }
+    }
+
+    def identifier(line: String, point: Int): Option[String] = findInBackticks(line, point).orElse {
+      val whiteSpaceReg = "(\\s|\\.)+".r
+
+      val (zero, end) = fold(Seq.empty)(whiteSpaceReg.findAllIn(line))
+        .collect {
+          case (white, ind) => (ind, ind + white.length)
+        }
+        .fold((0, line.length)) {
+          case ((left, right), (from, to)) =>
+            val zero = if (to > left && to <= point) to else left
+            val end = if (from < right && from >= point) from else right
+            (zero, end)
+        }
+
+      val ranges = for {
+        from <- zero to point
+        to <- point to end
+      } yield (from -> to)
+
+      ranges
+        .sortBy { case (from, to) => -(to - from) }
+        .foldLeft(List.empty[String]) {
+          case (z, (from, to)) =>
+            val fragment = line.slice(from, to).trim
+            if (isIdentifier(fragment))
+              z match {
+                case Nil if fragment.nonEmpty              => fragment :: z
+                case h :: _ if h.length < fragment.length  => fragment :: Nil
+                case h :: _ if h.length == fragment.length => fragment :: z
+                case _                                     => z
+              }
+            else z
+        }
+        .headOption
+    }
+
+    private def asClassObjectIdentifier(sym: String) =
+      Seq(s".$sym", s".$sym$$", s"$$$sym", s"$$$sym$$")
+
+    def potentialClsOrTraitOrObj(sym: String): PartialFunction[String, String] = {
+      val encodedSym = NameTransformer.encode(sym.toSeq match {
+        case '`' +: body :+ '`' => body.mkString
+        case noBackticked       => noBackticked.mkString
+      })
+      val action: PartialFunction[String, String] = {
+        case potentialClassOrTraitOrObject
+            if asClassObjectIdentifier(encodedSym).exists(potentialClassOrTraitOrObject.endsWith) ||
+              encodedSym == potentialClassOrTraitOrObject ||
+              s"$encodedSym$$" == potentialClassOrTraitOrObject =>
+          potentialClassOrTraitOrObject
+      }
+      action
+    }
+
+    @tailrec
+    private def fold(z: Seq[(String, Int)])(it: Regex.MatchIterator): Seq[(String, Int)] = {
+      if (!it.hasNext) z
+      else fold(z :+ (it.next() -> it.start))(it)
+    }
+
+    def classTraitObjectInLine(sym: String)(line: String): Seq[(String, Int)] = {
+      val potentials = Seq(
+        s"object\\s+${Regex quote sym}".r,
+        s"trait\\s+${Regex quote sym} *\\[?".r,
+        s"class\\s+${Regex quote sym} *\\[?".r,
+      )
+      potentials
+        .flatMap { reg =>
+          fold(Seq.empty)(reg.findAllIn(line))
+        }
+        .collect {
+          case (name, pos) =>
+            (if (name.endsWith("[")) name.init.trim else name.trim) -> pos
+        }
+    }
+
+    def markPosition(file: Path, sym: String): Seq[(URI, Long, Long, Long)] = {
+      val findInLine = classTraitObjectInLine(sym)(_)
+      Files
+        .lines(file)
+        .iterator
+        .asScala
+        .zipWithIndex
+        .flatMap {
+          case (line, lineNumber) =>
+            findInLine(line)
+              .collect {
+                case (sym, from) =>
+                  (file.toUri, lineNumber.toLong, from.toLong, from.toLong + sym.length)
+              }
+        }
+        .toSeq
+        .distinct
+    }
+  }
+
+  private def getDefinition(jsonDefinition: JValue): Option[TextDocumentPositionParams] = {
+    import langserver.codec.JsonProtocol._
+    Converter.fromJson[TextDocumentPositionParams](jsonDefinition).toOption
+  }
+
+  private[this] val AnalysesKey = "lsp.definition.analyses.key"
+  private[server] type Analyses = Set[((String, Boolean), Option[Analysis])]
+
+  private def storeAnalysis(cacheFile: Path, useBinary: Boolean): Option[Analysis] =
+    MixedAnalyzingCompiler
+      .staticCachedStore(cacheFile, !useBinary)
+      .get
+      .toOption
+      .map { _.getAnalysis }
+      .collect { case a: Analysis => a }
+
+  private[sbt] def updateCache(
+      cache: Cache[String, Analyses]
+  )(cacheFile: String, useBinary: Boolean): Any = {
+    cache.get(AnalysesKey, k => Set(cacheFile -> useBinary -> None)) match {
+      case null => new AnyRef
+      case set =>
+        val newSet = set
+          .filterNot { case ((file, _), _) => file == cacheFile }
+          .+(cacheFile -> useBinary -> None)
+        cache.put(AnalysesKey, newSet)
+    }
+  }
+  private[sbt] object AnalysesAccess {
+    private[sbt] lazy val cache: Cache[String, Analyses] = Caffeine.newBuilder.build()
+    ShutdownHooks.add(() => {
+      cache.invalidateAll()
+      cache.cleanUp()
+    })
+    private[sbt] def getFrom(cache: Cache[String, Analyses]): Option[Analyses] = {
+      cache.getIfPresent(AnalysesKey) match {
+        case null => None
+        case a    => Some(a)
+      }
+    }
+  }
+
+  def collectAnalysesTask = Def.task {
+    val cacheFile: String = compileIncSetup.value.cacheFile.getAbsolutePath
+    val useBinary = enableBinaryCompileAnalysis.value
+    val s = state.value
+    s.log.debug(s"analysis location ${cacheFile -> useBinary}")
+    updateCache(AnalysesAccess.cache)(cacheFile, useBinary)
+  }
+
+  private[sbt] def getAnalyses: Future[Seq[Analysis]] = {
+    val result = Promise[Seq[Analysis]]
+
+    new Thread("sbt-get-analysis-thread") {
+      setDaemon(true)
+      start()
+      override def run(): Unit =
+        try {
+          AnalysesAccess.cache.getIfPresent(AnalysesKey) match {
+            case null => result.success(Nil)
+            case caches =>
+              val (working, uninitialized) = caches.partition {
+                case (_, Some(_)) => true
+                case (_, None)    => false
+              }
+              val addToCache = uninitialized.collect {
+                case (title @ (file, useBinary), _) if Files.exists(Paths.get(file)) =>
+                  (title, storeAnalysis(Paths.get(file), !useBinary))
+              }
+              val validCaches = working ++ addToCache
+              if (addToCache.nonEmpty) {
+                AnalysesAccess.cache.put(AnalysesKey, validCaches)
+              }
+              result.success(validCaches.toSeq.collect {
+                case (_, Some(analysis)) =>
+                  analysis
+              })
+          }
+        } catch { case scala.util.control.NonFatal(e) => result.failure(e) }
+    }
+    result.future
+  }
+
+  @nowarn
+  def lspDefinition(
+      jsonDefinition: JValue,
+      requestId: String,
+      commandSource: CommandSource,
+      converter: FileConverter,
+      log: Logger,
+  )(implicit ec: ExecutionContext): Future[Unit] = Future {
+    val LspDefinitionLogHead = "lsp-definition"
+    val jsonDefinitionString = CompactPrinter(jsonDefinition)
+    log.debug(s"$LspDefinitionLogHead json request: $jsonDefinitionString")
+    lazy val analyses = getAnalyses
+    getDefinition(jsonDefinition)
+      .flatMap { definition =>
+        val uri = URI.create(definition.textDocument.uri)
+        Files
+          .lines(Paths.get(uri))
+          .skip(definition.position.line)
+          .findFirst
+          .toOption
+          .flatMap { line =>
+            log.debug(s"$LspDefinitionLogHead found line: $line")
+            textProcessor.identifier(line, definition.position.character.toInt)
+          }
+      } match {
+      case Some(sym) =>
+        log.debug(s"symbol $sym")
+        analyses
+          .map { analyses =>
+            import sbt.internal.CompatParColls.Converters._
+            val locations = analyses.par.flatMap { analysis =>
+              val selectPotentials = textProcessor.potentialClsOrTraitOrObj(sym)
+              val classes =
+                (analysis.apis.allInternalClasses ++ analysis.apis.allExternals).collect {
+                  selectPotentials
+                }
+              log.debug(s"$LspDefinitionLogHead potentials: $classes")
+              classes
+                .flatMap { className =>
+                  analysis.relations.definesClass(className) ++
+                    analysis.relations.libraryDefinesClass(className)
+                }
+                .flatMap { classFile: VirtualFileRef =>
+                  val x = converter.toPath(classFile)
+                  textProcessor.markPosition(x, sym).collect {
+                    case (uri, line, from, to) =>
+                      Location(
+                        uri.toString,
+                        Range(Position(line, from), Position(line, to)),
+                      )
+                  }
+                }
+            }.seq
+            log.debug(s"$LspDefinitionLogHead locations $locations")
+            import langserver.codec.JsonProtocol._
+            send(commandSource, requestId)(locations.toArray)
+          }
+          .recover {
+            case t =>
+              log.warn(s"Problem with processing analyses $t for $jsonDefinitionString")
+              val rsp = JsonRpcResponseError(
+                ErrorCodes.InternalError,
+                "Problem with processing analyses.",
+                None,
+              )
+              import JsonRPCProtocol._
+              send(commandSource, requestId)(rsp)
+          }
+        ()
+      case None =>
+        log.info(s"Symbol not found in definition request $jsonDefinitionString")
+        import langserver.codec.JsonProtocol._
+        send(commandSource, requestId)(Array.empty[Location])
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala b/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala
new file mode 100644
index 000000000..57c1c9c13
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala
@@ -0,0 +1,97 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import sbt.internal.langserver._
+import sbt.internal.protocol._
+import sbt.internal.protocol.codec._
+import sbt.protocol.{ CompletionParams => CP, SettingQuery => Q }
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+import sjsonnew.support.scalajson.unsafe.Converter
+import xsbti.FileConverter
+
+private[sbt] final case class LangServerError(code: Long, message: String)
+    extends Throwable(message)
+
+private[sbt] object LanguageServerProtocol {
+  private val internalJsonProtocol = new sbt.internal.langserver.codec.JsonProtocol
+  with sbt.protocol.codec.JsonProtocol with sjsonnew.BasicJsonProtocol with InitializeOptionFormats
+
+  import internalJsonProtocol._
+
+  def json(r: JsonRpcRequestMessage): JValue =
+    r.params.getOrElse(
+      throw LangServerError(
+        ErrorCodes.InvalidParams,
+        s"param is expected on '${r.method}' method."
+      )
+    )
+
+  lazy val serverCapabilities: ServerCapabilities = {
+    ServerCapabilities(
+      textDocumentSync = TextDocumentSyncOptions(true, 0, false, false, SaveOptions(false)),
+      hoverProvider = false,
+      definitionProvider = true
+    )
+  }
+
+  def handler(converter: FileConverter): ServerHandler = ServerHandler { callback =>
+    import callback._
+    ServerIntent(
+      onRequest = {
+        case r: JsonRpcRequestMessage if r.method == "initialize" =>
+          val param = Converter.fromJson[InitializeParams](json(r)).get
+          val optionJson = param.initializationOptions.getOrElse(
+            throw LangServerError(
+              ErrorCodes.InvalidParams,
+              "initializationOptions is expected on 'initialize' param."
+            )
+          )
+          val opt = Converter.fromJson[InitializeOption](optionJson).get
+          if (authOptions(ServerAuthentication.Token)) {
+            val token = opt.token.getOrElse(sys.error("'token' is missing."))
+            if (authenticate(token)) ()
+            else throw LangServerError(ErrorCodes.InvalidRequest, "invalid token")
+          } else ()
+          setInitialized(true)
+          if (!opt.skipAnalysis.getOrElse(false)) appendExec("collectAnalyses", None)
+          jsonRpcRespond(InitializeResult(serverCapabilities), Some(r.id))
+
+        case r: JsonRpcRequestMessage if r.method == "textDocument/definition" =>
+          val _ = Definition.lspDefinition(json(r), r.id, CommandSource(name), converter, log)(
+            StandardMain.executionContext
+          )
+
+        case r: JsonRpcRequestMessage if r.method == "sbt/exec" =>
+          val param = Converter.fromJson[SbtExecParams](json(r)).get
+          val _ = appendExec(param.commandLine, Some(r.id))
+
+        case r: JsonRpcRequestMessage if r.method == "sbt/setting" =>
+          val param = Converter.fromJson[Q](json(r)).get
+          onSettingQuery(Option(r.id), param)
+
+        case r: JsonRpcRequestMessage if r.method == "sbt/cancelRequest" =>
+          val param = Converter.fromJson[CancelRequestParams](json(r)).get
+          onCancellationRequest(Option(r.id), param)
+
+        case r: JsonRpcRequestMessage if r.method == "sbt/completion" =>
+          import sbt.protocol.codec.JsonProtocol._
+          val param = Converter.fromJson[CP](json(r)).get
+          onCompletionRequest(Option(r.id), param)
+
+      },
+      onResponse = PartialFunction.empty,
+      onNotification = {
+        case n: JsonRpcNotificationMessage if n.method == "textDocument/didSave" =>
+          val _ = appendExec(";Test/compile; collectAnalyses", None)
+      }
+    )
+  }
+}
diff --git a/main/src/main/scala/sbt/internal/server/NetworkChannel.scala b/main/src/main/scala/sbt/internal/server/NetworkChannel.scala
new file mode 100644
index 000000000..254ab3b2b
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/NetworkChannel.scala
@@ -0,0 +1,967 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import java.io.{ IOException, InputStream, OutputStream }
+import java.net.{ Socket, SocketTimeoutException }
+import java.util.concurrent.{
+  ConcurrentHashMap,
+  Executors,
+  LinkedBlockingQueue,
+  RejectedExecutionException,
+  TimeUnit
+}
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference }
+
+import sbt.BasicCommandStrings.{ Shutdown, TerminateAction }
+import sbt.internal.langserver.{ CancelRequestParams, ErrorCodes, LogMessageParams, MessageType }
+import sbt.internal.langserver.{ CancelRequestParams, ErrorCodes }
+import sbt.internal.protocol.{
+  JsonRpcNotificationMessage,
+  JsonRpcRequestMessage,
+  JsonRpcResponseError,
+  JsonRpcResponseMessage
+}
+import sbt.internal.ui.{ UITask, UserThread }
+import sbt.internal.util.{ Prompt, ReadJsonFromInputStream, Terminal, Util }
+import sbt.internal.util.Terminal.TerminalImpl
+import sbt.internal.util.complete.{ Parser, Parsers }
+import sbt.protocol._
+import sbt.util.Logger
+
+import scala.annotation.{ nowarn, tailrec }
+import scala.collection.mutable
+import scala.concurrent.duration._
+import scala.util.Try
+import scala.util.control.NonFatal
+import Serialization.{ attach, cancelReadSystemIn, readSystemIn }
+
+import sjsonnew._
+import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Converter }
+
+import BasicJsonProtocol._
+import Serialization.{ attach, promptChannel }
+import sbt.internal.util.ProgressState
+
+final class NetworkChannel(
+    val name: String,
+    connection: Socket,
+    auth: Set[ServerAuthentication],
+    instance: ServerInstance,
+    handlers: Seq[ServerHandler],
+    mkUIThreadImpl: (State, CommandChannel) => UITask,
+) extends CommandChannel { self =>
+  def this(
+      name: String,
+      connection: Socket,
+      structure: BuildStructure,
+      auth: Set[ServerAuthentication],
+      instance: ServerInstance,
+      handlers: Seq[ServerHandler],
+      log: Logger
+  ) =
+    this(
+      name,
+      connection,
+      auth,
+      instance,
+      handlers,
+      new UITask.AskUserTask(_, _),
+    )
+
+  def log: Logger = StandardMain.exchange.withState(_.log)
+
+  private val running = new AtomicBoolean(true)
+  private val delimiter: Byte = '\n'.toByte
+  private val out = connection.getOutputStream
+  private var initialized = false
+  private val pendingRequests: mutable.Map[String, JsonRpcRequestMessage] = mutable.Map()
+
+  private[this] val inputBuffer = new LinkedBlockingQueue[Int]()
+  private[this] val pendingWrites = new LinkedBlockingQueue[(Array[Byte], Boolean)]()
+  private[this] val attached = new AtomicBoolean(false)
+  private[this] val alive = new AtomicBoolean(true)
+  private[sbt] def isInteractive = interactive.get
+  private[this] val interactive = new AtomicBoolean(false)
+  private[sbt] def setInteractive(id: String, value: Boolean) = {
+    terminalHolder.getAndSet(new NetworkTerminal) match {
+      case null =>
+      case t    => t.close()
+    }
+    interactive.set(value)
+    if (isInteractive) terminal.setPrompt(Prompt.Pending)
+    attached.set(true)
+    pendingRequests.remove(id)
+    jsonRpcRespond("", id)
+    addFastTrackTask(attach)
+  }
+  private[sbt] def prompt(): Unit = {
+    interactive.set(true)
+    jsonRpcNotify(promptChannel, "")
+  }
+  private[sbt] def write(byte: Byte) = inputBuffer.add(byte.toInt)
+
+  private[this] val terminalHolder = new AtomicReference[Terminal](Terminal.NullTerminal)
+  override private[sbt] def terminal: Terminal = terminalHolder.get
+  override val userThread: UserThread = new UserThread(this)
+
+  private lazy val callback: ServerCallback = new ServerCallback {
+    def jsonRpcRespond[A: JsonFormat](event: A, execId: Option[String]): Unit =
+      self.respondResult(event, execId)
+
+    def jsonRpcRespondError(execId: Option[String], code: Long, message: String): Unit =
+      self.respondError(code, message, execId)
+
+    def jsonRpcNotify[A: JsonFormat](method: String, params: A): Unit =
+      self.jsonRpcNotify(method, params)
+
+    def appendExec(commandLine: String, execId: Option[String]): Boolean =
+      self.append(Exec(commandLine, execId, Some(CommandSource(name))))
+
+    def appendExec(exec: Exec): Boolean = self.append(exec)
+
+    def log: Logger = self.log
+    def name: String = self.name
+    private[sbt] def authOptions: Set[ServerAuthentication] = self.authOptions
+    private[sbt] def authenticate(token: String): Boolean = self.authenticate(token)
+    private[sbt] def setInitialized(value: Boolean): Unit = self.setInitialized(value)
+    private[sbt] def onSettingQuery(execId: Option[String], req: SettingQuery): Unit =
+      self.onSettingQuery(execId, req)
+    private[sbt] def onCompletionRequest(execId: Option[String], cp: CompletionParams): Unit =
+      self.onCompletionRequest(execId, cp)
+    private[sbt] def onCancellationRequest(execId: Option[String], crp: CancelRequestParams): Unit =
+      self.onCancellationRequest(execId, crp)
+  }
+
+  protected def authenticate(token: String): Boolean = instance.authenticate(token)
+
+  protected def setInitialized(value: Boolean): Unit = initialized = value
+
+  protected def authOptions: Set[ServerAuthentication] = auth
+
+  override def mkUIThread: (State, CommandChannel) => UITask = (state, command) => {
+    if (interactive.get || ContinuousCommands.isInWatch(state, this)) mkUIThreadImpl(state, command)
+    else
+      new UITask {
+        override private[sbt] val channel = NetworkChannel.this
+        override private[sbt] lazy val reader: UITask.Reader = () => {
+          try {
+            this.synchronized(this.wait)
+            Left(TerminateAction)
+          } catch {
+            case _: InterruptedException => Right("")
+          }
+        }
+      }
+  }
+
+  val thread = new Thread(s"sbt-networkchannel-${connection.getPort}") {
+    private val ct = "Content-Type: "
+    private val x1 = "application/sbt-x1"
+    override def run(): Unit = {
+      try {
+        connection.setSoTimeout(5000)
+
+        val in = connection.getInputStream
+        // keep going unless the socket has closed
+        while (running.get) {
+          try {
+            val onHeader: String => Unit = line => {
+              if (line.startsWith(ct) && line.contains(x1)) {
+                logMessage("error", s"server protocol $x1 is no longer supported")
+              }
+            }
+            val content = ReadJsonFromInputStream(in, running, Some(onHeader))
+            if (content.nonEmpty) handleBody(content)
+          } catch {
+            case _: SocketTimeoutException                => // its ok
+            case _: IOException | _: InterruptedException => running.set(false)
+          }
+        } // while
+      } finally {
+        shutdown(false)
+      }
+    }
+
+    private lazy val intents = {
+      handlers.toVector map { h =>
+        h.handler(callback)
+      }
+    }
+
+    lazy val onRequestMessage: PartialFunction[JsonRpcRequestMessage, Unit] =
+      intents.foldLeft(PartialFunction.empty[JsonRpcRequestMessage, Unit]) {
+        case (f, i) => f orElse i.onRequest
+      }
+    lazy val onResponseMessage: PartialFunction[JsonRpcResponseMessage, Unit] =
+      intents.foldLeft(PartialFunction.empty[JsonRpcResponseMessage, Unit]) {
+        case (f, i) => f orElse i.onResponse
+      }
+
+    lazy val onNotification: PartialFunction[JsonRpcNotificationMessage, Unit] =
+      intents.foldLeft(PartialFunction.empty[JsonRpcNotificationMessage, Unit]) {
+        case (f, i) => f orElse i.onNotification
+      }
+
+    def handleBody(chunk: Seq[Byte]): Unit = {
+      Serialization.deserializeJsonMessage(chunk) match {
+        case Right(req: JsonRpcRequestMessage) =>
+          try {
+            registerRequest(req)
+            onRequestMessage(req)
+          } catch {
+            case LangServerError(code, message) =>
+              log.debug(s"sending error: $code: $message")
+              respondError(code, message, Some(req.id))
+          }
+        case Right(res: JsonRpcResponseMessage) =>
+          onResponseMessage(res)
+        case Right(ntf: JsonRpcNotificationMessage) =>
+          try {
+            onNotification(ntf)
+          } catch {
+            case LangServerError(code, message) =>
+              logMessage("error", s"error $code while handling notification: $message")
+          }
+        case Right(msg) =>
+          log.debug(s"unhandled message: $msg")
+        case Left(errorDesc) =>
+          val msg =
+            s"got invalid chunk from client (${new String(chunk.toArray, "UTF-8")}): $errorDesc"
+          log.error(msg)
+          logMessage("error", msg)
+      }
+    }
+  }
+  thread.start()
+
+  private[sbt] def isLanguageServerProtocol: Boolean = true
+
+  private def registerRequest(request: JsonRpcRequestMessage): Unit = {
+    this.synchronized {
+      pendingRequests += (request.id -> request)
+      ()
+    }
+  }
+
+  private[sbt] def respondError(
+      err: JsonRpcResponseError,
+      execId: Option[String]
+  ): Unit = this.synchronized {
+    getPendingRequest(execId) match {
+      case Some(request) =>
+        pendingRequests -= request.id
+        jsonRpcRespondError(request.id, err)
+      case _ => logMessage("error", s"Error ${err.code}: ${err.message}")
+    }
+  }
+
+  private[sbt] def getPendingRequest(execId: Option[String]): Option[JsonRpcRequestMessage] = {
+    execId.flatMap {
+      // This handles multi commands from the network that were remapped to a different
+      // exec id for reporting purposes.
+      case id if id.startsWith(BasicCommandStrings.networkExecPrefix) =>
+        StandardMain.exchange.withState { s =>
+          s.get(BasicCommands.execMap)
+            .flatMap(_.collectFirst { case (k, `id`) => k })
+            .flatMap(pendingRequests.get)
+        }
+      case id => pendingRequests.get(id)
+    }
+  }
+
+  private[sbt] def respondError(
+      code: Long,
+      message: String,
+      execId: Option[String]
+  ): Unit = {
+    respondError(JsonRpcResponseError(code, message), execId)
+  }
+
+  private[sbt] def respondResult[A: JsonFormat](
+      event: A,
+      execId: Option[String]
+  ): Unit = this.synchronized {
+    getPendingRequest(execId) match {
+      case Some(request) =>
+        pendingRequests -= request.id
+        jsonRpcRespond(event, request.id)
+      case _ =>
+        val msg =
+          s"unmatched json response for requestId $execId: ${CompactPrinter(Converter.toJsonUnsafe(event))}"
+        log.debug(msg)
+    }
+  }
+
+  private[sbt] def notifyEvent[A: JsonFormat](method: String, params: A): Unit = {
+    jsonRpcNotify(method, params)
+  }
+
+  def respond[A: JsonFormat](event: A): Unit = respond(event, None)
+
+  def respond[A: JsonFormat](event: A, execId: Option[String]): Unit = if (alive.get) {
+    respondResult(event, execId)
+  }
+
+  def notifyEvent(event: EventMessage): Unit = {
+    event match {
+      case entry: LogEvent => logMessage(entry.level, entry.message)
+      case entry: ExecStatusEvent =>
+        getPendingRequest(entry.execId) match {
+          case Some(request) =>
+            logMessage("debug", s"${entry.status} ${request.method}")
+          case None =>
+            log.debug(
+              s"unmatched ${entry.status} event for requestId ${entry.execId}: ${entry.message}"
+            )
+        }
+      case _ => ()
+    }
+  }
+
+  def publishBytes(event: Array[Byte]): Unit = publishBytes(event, false)
+
+  /*
+   * Do writes on a background thread because otherwise the client socket can get blocked.
+   */
+  private[this] val writeThread = new Thread(() => {
+    @tailrec def impl(): Unit = {
+      val (event, delimit) =
+        try pendingWrites.take
+        catch {
+          case _: InterruptedException =>
+            alive.set(false)
+            (Array.empty[Byte], false)
+        }
+      if (alive.get) {
+        try {
+          out.write(event)
+          if (delimit) {
+            out.write(delimiter.toInt)
+          }
+          out.flush()
+        } catch {
+          case _: IOException =>
+            alive.set(false)
+            shutdown(true)
+          case _: InterruptedException =>
+            alive.set(false)
+        }
+        impl()
+      }
+    }
+    impl()
+  }, s"sbt-$name-write-thread")
+  writeThread.setDaemon(true)
+  writeThread.start()
+
+  def publishBytes(event: Array[Byte], delimit: Boolean): Unit =
+    try pendingWrites.put(event -> delimit)
+    catch { case _: InterruptedException => }
+
+  def onCommand(command: CommandMessage): Unit = command match {
+    case x: InitCommand  => onInitCommand(x)
+    case x: ExecCommand  => onExecCommand(x)
+    case x: SettingQuery => onSettingQuery(None, x)
+  }
+
+  private def onInitCommand(cmd: InitCommand): Unit = {
+    if (auth(ServerAuthentication.Token)) {
+      cmd.token match {
+        case Some(x) =>
+          authenticate(x) match {
+            case true =>
+              initialized = true
+              notifyEvent(ChannelAcceptedEvent(name))
+            case _ => sys.error("invalid token")
+          }
+        case None => sys.error("init command but without token.")
+      }
+    } else {
+      initialized = true
+    }
+  }
+
+  private def onExecCommand(cmd: ExecCommand) = {
+    if (initialized) {
+      append(
+        Exec(cmd.commandLine, cmd.execId orElse Some(Exec.newExecId), Some(CommandSource(name)))
+      )
+      ()
+    } else {
+      log.warn(s"ignoring command $cmd before initialization")
+    }
+  }
+
+  protected def onSettingQuery(execId: Option[String], req: SettingQuery) = {
+    if (initialized) {
+      import sbt.protocol.codec.JsonProtocol._
+      StandardMain.exchange.withState { s =>
+        val structure = Project.extract(s).structure
+        sbt.internal.server.SettingQuery.handleSettingQueryEither(req, structure) match {
+          case Right(x) => respondResult(x, execId)
+          case Left(s)  => respondError(ErrorCodes.InvalidParams, s, execId)
+        }
+      }
+    } else {
+      log.warn(s"ignoring query $req before initialization")
+    }
+  }
+
+  @nowarn
+  protected def onCompletionRequest(execId: Option[String], cp: CompletionParams) = {
+    if (initialized) {
+      try {
+        StandardMain.exchange.withState { sstate =>
+          import sbt.protocol.codec.JsonProtocol._
+          def completionItems(s: State) = {
+            Parser
+              .completions(s.combinedParser, cp.query, cp.level.getOrElse(9))
+              .get
+              .flatMap { c =>
+                if (!c.isEmpty) Some(c.append.replaceAll("\n", " "))
+                else None
+              }
+              .map(c => cp.query + c)
+          }
+          val (items, cachedMainClassNames, cachedTestNames) = {
+            val scopedKeyParser: Parser[Seq[Def.ScopedKey[_]]] =
+              Act.aggregatedKeyParser(sstate) <~ Parsers.any.*
+            Parser.parse(cp.query, scopedKeyParser) match {
+              case Right(keys) =>
+                val testKeys =
+                  keys.filter(k => k.key.label == "testOnly" || k.key.label == "testQuick")
+                val (testState, cachedTestNames) = testKeys.foldLeft((sstate, true)) {
+                  case ((st, allCached), k) =>
+                    SessionVar.loadAndSet(sbt.Keys.definedTestNames in k.scope, st, true) match {
+                      case (nst, d) => (nst, allCached && d.isDefined)
+                    }
+                }
+                val runKeys = keys.filter(_.key.label == "runMain")
+                val (runState, cachedMainClassNames) = runKeys.foldLeft((testState, true)) {
+                  case ((st, allCached), k) =>
+                    SessionVar.loadAndSet(sbt.Keys.discoveredMainClasses in k.scope, st, true) match {
+                      case (nst, d) => (nst, allCached && d.isDefined)
+                    }
+                }
+                (completionItems(runState), cachedMainClassNames, cachedTestNames)
+              case _ => (completionItems(sstate), true, true)
+            }
+          }
+          respondResult(
+            CompletionResponse(
+              items = items.toVector,
+              cachedMainClassNames = cachedMainClassNames,
+              cachedTestNames = cachedTestNames
+            ),
+            execId
+          )
+        }
+      } catch {
+        case NonFatal(_) =>
+          respondError(
+            ErrorCodes.UnknownError,
+            "Completions request failed",
+            execId
+          )
+      }
+    } else {
+      log.warn(s"ignoring completion request $cp before initialization")
+    }
+  }
+
+  protected def onCancellationRequest(execId: Option[String], crp: CancelRequestParams) = {
+    if (initialized) {
+
+      def errorRespond(msg: String) = respondError(
+        ErrorCodes.RequestCancelled,
+        msg,
+        execId
+      )
+
+      try {
+        Option(EvaluateTask.currentlyRunningTaskEngine.get) match {
+          case Some(runningEngine) =>
+            val runningExecId =
+              StandardMain.exchange.withState(_.currentCommand.flatMap(_.execId).getOrElse(""))
+            val expected = StandardMain.exchange.withState(
+              _.get(BasicCommands.execMap)
+                .flatMap(s => s.get(crp.id) orElse s.get("\u2668" + crp.id))
+                .getOrElse(crp.id)
+            )
+
+            def checkId(): Boolean = {
+              if (runningExecId.startsWith("\u2668")) {
+                (
+                  Try { crp.id.toLong }.toOption,
+                  Try { runningExecId.substring(1).toLong }.toOption
+                ) match {
+                  case (Some(id), Some(eid)) => id == eid
+                  case _                     => false
+                }
+              } else runningExecId == expected
+            }
+
+            // direct comparison on strings and
+            // remove hotspring unicode added character for numbers
+            if (checkId || (crp.id == Serialization.CancelAll &&
+                StandardMain.exchange.currentExec.exists(_.source.exists(_.channelName == name)))) {
+              runningEngine.cancelAndShutdown()
+
+              import sbt.protocol.codec.JsonProtocol._
+              respondResult(
+                ExecStatusEvent(
+                  "Task cancelled",
+                  Some(name),
+                  Some(runningExecId),
+                  Vector(),
+                  None,
+                ),
+                execId
+              )
+            } else {
+              errorRespond("Task ID not matched")
+            }
+
+          case None =>
+            errorRespond("No tasks under execution")
+        }
+      } catch {
+        case NonFatal(_) =>
+          errorRespond("Cancel request failed")
+      }
+    } else {
+      log.warn(s"ignoring cancellation request $crp before initialization")
+    }
+  }
+
+  @deprecated("Use variant that takes logShutdown parameter", "1.4.0")
+  override def shutdown(): Unit = {
+    shutdown(true)
+  }
+  import sjsonnew.BasicJsonProtocol.BooleanJsonFormat
+
+  override def shutdown(logShutdown: Boolean): Unit =
+    shutdown(logShutdown, remainingCommands = None)
+
+  /**
+   * Closes down the channel. Before closing the socket, it sends a notification to
+   * the client to shutdown. If the client initiated the shutdown, we don't want the
+   * client to display an error or return a non-zero exit code so we send it a
+   * notification that tells it whether or not to log the shutdown. This can't
+   * easily be done client side because when the client is in interactive session,
+   * it doesn't know commands it has sent to the server.
+   */
+  private[sbt] def shutdown(
+      logShutdown: Boolean,
+      remainingCommands: Option[(String, String)]
+  ): Unit = {
+    doFlush()
+    terminal.close()
+    StandardMain.exchange.removeChannel(this)
+    super.shutdown(logShutdown)
+    if (logShutdown) Terminal.consoleLog(s"shutting down client connection $name")
+    VirtualTerminal.cancelRequests(name)
+    try jsonRpcNotify(Shutdown, (logShutdown, remainingCommands))
+    catch { case _: IOException => }
+    running.set(false)
+    out.close()
+    outputStream.close()
+    thread.interrupt()
+    writeThread.interrupt()
+  }
+
+  /** Respond back to Language Server's client. */
+  private[sbt] def jsonRpcRespond[A: JsonFormat](event: A, execId: String): Unit = {
+    val m =
+      JsonRpcResponseMessage("2.0", execId, Option(Converter.toJson[A](event).get), None)
+    val bytes = Serialization.serializeResponseMessage(m)
+    publishBytes(bytes)
+  }
+
+  /** Respond back to Language Server's client. */
+  private[sbt] def jsonRpcRespondError[A: JsonFormat](
+      execId: String,
+      code: Long,
+      message: String,
+      data: A,
+  ): Unit = {
+    val err = JsonRpcResponseError(code, message, Converter.toJson[A](data).get)
+    jsonRpcRespondError(execId, err)
+  }
+
+  private[sbt] def jsonRpcRespondError(
+      execId: String,
+      err: JsonRpcResponseError
+  ): Unit = {
+    val m = JsonRpcResponseMessage("2.0", execId, None, Option(err))
+    val bytes = Serialization.serializeResponseMessage(m)
+    publishBytes(bytes)
+  }
+
+  /** Notify to Language Server's client. */
+  private[sbt] def jsonRpcNotify[A: JsonFormat](method: String, params: A): Unit = {
+    val m =
+      JsonRpcNotificationMessage("2.0", method, Option(Converter.toJson[A](params).get))
+    if (method != Serialization.systemOut) log.debug(s"jsonRpcNotify: $m")
+    val bytes = Serialization.serializeNotificationMessage(m)
+    publishBytes(bytes)
+  }
+
+  /** Notify to Language Server's client. */
+  private[sbt] def jsonRpcRequest[A: JsonFormat](id: String, method: String, params: A): Unit = {
+    val m =
+      JsonRpcRequestMessage("2.0", id, method, Option(Converter.toJson[A](params).get))
+    log.debug(s"jsonRpcRequest: $m")
+    val bytes = Serialization.serializeRequestMessage(m)
+    publishBytes(bytes)
+  }
+
+  def logMessage(level: String, message: String): Unit = {
+    import sbt.internal.langserver.codec.JsonProtocol._
+    jsonRpcNotify(
+      "build/logMessage",
+      LogMessageParams(MessageType.fromLevelString(level), message)
+    )
+  }
+
+  private[this] lazy val inputStream: InputStream = new Terminal.SimpleInputStream {
+    override def read(): Int = {
+      import sjsonnew.BasicJsonProtocol._
+      try {
+        jsonRpcNotify(readSystemIn, "")
+        inputBuffer.take
+      } catch {
+        case e: IOException =>
+          try jsonRpcNotify(cancelReadSystemIn, "")
+          catch { case _: IOException => }
+          -1
+      }
+    }
+    override def available(): Int = inputBuffer.size
+  }
+  private[this] lazy val writeableInputStream: Terminal.WriteableInputStream =
+    new Terminal.WriteableInputStream(inputStream, name)
+  import sjsonnew.BasicJsonProtocol._
+
+  import scala.collection.JavaConverters._
+  private[this] val outputBuffer = new LinkedBlockingQueue[Byte]
+  private[this] val flushFuture = new AtomicReference[java.util.concurrent.Future[_]]
+  private[this] def doFlush()() = {
+    val list = new java.util.ArrayList[Byte]
+    outputBuffer.synchronized(outputBuffer.drainTo(list))
+    if (!list.isEmpty) jsonRpcNotify(Serialization.systemOut, list.asScala.toSeq)
+  }
+  private[this] lazy val outputStream: OutputStream with AutoCloseable = new OutputStream
+    with AutoCloseable {
+    /*
+     * We buffer calls to flush to the remote client so that it is called at most
+     * once every 20 milliseconds. This is done because many terminals seem to flicker
+     * and display ghost characters if we flush to the remote client too often. The
+     * json protocol is a bit bulky so this will also reduce the total number of
+     * bytes that are written to the named pipe or unix domain socket. The buffer
+     * period of 20 milliseconds was arbitrarily chosen and could be tuned in the future.
+     * The thinking is that writes tend to be bursty so a twenty millisecond window is
+     * probably long enough to catch each burst but short enough to not introduce
+     * noticeable latency.
+     */
+    private[this] val executor =
+      Executors.newSingleThreadScheduledExecutor(
+        r => new Thread(r, s"$name-output-buffer-timer-thread")
+      )
+    override def close(): Unit = {
+      Util.ignoreResult(executor.shutdownNow())
+      doFlush()
+    }
+    override def write(b: Int): Unit = outputBuffer.synchronized {
+      outputBuffer.put(b.toByte)
+    }
+    override def flush(): Unit = {
+      flushFuture.get match {
+        case null =>
+          try {
+            flushFuture.set(
+              executor.schedule(
+                (() => {
+                  flushFuture.set(null)
+                  doFlush()
+                }): Runnable,
+                20,
+                TimeUnit.MILLISECONDS
+              )
+            )
+          } catch { case _: RejectedExecutionException => doFlush() }
+        case f =>
+      }
+    }
+    override def write(b: Array[Byte]): Unit = outputBuffer.synchronized {
+      b.foreach(outputBuffer.put)
+    }
+    override def write(b: Array[Byte], off: Int, len: Int): Unit = {
+      write(java.util.Arrays.copyOfRange(b, off, off + len))
+    }
+  }
+  private[this] lazy val errorStream: OutputStream = new OutputStream {
+    private[this] val buffer = new LinkedBlockingQueue[Byte]
+    override def write(b: Int): Unit = buffer.synchronized {
+      buffer.put(b.toByte)
+    }
+    override def flush(): Unit = {
+      val list = new java.util.ArrayList[Byte]
+      buffer.synchronized(buffer.drainTo(list))
+      if (!list.isEmpty) jsonRpcNotify(Serialization.systemErr, list.asScala.toSeq)
+    }
+    override def write(b: Array[Byte]): Unit = buffer.synchronized {
+      b.foreach(buffer.put)
+    }
+    override def write(b: Array[Byte], off: Int, len: Int): Unit = {
+      write(java.util.Arrays.copyOfRange(b, off, off + len))
+    }
+  }
+  private class NetworkTerminal
+      extends TerminalImpl(writeableInputStream, outputStream, errorStream, name) {
+    private[this] val pending = new AtomicBoolean(false)
+    private[this] val closed = new AtomicBoolean(false)
+    private[this] val properties = new AtomicReference[TerminalPropertiesResponse]
+    private[this] val lastUpdate = new AtomicReference[Deadline]
+    private def empty = TerminalPropertiesResponse(0, 0, false, false, false, false)
+    def getProperties(block: Boolean): Unit = {
+      if (alive.get) {
+        if (!pending.get && Option(lastUpdate.get).fold(true)(d => (d + 1.second).isOverdue)) {
+          pending.set(true)
+          val queue = VirtualTerminal.sendTerminalPropertiesQuery(name, jsonRpcRequest)
+          val update: Runnable = () => {
+            queue.poll(5, java.util.concurrent.TimeUnit.SECONDS) match {
+              case null =>
+              case t    => properties.set(t)
+            }
+            pending.synchronized {
+              lastUpdate.set(Deadline.now)
+              pending.set(false)
+              pending.notifyAll()
+            }
+          }
+          new Thread(update, s"network-terminal-$name-update") {
+            setDaemon(true)
+          }.start()
+        }
+        while (block && properties.get == null) pending.synchronized(pending.wait())
+        ()
+      } else throw new InterruptedException
+    }
+    private def withThread[R](f: => R, default: R): R = {
+      val t = Thread.currentThread
+      try {
+        blockedThreads.synchronized(blockedThreads.add(t))
+        f
+      } catch { case _: InterruptedException => default } finally {
+        Util.ignoreResult(blockedThreads.synchronized(blockedThreads.remove(t)))
+      }
+    }
+    def getProperty[T](f: TerminalPropertiesResponse => T, default: T): Option[T] = {
+      if (closed.get || !isAttached) None
+      else
+        withThread({
+          getProperties(true);
+          Some(f(Option(properties.get).getOrElse(empty)))
+        }, None)
+    }
+    private[this] def waitForPending(f: TerminalPropertiesResponse => Boolean): Boolean = {
+      if (closed.get || !isAttached) false
+      withThread(
+        {
+          if (pending.get) pending.synchronized(pending.wait())
+          Option(properties.get).map(f).getOrElse(false)
+        },
+        false
+      )
+    }
+    private[this] val blockedThreads = ConcurrentHashMap.newKeySet[Thread]
+    override private[sbt] val progressState: ProgressState = new ProgressState(
+      1,
+      StandardMain.exchange
+        .withState(_.get(Keys.superShellMaxTasks.key))
+        .getOrElse(SysProp.supershellMaxTasks)
+    )
+    override def getWidth: Int = getProperty(_.width, 0).getOrElse(0)
+    override def getHeight: Int = getProperty(_.height, 0).getOrElse(0)
+    override def isAnsiSupported: Boolean = getProperty(_.isAnsiSupported, false).getOrElse(false)
+    override def isEchoEnabled: Boolean = sbt.internal.util.JLine3.isEchoEnabled(getAttributes)
+    override def isSuccessEnabled: Boolean =
+      interactive.get ||
+        StandardMain.exchange.withState(ContinuousCommands.isInWatch(_, NetworkChannel.this))
+    override lazy val isColorEnabled: Boolean = waitForPending(_.isColorEnabled)
+    override lazy val isSupershellEnabled: Boolean = waitForPending(_.isSupershellEnabled)
+    getProperties(false)
+    private def getCapability[T](
+        query: TerminalCapabilitiesQuery,
+        result: TerminalCapabilitiesResponse => T
+    ): Option[T] = {
+      if (closed.get) None
+      else {
+        import sbt.protocol.codec.JsonProtocol._
+        val queue = VirtualTerminal.sendTerminalCapabilitiesQuery(name, jsonRpcRequest, query)
+        Some(result(queue.take))
+      }
+    }
+    override def getBooleanCapability(capability: String): Boolean =
+      getCapability(
+        TerminalCapabilitiesQuery(boolean = Some(capability), numeric = None, string = None),
+        _.boolean.getOrElse(false)
+      ).getOrElse(false)
+    override def getNumericCapability(capability: String): Integer =
+      getCapability(
+        TerminalCapabilitiesQuery(boolean = None, numeric = Some(capability), string = None),
+        (_: TerminalCapabilitiesResponse).numeric.map(Integer.valueOf).getOrElse(-1: Integer)
+      ).getOrElse(-1: Integer)
+    override def getStringCapability(capability: String): String =
+      getCapability(
+        TerminalCapabilitiesQuery(boolean = None, numeric = None, string = Some(capability)),
+        _.string.flatMap {
+          case "null" => None
+          case s      => Some(s)
+        }.orNull
+      ).getOrElse("")
+
+    override private[sbt] def getAttributes: Map[String, String] =
+      if (closed.get) Map.empty
+      else {
+        import sbt.protocol.codec.JsonProtocol._
+        val queue = VirtualTerminal.sendTerminalAttributesQuery(
+          name,
+          jsonRpcRequest
+        )
+        try {
+          val a = queue.take
+          Map(
+            "iflag" -> a.iflag,
+            "oflag" -> a.oflag,
+            "cflag" -> a.cflag,
+            "lflag" -> a.lflag,
+            "cchars" -> a.cchars
+          )
+        } catch { case _: InterruptedException => Map.empty }
+      }
+    override private[sbt] def setAttributes(attributes: Map[String, String]): Unit =
+      if (!closed.get) {
+        import sbt.protocol.codec.JsonProtocol._
+        val attrs = TerminalSetAttributesCommand(
+          iflag = attributes.getOrElse("iflag", ""),
+          oflag = attributes.getOrElse("oflag", ""),
+          cflag = attributes.getOrElse("cflag", ""),
+          lflag = attributes.getOrElse("lflag", ""),
+          cchars = attributes.getOrElse("cchars", ""),
+        )
+        val queue = VirtualTerminal.setTerminalAttributesCommand(name, jsonRpcRequest, attrs)
+        try queue.take
+        catch { case _: InterruptedException => }
+      }
+    override private[sbt] def getSizeImpl: (Int, Int) =
+      if (!closed.get) {
+        import sbt.protocol.codec.JsonProtocol._
+        val queue = VirtualTerminal.getTerminalSize(name, jsonRpcRequest)
+        val res = try queue.take
+        catch { case _: InterruptedException => TerminalGetSizeResponse(1, 1) }
+        (res.width, res.height)
+      } else (1, 1)
+    override def setSize(width: Int, height: Int): Unit =
+      if (!closed.get) {
+        import sbt.protocol.codec.JsonProtocol._
+        val size = TerminalSetSizeCommand(width, height)
+        val queue = VirtualTerminal.setTerminalSize(name, jsonRpcRequest, size)
+        try queue.take
+        catch { case _: InterruptedException => }
+      }
+    private[this] def setRawMode(toggle: Boolean): Unit = {
+      if (!closed.get || false) {
+        import sbt.protocol.codec.JsonProtocol._
+        val raw = TerminalSetRawModeCommand(toggle)
+        val queue = VirtualTerminal.setTerminalRawMode(name, jsonRpcRequest, raw)
+        try queue.take
+        catch { case _: InterruptedException => }
+      }
+    }
+    override private[sbt] def enterRawMode(): Unit = setRawMode(true)
+    override private[sbt] def exitRawMode(): Unit = setRawMode(false)
+    override def setEchoEnabled(toggle: Boolean): Unit =
+      if (!closed.get) {
+        import sbt.protocol.codec.JsonProtocol._
+        val echo = TerminalSetEchoCommand(toggle)
+        val queue = VirtualTerminal.setTerminalEcho(name, jsonRpcRequest, echo)
+        try queue.take
+        catch { case _: InterruptedException => () }
+      }
+
+    override def flush(): Unit = doFlush()
+    override def toString: String = s"NetworkTerminal($name)"
+    override def close(): Unit = if (closed.compareAndSet(false, true)) {
+      val threads = blockedThreads.synchronized {
+        val t = blockedThreads.asScala.toVector
+        blockedThreads.clear()
+        t
+      }
+      threads.foreach(_.interrupt())
+      super.close()
+    }
+  }
+  private[sbt] def isAttached: Boolean = attached.get
+}
+
+object NetworkChannel {
+  sealed trait ChannelState
+  case object SingleLine extends ChannelState
+  case object InHeader extends ChannelState
+  case object InBody extends ChannelState
+  private[sbt] def cancel(
+      execID: Option[String],
+      id: String,
+      force: Boolean
+  ): Either[String, String] = {
+
+    Option(EvaluateTask.currentlyRunningTaskEngine.get) match {
+      case Some(runningEngine) =>
+        val runningExecId =
+          StandardMain.exchange.withState(_.currentCommand.flatMap(_.execId).getOrElse(""))
+
+        def checkId(): Boolean = {
+          if (runningExecId.startsWith("\u2668")) {
+            (
+              Try { id.toLong }.toOption,
+              Try { runningExecId.substring(1).toLong }.toOption
+            ) match {
+              case (Some(id), Some(eid)) => id == eid
+              case _                     => false
+            }
+          } else runningExecId == id
+        }
+
+        // direct comparison on strings and
+        // remove hotspring unicode added character for numbers
+        if (checkId || force) {
+          runningEngine.cancelAndShutdown()
+          Right(runningExecId)
+        } else {
+          Left("Task ID not matched")
+        }
+
+      case None =>
+        Left("No tasks under execution")
+    }
+  }
+
+  private[sbt] val disconnect: Command =
+    Command.arb { s =>
+      val dncParser: Parser[String] = BasicCommandStrings.DisconnectNetworkChannel
+      dncParser.examples() ~> Parsers.Space.examples() ~> Parsers.any.*.examples()
+    } { (st, channel) =>
+      StandardMain.exchange.killChannel(channel.mkString)
+      st
+    }
+}
diff --git a/main/src/main/scala/sbt/internal/server/SettingQuery.scala b/main/src/main/scala/sbt/internal/server/SettingQuery.scala
new file mode 100644
index 000000000..98aa89655
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/SettingQuery.scala
@@ -0,0 +1,140 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import java.net.URI
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+import scala.util.{ Left, Right }
+import sbt.util.{ SomeJsonWriter, NoJsonWriter }
+import sbt.librarymanagement.LibraryManagementCodec._
+import sbt.protocol._
+import sjsonnew._
+import sjsonnew.support.scalajson.unsafe._
+
+object SettingQuery {
+  import sbt.internal.util.{ AttributeKey, Settings }
+  import sbt.internal.util.complete.{ DefaultParsers, Parser }, DefaultParsers._
+  import sbt.Def.{ showBuildRelativeKey2, ScopedKey }
+
+  // Similar to Act.ParsedAxis / Act.projectRef / Act.resolveProject except you can't omit the project reference
+
+  sealed trait ParsedExplicitAxis[+T]
+  final object ParsedExplicitGlobal extends ParsedExplicitAxis[Nothing]
+  final class ParsedExplicitValue[T](val value: T) extends ParsedExplicitAxis[T]
+  def explicitValue[T](t: Parser[T]): Parser[ParsedExplicitAxis[T]] = t map { v =>
+    new ParsedExplicitValue(v)
+  }
+
+  def projectRef(
+      index: KeyIndex,
+      currentBuild: URI
+  ): Parser[ParsedExplicitAxis[ResolvedReference]] = {
+    val global = token(Act.ZeroString ~ '/') ^^^ ParsedExplicitGlobal
+    val trailing = '/' !!! "Expected '/' (if selecting a project)"
+    global | explicitValue(Act.resolvedReference(index, currentBuild, trailing))
+  }
+
+  def resolveProject(parsed: ParsedExplicitAxis[ResolvedReference]): Option[ResolvedReference] =
+    parsed match {
+      case ParsedExplicitGlobal       => None
+      case pv: ParsedExplicitValue[_] => Some(pv.value)
+    }
+
+  def scopedKeyFull(
+      index: KeyIndex,
+      currentBuild: URI,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      keyMap: Map[String, AttributeKey[_]]
+  ): Parser[Seq[Parser[ParsedKey]]] = {
+    for {
+      rawProject <- projectRef(index, currentBuild)
+      proj = resolveProject(rawProject)
+      confAmb <- Act.config(index configs proj)
+      partialMask = ScopeMask(true, confAmb.isExplicit, false, false)
+    } yield Act.taskKeyExtra(index, defaultConfigs, keyMap, proj, confAmb, partialMask, Nil)
+  }
+
+  def scopedKeySelected(
+      index: KeyIndex,
+      currentBuild: URI,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      keyMap: Map[String, AttributeKey[_]],
+      data: Settings[Scope]
+  ): Parser[ParsedKey] =
+    scopedKeyFull(index, currentBuild, defaultConfigs, keyMap) flatMap { choices =>
+      Act.select(choices, data)(showBuildRelativeKey2(currentBuild))
+    }
+
+  def scopedKey(
+      index: KeyIndex,
+      currentBuild: URI,
+      defaultConfigs: Option[ResolvedReference] => Seq[String],
+      keyMap: Map[String, AttributeKey[_]],
+      data: Settings[Scope]
+  ): Parser[ScopedKey[_]] =
+    scopedKeySelected(index, currentBuild, defaultConfigs, keyMap, data).map(_.key)
+
+  def scopedKeyParser(structure: BuildStructure): Parser[ScopedKey[_]] =
+    scopedKey(
+      structure.index.keyIndex,
+      structure.root,
+      structure.extra.configurationsForAxis,
+      structure.index.keyMap,
+      structure.data
+    )
+
+  def getSettingValue[A](structure: BuildStructure, key: Def.ScopedKey[A]): Either[String, A] =
+    structure.data
+      .get(key.scope, key.key)
+      .toRight(s"Key ${Def displayFull key} not found")
+      .flatMap {
+        case _: Task[_] => Left(s"Key ${Def displayFull key} is a task, can only query settings")
+        case _: InputTask[_] =>
+          Left(s"Key ${Def displayFull key} is an input task, can only query settings")
+        case x => Right(x)
+      }
+
+  def getJsonWriter[A](key: AttributeKey[A]): Either[String, JsonWriter[A]] =
+    key.optJsonWriter match {
+      case SomeJsonWriter(jw) => Right(jw)
+      case NoJsonWriter()     => Left(s"JsonWriter for ${key.manifest} not found")
+    }
+
+  def toJson[A: JsonWriter](x: A): JValue = Converter toJsonUnsafe x
+
+  def getSettingJsonValue[A](
+      structure: BuildStructure,
+      key: Def.ScopedKey[A]
+  ): Either[String, JValue] =
+    getSettingValue(structure, key) flatMap (
+        value =>
+          getJsonWriter(key.key) map { implicit jw: JsonWriter[A] =>
+            toJson(value)
+          }
+      )
+
+  def handleSettingQueryEither(
+      req: SettingQuery,
+      structure: BuildStructure
+  ): Either[String, SettingQuerySuccess] = {
+    val key = Parser.parse(req.setting, scopedKeyParser(structure))
+
+    for {
+      key <- key
+      json <- getSettingJsonValue(structure, key)
+    } yield SettingQuerySuccess(json, key.key.manifest.toString)
+  }
+
+  def handleSettingQuery(req: SettingQuery, structure: BuildStructure): SettingQueryResponse =
+    handleSettingQueryEither(req, structure) match {
+      case Right(x) => x
+      case Left(s)  => SettingQueryFailure(s)
+    }
+}
diff --git a/main/src/main/scala/sbt/internal/server/VirtualTerminal.scala b/main/src/main/scala/sbt/internal/server/VirtualTerminal.scala
new file mode 100644
index 000000000..c88adaab8
--- /dev/null
+++ b/main/src/main/scala/sbt/internal/server/VirtualTerminal.scala
@@ -0,0 +1,253 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import java.util.concurrent.{ ArrayBlockingQueue, ConcurrentHashMap }
+import java.util.UUID
+import sbt.internal.protocol.{
+  JsonRpcNotificationMessage,
+  JsonRpcRequestMessage,
+  JsonRpcResponseMessage
+}
+import sbt.protocol.Serialization.{
+  attach,
+  systemIn,
+  getTerminalAttributes,
+  setTerminalAttributes,
+  terminalCapabilities,
+  terminalGetSize,
+  terminalPropertiesQuery,
+  terminalSetEcho,
+  terminalSetSize,
+  terminalSetRawMode,
+}
+import sjsonnew.support.scalajson.unsafe.Converter
+import sbt.protocol.{
+  Attach,
+  TerminalAttributesQuery,
+  TerminalAttributesResponse,
+  TerminalCapabilitiesQuery,
+  TerminalCapabilitiesResponse,
+  TerminalPropertiesResponse,
+  TerminalGetSizeQuery,
+  TerminalGetSizeResponse,
+  TerminalSetAttributesCommand,
+  TerminalSetEchoCommand,
+  TerminalSetSizeCommand,
+  TerminalSetRawModeCommand,
+}
+import sbt.protocol.codec.JsonProtocol._
+import sbt.protocol.TerminalGetSizeResponse
+
+object VirtualTerminal {
+  private[this] val pendingTerminalProperties =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[TerminalPropertiesResponse]]()
+  private[this] val pendingTerminalCapabilities =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[TerminalCapabilitiesResponse]]
+  private[this] val pendingTerminalAttributes =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[TerminalAttributesResponse]]
+  private[this] val pendingTerminalSetAttributes =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[Unit]]
+  private[this] val pendingTerminalSetSize =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[Unit]]
+  private[this] val pendingTerminalGetSize =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[TerminalGetSizeResponse]]
+  private[this] val pendingTerminalSetEcho =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[Unit]]
+  private[this] val pendingTerminalSetRawMode =
+    new ConcurrentHashMap[(String, String), ArrayBlockingQueue[Unit]]
+  private[sbt] def sendTerminalPropertiesQuery(
+      channelName: String,
+      jsonRpcRequest: (String, String, String) => Unit
+  ): ArrayBlockingQueue[TerminalPropertiesResponse] = {
+    val id = UUID.randomUUID.toString
+    val queue = new ArrayBlockingQueue[TerminalPropertiesResponse](1)
+    pendingTerminalProperties.put((channelName, id), queue)
+    jsonRpcRequest(id, terminalPropertiesQuery, "")
+    queue
+  }
+  private[sbt] def sendTerminalCapabilitiesQuery(
+      channelName: String,
+      jsonRpcRequest: (String, String, TerminalCapabilitiesQuery) => Unit,
+      query: TerminalCapabilitiesQuery,
+  ): ArrayBlockingQueue[TerminalCapabilitiesResponse] = {
+    val id = UUID.randomUUID.toString
+    val queue = new ArrayBlockingQueue[TerminalCapabilitiesResponse](1)
+    pendingTerminalCapabilities.put((channelName, id), queue)
+    jsonRpcRequest(id, terminalCapabilities, query)
+    queue
+  }
+  private[sbt] def cancelRequests(name: String): Unit = {
+    import scala.collection.JavaConverters._
+    pendingTerminalCapabilities.asScala.foreach {
+      case (k @ (`name`, _), q) =>
+        pendingTerminalCapabilities.remove(k)
+        q.put(TerminalCapabilitiesResponse(None, None, None))
+      case _ =>
+    }
+    pendingTerminalProperties.asScala.foreach {
+      case (k @ (`name`, _), q) =>
+        pendingTerminalProperties.remove(k)
+        q.put(TerminalPropertiesResponse(0, 0, false, false, false, false))
+      case _ =>
+    }
+  }
+  private[sbt] def sendTerminalAttributesQuery(
+      channelName: String,
+      jsonRpcRequest: (String, String, TerminalAttributesQuery) => Unit,
+  ): ArrayBlockingQueue[TerminalAttributesResponse] = {
+    val id = UUID.randomUUID.toString
+    val queue = new ArrayBlockingQueue[TerminalAttributesResponse](1)
+    pendingTerminalAttributes.put((channelName, id), queue)
+    jsonRpcRequest(id, getTerminalAttributes, TerminalAttributesQuery())
+    queue
+  }
+  private[sbt] def setTerminalAttributesCommand(
+      channelName: String,
+      jsonRpcRequest: (String, String, TerminalSetAttributesCommand) => Unit,
+      query: TerminalSetAttributesCommand
+  ): ArrayBlockingQueue[Unit] = {
+    val id = UUID.randomUUID.toString
+    val queue = new ArrayBlockingQueue[Unit](1)
+    pendingTerminalSetAttributes.put((channelName, id), queue)
+    jsonRpcRequest(id, setTerminalAttributes, query)
+    queue
+  }
+
+  private[sbt] def setTerminalSize(
+      channelName: String,
+      jsonRpcRequest: (String, String, TerminalSetSizeCommand) => Unit,
+      query: TerminalSetSizeCommand
+  ): ArrayBlockingQueue[Unit] = {
+    val id = UUID.randomUUID.toString
+    val queue = new ArrayBlockingQueue[Unit](1)
+    pendingTerminalSetSize.put((channelName, id), queue)
+    jsonRpcRequest(id, terminalSetSize, query)
+    queue
+  }
+
+  private[sbt] def getTerminalSize(
+      channelName: String,
+      jsonRpcRequest: (String, String, TerminalGetSizeQuery) => Unit,
+  ): ArrayBlockingQueue[TerminalGetSizeResponse] = {
+    val id = UUID.randomUUID.toString
+    val query = TerminalGetSizeQuery()
+    val queue = new ArrayBlockingQueue[TerminalGetSizeResponse](1)
+    pendingTerminalGetSize.put((channelName, id), queue)
+    jsonRpcRequest(id, terminalGetSize, query)
+    queue
+  }
+
+  private[sbt] def setTerminalEcho(
+      channelName: String,
+      jsonRpcRequest: (String, String, TerminalSetEchoCommand) => Unit,
+      query: TerminalSetEchoCommand
+  ): ArrayBlockingQueue[Unit] = {
+    val id = UUID.randomUUID.toString
+    val queue = new ArrayBlockingQueue[Unit](1)
+    pendingTerminalSetEcho.put((channelName, id), queue)
+    jsonRpcRequest(id, terminalSetEcho, query)
+    queue
+  }
+
+  private[sbt] def setTerminalRawMode(
+      channelName: String,
+      jsonRpcRequest: (String, String, TerminalSetRawModeCommand) => Unit,
+      query: TerminalSetRawModeCommand
+  ): ArrayBlockingQueue[Unit] = {
+    val id = UUID.randomUUID.toString
+    val queue = new ArrayBlockingQueue[Unit](1)
+    pendingTerminalSetEcho.put((channelName, id), queue)
+    jsonRpcRequest(id, terminalSetRawMode, query)
+    queue
+  }
+
+  val handler = ServerHandler { cb =>
+    ServerIntent(requestHandler(cb), responseHandler(cb), notificationHandler(cb))
+  }
+  type Handler[R] = ServerCallback => PartialFunction[R, Unit]
+  private val requestHandler: Handler[JsonRpcRequestMessage] =
+    callback => {
+      case r if r.method == attach =>
+        val isInteractive = r.params
+          .flatMap(Converter.fromJson[Attach](_).toOption.map(_.interactive))
+          .exists(identity)
+        StandardMain.exchange.channelForName(callback.name) match {
+          case Some(nc: NetworkChannel) => nc.setInteractive(r.id, isInteractive)
+          case _                        =>
+        }
+    }
+  private val responseHandler: Handler[JsonRpcResponseMessage] =
+    callback => {
+      case r if pendingTerminalProperties.get((callback.name, r.id)) != null =>
+        val response =
+          r.result.flatMap(Converter.fromJson[TerminalPropertiesResponse](_).toOption)
+        pendingTerminalProperties.remove((callback.name, r.id)) match {
+          case null   =>
+          case buffer => response.foreach(buffer.put)
+        }
+      case r if pendingTerminalCapabilities.get((callback.name, r.id)) != null =>
+        val response =
+          r.result.flatMap(
+            Converter.fromJson[TerminalCapabilitiesResponse](_).toOption
+          )
+        pendingTerminalCapabilities.remove((callback.name, r.id)) match {
+          case null =>
+          case buffer =>
+            buffer.put(response.getOrElse(TerminalCapabilitiesResponse(None, None, None)))
+        }
+      case r if pendingTerminalAttributes.get((callback.name, r.id)) != null =>
+        val response =
+          r.result.flatMap(Converter.fromJson[TerminalAttributesResponse](_).toOption)
+        pendingTerminalAttributes.remove((callback.name, r.id)) match {
+          case null =>
+          case buffer =>
+            buffer.put(response.getOrElse(TerminalAttributesResponse("", "", "", "", "")))
+        }
+      case r if pendingTerminalSetAttributes.get((callback.name, r.id)) != null =>
+        pendingTerminalSetAttributes.remove((callback.name, r.id)) match {
+          case null   =>
+          case buffer => buffer.put(())
+        }
+      case r if pendingTerminalSetSize.get((callback.name, r.id)) != null =>
+        pendingTerminalSetSize.remove((callback.name, r.id)) match {
+          case null   =>
+          case buffer => buffer.put(())
+        }
+      case r if pendingTerminalGetSize.get((callback.name, r.id)) != null =>
+        val response =
+          r.result.flatMap(Converter.fromJson[TerminalGetSizeResponse](_).toOption)
+        pendingTerminalGetSize.remove((callback.name, r.id)) match {
+          case null   =>
+          case buffer => buffer.put(response.getOrElse(TerminalGetSizeResponse(1, 1)))
+        }
+      case r if pendingTerminalSetEcho.get((callback.name, r.id)) != null =>
+        pendingTerminalSetEcho.remove((callback.name, r.id)) match {
+          case null   =>
+          case buffer => buffer.put(())
+        }
+      case r if pendingTerminalSetRawMode.get((callback.name, r.id)) != null =>
+        pendingTerminalSetRawMode.remove((callback.name, r.id)) match {
+          case null   =>
+          case buffer => buffer.put(())
+        }
+    }
+  private val notificationHandler: Handler[JsonRpcNotificationMessage] =
+    callback => {
+      case n if n.method == systemIn =>
+        import sjsonnew.BasicJsonProtocol._
+        n.params.flatMap(Converter.fromJson[Byte](_).toOption).foreach { byte =>
+          StandardMain.exchange.channelForName(callback.name) match {
+            case Some(nc: NetworkChannel) => nc.write(byte)
+            case _                        =>
+          }
+        }
+    }
+}
diff --git a/main/src/main/scala/sbt/nio/FileChanges.scala b/main/src/main/scala/sbt/nio/FileChanges.scala
new file mode 100644
index 000000000..66329caad
--- /dev/null
+++ b/main/src/main/scala/sbt/nio/FileChanges.scala
@@ -0,0 +1,60 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.nio
+
+import java.nio.file.Path
+
+/**
+ * A report on the changes of the input file dependencies or output files of a task compared to
+ * some previous time. It also contains the complete list of current inputs or outputs.
+ *
+ * @param created the files that were not present previously. When this is non empty, it does not
+ *                necessarily mean that the files were recently created. It could just indicate
+ *                that there was no previous cache entry for the file stamps (
+ *                see [[FileChanges#noPrevious]]).
+ * @param deleted the files that have been deleted. This should be empty when no previous list of
+ *                files is available.
+ * @param modified the files that have been modified. This should be empty when no previous list of
+ *                 files is available.
+ * @param unmodified the files that have no changes. This should be empty when no previous list of
+ *                   files is availab.e
+ */
+final case class FileChanges(
+    created: Seq[Path],
+    deleted: Seq[Path],
+    modified: Seq[Path],
+    unmodified: Seq[Path]
+) {
+
+  /**
+   * Return true either if there is no previous information or
+   * @return true if there are no changes.
+   */
+  lazy val hasChanges: Boolean = created.nonEmpty || deleted.nonEmpty || modified.nonEmpty
+}
+
+object FileChanges {
+
+  /**
+   * Creates an instance of [[FileChanges]] for a collection of files for which there were no
+   * previous file stamps available.
+   * @param files all of the existing files.
+   * @return the [[FileChanges]] with the [[FileChanges.created]] field set to the input, `files`.
+   */
+  def noPrevious(files: Seq[Path]): FileChanges =
+    FileChanges(created = files, deleted = Nil, modified = Nil, unmodified = Nil)
+
+  /**
+   * Creates an instance of [[FileChanges]] for a collection of files for which there were no
+   * changes when compared to the previous file stamps.
+   * @param files all of the existing files.
+   * @return the [[FileChanges]] with the [[FileChanges.unmodified]] field set to the input, `files`.
+   */
+  def unmodified(files: Seq[Path]): FileChanges =
+    FileChanges(created = Nil, deleted = Nil, modified = Nil, unmodified = files)
+}
diff --git a/main/src/main/scala/sbt/nio/FileStamp.scala b/main/src/main/scala/sbt/nio/FileStamp.scala
new file mode 100644
index 000000000..1a892373e
--- /dev/null
+++ b/main/src/main/scala/sbt/nio/FileStamp.scala
@@ -0,0 +1,327 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.nio
+
+import java.io.{ File, IOException }
+import java.nio.file.{ Path, Paths }
+import java.util.concurrent.ConcurrentHashMap
+
+import sbt.internal.inc.{ EmptyStamp, Stamper, Hash => IncHash, LastModified => IncLastModified }
+import sbt.io.IO
+import sbt.nio.file.FileAttributes
+import sjsonnew.{ Builder, JsonFormat, Unbuilder, deserializationError }
+import xsbti.compile.analysis.{ Stamp => XStamp }
+
+/**
+ * A trait that indicates what file stamping implementation should be used to track the state of
+ * a given file. The two choices are [[FileStamper.Hash]] and [[FileStamper.LastModified]].
+ */
+sealed trait FileStamper
+
+/**
+ * Provides implementations of [[FileStamper]].
+ *
+ */
+object FileStamper {
+
+  /**
+   * Track files using a hash.
+   */
+  case object Hash extends FileStamper
+
+  /**
+   * Track files using the last modified time.
+   */
+  case object LastModified extends FileStamper
+}
+
+/**
+ * Represents the state of a file. This representation is either a hash of the file contents or
+ * the last modified time.
+ */
+sealed trait FileStamp
+
+/**
+ * Provides json formatters for [[FileStamp]].
+ */
+object FileStamp {
+  private[sbt] type Id[T] = T
+
+  private[sbt] implicit class Ops(val fileStamp: FileStamp) {
+    private[sbt] def stamp: XStamp = fileStamp match {
+      case f: FileHashImpl    => f.xstamp
+      case LastModified(time) => new IncLastModified(time)
+      case _                  => EmptyStamp
+    }
+  }
+
+  private[sbt] def apply(path: Path, fileStamper: FileStamper): Option[FileStamp] =
+    fileStamper match {
+      case FileStamper.Hash         => hash(path)
+      case FileStamper.LastModified => lastModified(path)
+    }
+  private[sbt] def apply(stamp: XStamp): Option[FileStamp] = stamp match {
+    case lm: IncLastModified => Some(new LastModified(lm.value))
+    case s: IncHash          => Some(fromZincStamp(s))
+    case _                   => None
+  }
+  private[sbt] def apply(path: Path, fileAttributes: FileAttributes): Option[FileStamp] =
+    try {
+      if (fileAttributes.isDirectory) lastModified(path)
+      else
+        path.toString match {
+          case s if s.endsWith(".jar")   => lastModified(path)
+          case s if s.endsWith(".class") => lastModified(path)
+          case _                         => hash(path)
+        }
+    } catch {
+      case e: IOException => Some(Error(e))
+    }
+  private[sbt] def hash(string: String): Hash =
+    new FileHashImpl(try {
+      sbt.internal.inc.Stamp.fromString(string)
+    } catch {
+      case _: Throwable => EmptyStamp
+    })
+  private[sbt] def hash(path: Path): Option[Hash] = Stamper.forFarmHashP(path) match {
+    case EmptyStamp => None
+    case s          => Some(new FileHashImpl(s))
+  }
+  private[sbt] def fromZincStamp(stamp: XStamp): Hash = new FileHashImpl(stamp)
+  private[sbt] def lastModified(path: Path): Option[LastModified] =
+    IO.getModifiedTimeOrZero(path.toFile) match {
+      case 0 => None
+      case l => Some(LastModified(l))
+    }
+  private[this] class FileHashImpl(val xstamp: XStamp) extends Hash(xstamp.toString)
+  private[sbt] sealed abstract case class Hash private[sbt] (hex: String) extends FileStamp
+  private[sbt] final case class LastModified private[sbt] (time: Long) extends FileStamp
+  private[sbt] final case class Error(exception: IOException) extends FileStamp
+
+  object Formats {
+    implicit val seqPathJsonFormatter: JsonFormat[Seq[Path]] = new JsonFormat[Seq[Path]] {
+      override def write[J](obj: Seq[Path], builder: Builder[J]): Unit = {
+        builder.beginArray()
+        obj.foreach { path =>
+          builder.writeString(path.toString)
+        }
+        builder.endArray()
+      }
+
+      override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[Path] =
+        jsOpt match {
+          case Some(js) =>
+            val size = unbuilder.beginArray(js)
+            val res = (1 to size) map { _ =>
+              Paths.get(unbuilder.readString(unbuilder.nextElement))
+            }
+            unbuilder.endArray()
+            res
+          case None =>
+            deserializationError("Expected JsArray but found None")
+        }
+    }
+
+    implicit val seqFileJsonFormatter: JsonFormat[Seq[File]] = new JsonFormat[Seq[File]] {
+      override def write[J](obj: Seq[File], builder: Builder[J]): Unit = {
+        builder.beginArray()
+        obj.foreach { file =>
+          builder.writeString(file.toString)
+        }
+        builder.endArray()
+      }
+
+      override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[File] =
+        jsOpt match {
+          case Some(js) =>
+            val size = unbuilder.beginArray(js)
+            val res = (1 to size) map { _ =>
+              new File(unbuilder.readString(unbuilder.nextElement))
+            }
+            unbuilder.endArray()
+            res
+          case None =>
+            deserializationError("Expected JsArray but found None")
+        }
+    }
+    implicit val fileJsonFormatter: JsonFormat[File] = new JsonFormat[File] {
+      override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): File =
+        seqFileJsonFormatter.read(jsOpt, unbuilder).head
+
+      override def write[J](obj: File, builder: Builder[J]): Unit =
+        seqFileJsonFormatter.write(obj :: Nil, builder)
+    }
+    implicit val pathJsonFormatter: JsonFormat[Path] = new JsonFormat[Path] {
+      override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Path =
+        seqPathJsonFormatter.read(jsOpt, unbuilder).head
+
+      override def write[J](obj: Path, builder: Builder[J]): Unit =
+        seqPathJsonFormatter.write(obj :: Nil, builder)
+    }
+    implicit val seqPathFileStampJsonFormatter: JsonFormat[Seq[(Path, FileStamp)]] =
+      new JsonFormat[Seq[(Path, FileStamp)]] {
+        override def write[J](obj: Seq[(Path, FileStamp)], builder: Builder[J]): Unit = {
+          val (hashes, lastModifiedTimes) = obj.partition(_._2.isInstanceOf[Hash])
+          builder.beginObject()
+          builder.addField("hashes", hashes.asInstanceOf[Seq[(Path, Hash)]])(
+            seqPathHashJsonFormatter
+          )
+          builder.addField(
+            "lastModifiedTimes",
+            lastModifiedTimes.asInstanceOf[Seq[(Path, LastModified)]]
+          )(seqPathLastModifiedJsonFormatter)
+          builder.endObject()
+        }
+
+        override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[(Path, FileStamp)] =
+          jsOpt match {
+            case Some(js) =>
+              unbuilder.beginObject(js)
+              val hashes = unbuilder.readField("hashes")(seqPathHashJsonFormatter)
+              val lastModifieds =
+                unbuilder.readField("lastModifiedTimes")(seqPathLastModifiedJsonFormatter)
+              unbuilder.endObject()
+              hashes ++ lastModifieds
+            case None =>
+              deserializationError("Expected JsObject but found None")
+          }
+      }
+    private[sbt] val seqPathHashJsonFormatter: JsonFormat[Seq[(Path, Hash)]] =
+      new JsonFormat[Seq[(Path, Hash)]] {
+        override def write[J](obj: Seq[(Path, Hash)], builder: Builder[J]): Unit = {
+          builder.beginArray()
+          obj.foreach {
+            case (p, h) =>
+              builder.beginArray()
+              builder.writeString(p.toString)
+              builder.writeString(h.hex)
+              builder.endArray()
+          }
+          builder.endArray()
+        }
+
+        override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[(Path, Hash)] =
+          jsOpt match {
+            case Some(js) =>
+              val size = unbuilder.beginArray(js)
+              val res = (1 to size) map { _ =>
+                unbuilder.beginArray(unbuilder.nextElement)
+                val path = Paths.get(unbuilder.readString(unbuilder.nextElement))
+                val hash = FileStamp.hash(unbuilder.readString(unbuilder.nextElement))
+                unbuilder.endArray()
+                path -> hash
+              }
+              unbuilder.endArray()
+              res
+            case None =>
+              deserializationError("Expected JsArray but found None")
+          }
+      }
+    private[sbt] val seqPathLastModifiedJsonFormatter: JsonFormat[Seq[(Path, LastModified)]] =
+      new JsonFormat[Seq[(Path, LastModified)]] {
+        override def write[J](obj: Seq[(Path, LastModified)], builder: Builder[J]): Unit = {
+          builder.beginArray()
+          obj.foreach {
+            case (p, lm) =>
+              builder.beginArray()
+              builder.writeString(p.toString)
+              builder.writeLong(lm.time)
+              builder.endArray()
+          }
+          builder.endArray()
+        }
+
+        override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Seq[(Path, LastModified)] =
+          jsOpt match {
+            case Some(js) =>
+              val size = unbuilder.beginArray(js)
+              val res = (1 to size) map { _ =>
+                unbuilder.beginArray(unbuilder.nextElement)
+                val path = Paths.get(unbuilder.readString(unbuilder.nextElement))
+                val hash = FileStamp.LastModified(unbuilder.readLong(unbuilder.nextElement))
+                unbuilder.endArray()
+                path -> hash
+              }
+              unbuilder.endArray()
+              res
+            case None =>
+              deserializationError("Expected JsArray but found None")
+          }
+      }
+  }
+
+  private implicit class EitherOps(val e: Either[FileStamp, FileStamp]) extends AnyVal {
+    def value: Option[FileStamp] = if (e == null) None else Some(e.fold(identity, identity))
+  }
+
+  private[sbt] class Cache {
+    private[this] val underlying = new ConcurrentHashMap[Path, Either[FileStamp, FileStamp]]
+
+    /**
+     * Invalidate the cache entry, but don't re-stamp the file until it's actually used
+     * in a call to get or update.
+     *
+     * @param path the file whose stamp we are invalidating
+     */
+    def invalidate(path: Path): Unit = underlying.get(path) match {
+      case Right(s) =>
+        underlying.put(path, Left(s))
+        ()
+      case _ => ()
+    }
+    def get(path: Path): Option[FileStamp] =
+      underlying.get(path) match {
+        case null     => None
+        case Left(v)  => updateImpl(path, fileStampToStamper(v))
+        case Right(v) => Some(v)
+      }
+    def getOrElseUpdate(path: Path, stamper: FileStamper): Option[FileStamp] =
+      underlying.get(path) match {
+        case null     => updateImpl(path, stamper)
+        case Left(_)  => updateImpl(path, stamper)
+        case Right(v) => Some(v)
+      }
+    def remove(key: Path): Option[FileStamp] = {
+      underlying.remove(key).value
+    }
+    def put(key: Path, fileStamp: FileStamp): Option[FileStamp] =
+      underlying.put(key, Right(fileStamp)) match {
+        case null => None
+        case e    => e.value
+      }
+
+    def putIfAbsent(key: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) = {
+      underlying.get(key) match {
+        case null     => (None, updateImpl(key, stamper))
+        case Right(s) => (Some(s), None)
+        case Left(_)  => (None, None)
+      }
+    }
+    def update(key: Path, stamper: FileStamper): (Option[FileStamp], Option[FileStamp]) = {
+      underlying.get(key) match {
+        case null => (None, updateImpl(key, stamper))
+        case v    => (v.value, updateImpl(key, stamper))
+      }
+    }
+
+    private def fileStampToStamper(stamp: FileStamp): FileStamper = stamp match {
+      case _: Hash => FileStamper.Hash
+      case _       => FileStamper.LastModified
+    }
+
+    private def updateImpl(path: Path, stamper: FileStamper): Option[FileStamp] = {
+      val stamp = FileStamp(path, stamper)
+      stamp match {
+        case None    => underlying.remove(path)
+        case Some(s) => underlying.put(path, Right(s))
+      }
+      stamp
+    }
+
+  }
+}
diff --git a/main/src/main/scala/sbt/nio/Keys.scala b/main/src/main/scala/sbt/nio/Keys.scala
new file mode 100644
index 000000000..373f23cda
--- /dev/null
+++ b/main/src/main/scala/sbt/nio/Keys.scala
@@ -0,0 +1,193 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.nio
+
+import java.io.InputStream
+import java.nio.file.Path
+import java.util.concurrent.atomic.AtomicBoolean
+
+import sbt.BuildSyntax.{ settingKey, taskKey }
+import sbt.KeyRanks.{ BMinusSetting, DSetting, Invisible }
+import sbt.internal.DynamicInput
+import sbt.internal.nio.FileTreeRepository
+import sbt.internal.util.AttributeKey
+import sbt.internal.util.complete.Parser
+import sbt.nio.file.{ FileAttributes, FileTreeView, Glob, PathFilter }
+import sbt._
+
+import scala.concurrent.duration.FiniteDuration
+
+object Keys {
+  sealed trait WatchBuildSourceOption
+  case object IgnoreSourceChanges extends WatchBuildSourceOption
+  case object WarnOnSourceChanges extends WatchBuildSourceOption
+  case object ReloadOnSourceChanges extends WatchBuildSourceOption
+  val allInputFiles =
+    taskKey[Seq[Path]]("All of the file inputs for a task excluding directories and hidden files.")
+  val changedInputFiles =
+    taskKey[Seq[(Path, FileStamp)] => FileChanges]("The changed files for a task")
+  val fileInputs = settingKey[Seq[Glob]](
+    "The file globs that are used by a task. This setting will generally be scoped per task. It will also be used to determine the sources to watch during continuous execution."
+  )
+  val fileInputIncludeFilter =
+    settingKey[PathFilter]("A filter to apply to the input sources of a task.")
+  val fileInputExcludeFilter =
+    settingKey[PathFilter]("An exclusion filter to apply to the input sources of a task.")
+  val inputFileStamper = settingKey[FileStamper](
+    "Toggles the file stamping implementation used to determine whether or not a file has been modified."
+  )
+
+  val fileOutputs = settingKey[Seq[Glob]]("Describes the output files of a task.")
+  val fileOutputIncludeFilter =
+    settingKey[PathFilter]("A filter to apply to the outputs of a task.")
+  val fileOutputExcludeFilter =
+    settingKey[PathFilter]("An exclusion filter to apply to the outputs of a task.")
+  val allOutputFiles =
+    taskKey[Seq[Path]]("All of the file outputs for a task excluding directories and hidden files.")
+  val changedOutputFiles =
+    taskKey[Seq[(Path, FileStamp)] => FileChanges](
+      "The files that have changed since the last task run."
+    )
+  val outputFileStamper = settingKey[FileStamper](
+    "Toggles the file stamping implementation used to determine whether or not a file has been modified."
+  )
+
+  val fileTreeView =
+    taskKey[FileTreeView.Nio[FileAttributes]]("A view of the local file system tree")
+
+  val checkBuildSources =
+    taskKey[StateTransform]("Check if any meta build sources have changed").withRank(DSetting)
+
+  // watch related settings
+  val watchAntiEntropyRetentionPeriod = settingKey[FiniteDuration](
+    "Wall clock Duration for which a FileEventMonitor will store anti-entropy events. This prevents spurious triggers when a task takes a long time to run. Higher values will consume more memory but make spurious triggers less likely."
+  ).withRank(BMinusSetting)
+  val watchAntiEntropyPollPeriod = settingKey[FiniteDuration](
+    "The duration for which sbt will poll for file events during the window in which sbt is buffering file events"
+  )
+  val onChangedBuildSource = settingKey[WatchBuildSourceOption](
+    "Determines what to do if the sbt meta build sources have changed"
+  ).withRank(DSetting)
+
+  val watchDeletionQuarantinePeriod = settingKey[FiniteDuration](
+    "Period for which deletion events will be quarantined. This is to prevent spurious builds when a file is updated with a rename which manifests as a file deletion followed by a file creation. The higher this value is set, the longer the delay will be between a file deletion and a build trigger but the less likely it is for a spurious trigger."
+  ).withRank(DSetting)
+  private[this] val forceTriggerOnAnyChangeMessage =
+    "Force the watch process to rerun the current task(s) if any relevant source change is " +
+      "detected regardless of whether or not the underlying file has actually changed."
+
+  // watch related keys
+  val watchBeforeCommand = settingKey[() => Unit](
+    "Function to run prior to running a command in a continuous build."
+  ).withRank(DSetting)
+  val watchForceTriggerOnAnyChange =
+    Def.settingKey[Boolean](forceTriggerOnAnyChangeMessage).withRank(DSetting)
+  private[sbt] val watchInputHandler = settingKey[InputStream => Watch.Action](
+    "Function that is periodically invoked to determine if the continuous build should be stopped or if a build should be triggered. It will usually read from stdin to respond to user commands. This is only invoked if watchInputStream is set."
+  ).withRank(DSetting)
+  val watchInputOptionsMessage = settingKey[String]("The help message for the watch input options")
+  val watchInputOptions = settingKey[Seq[Watch.InputOption]]("The available input options")
+  val watchInputStream = taskKey[InputStream](
+    "The input stream to read for user input events. This will usually be System.in"
+  ).withRank(DSetting)
+  val watchInputParser = settingKey[Parser[Watch.Action]](
+    "A parser of user input that can be used to trigger or exit a continuous build"
+  ).withRank(DSetting)
+  val watchLogLevel =
+    settingKey[sbt.util.Level.Value]("Transform the default logger in continuous builds.")
+      .withRank(DSetting)
+  val watchOnFileInputEvent = settingKey[(Int, Watch.Event) => Watch.Action](
+    "Callback to invoke if an event is triggered in a continuous build by one of the files matching an fileInput glob for the task and its transitive dependencies"
+  ).withRank(DSetting)
+  val watchOnIteration = settingKey[(Int, ProjectRef, Seq[String]) => Watch.Action](
+    "Function that is invoked before waiting for file system events or user input events."
+  ).withRank(DSetting)
+  val watchOnTermination = settingKey[(Watch.Action, String, Int, State) => State](
+    "Transforms the state upon completion of a watch. The String argument is the command that was run during the watch. The Int parameter specifies how many times the command was run during the watch."
+  ).withRank(DSetting)
+  val watchPersistFileStamps = settingKey[Boolean](
+    "Toggles whether or not the continuous build will reuse the file stamps computed in previous runs. Setting this to true decrease watch startup latency but could cause inconsistent results if many source files are concurrently modified."
+  ).withRank(DSetting)
+  val watchStartMessage = settingKey[(Int, ProjectRef, Seq[String]) => Option[String]](
+    "The message to show when triggered execution waits for sources to change. The parameters are the current watch iteration count, the current project name and the tasks that are being run with each build."
+  ).withRank(DSetting)
+  // The watchTasks key should really be named watch, but that is already taken by the deprecated watch key. I'd be surprised if there are any plugins that use it so I think we should consider breaking binary compatibility to rename this task.
+  @deprecated("The watch input task no longer has any effect.", "1.4.0")
+  val watchTasks = InputKey[StateTransform](
+    "watch",
+    "Watch a task (or multiple tasks) and rebuild when its file inputs change or user input is received. The semantics are more or less the same as the `~` command except that it cannot transform the state on exit. This means that it cannot be used to reload the build."
+  ).withRank(DSetting)
+  val watchTriggers =
+    settingKey[Seq[Glob]]("Describes files that should trigger a new continuous build.")
+
+  /**
+   * Sets the message to display after a new build is triggered. By default,
+   * it prints the file that triggered the build and what command(s) will be run.
+   * To clear the screen, add
+   * {{{
+   *   watchTriggeredMessage := Watch.clearScreenOnTrigger
+   * }}}
+   * to the build.
+   *
+   */
+  val watchTriggeredMessage = settingKey[(Int, Path, Seq[String]) => Option[String]](
+    "The message to show before triggered execution executes an action after sources change. The parameters are the current watch iteration count, the path that triggered the build and the names of the commands to run."
+  ).withRank(DSetting)
+
+  // internal keys
+  private[sbt] val globalFileTreeRepository = AttributeKey[FileTreeRepository[FileAttributes]](
+    "global-file-tree-repository",
+    "Provides a view into the file system that may or may not cache the tree in memory",
+    Int.MaxValue
+  )
+  private[sbt] val dynamicDependency = settingKey[Unit](
+    "Leaves a breadcrumb that the scoped task is evaluated inside of a dynamic task"
+  ).withRank(Invisible)
+  private[sbt] val transitiveClasspathDependency = settingKey[Unit](
+    "Leaves a breadcrumb that the scoped task has transitive classpath dependencies"
+  ).withRank(Invisible)
+  private[sbt] val transitiveDynamicInputs =
+    taskKey[Seq[DynamicInput]]("The transitive inputs and triggers for a key").withRank(Invisible)
+  private[sbt] val dynamicFileOutputs =
+    taskKey[Seq[Path]]("The outputs of a task").withRank(Invisible)
+
+  val inputFileStamps =
+    taskKey[Seq[(Path, FileStamp)]]("Retrieves the hashes for a set of task input files")
+      .withRank(Invisible)
+  val outputFileStamps =
+    taskKey[Seq[(Path, FileStamp)]]("Retrieves the hashes for a set of task output files")
+      .withRank(Invisible)
+  private[sbt] type FileAttributeMap =
+    java.util.Map[Path, FileStamp]
+  private[sbt] val persistentFileStampCache =
+    AttributeKey[FileStamp.Cache]("persistent-file-stamp-cache", Int.MaxValue)
+  private[sbt] val allInputPathsAndAttributes =
+    taskKey[Seq[(Path, FileAttributes)]]("Get all of the file inputs for a task")
+      .withRank(Invisible)
+  private[sbt] val unmanagedFileStampCache = taskKey[FileStamp.Cache](
+    "Map of managed file stamps that may be cleared between task evaluation runs."
+  ).withRank(Invisible)
+  private[sbt] val managedFileStampCache = taskKey[FileStamp.Cache](
+    "Map of managed file stamps that may be cleared between task evaluation runs."
+  ).withRank(Invisible)
+  private[sbt] val managedSourcePaths =
+    taskKey[Seq[Path]]("Transforms the managedSources to Seq[Path] to induce setting injection.")
+      .withRank(Invisible)
+  private[sbt] val dependencyClasspathFiles =
+    taskKey[Seq[Path]]("The dependency classpath for a task.").withRank(Invisible)
+  private[sbt] val compileOutputs = taskKey[Seq[Path]]("Compilation outputs").withRank(Invisible)
+
+  private[this] val hasCheckedMetaBuildMsg =
+    "Indicates whether or not we have called the checkBuildSources task. This is to avoid warning " +
+      "user about build source changes if the build sources were changed while sbt was shutdown. " +
+      " When that occurs, the previous cache reflects the state of the old build files, but by " +
+      " the time the checkBuildSources task has run, the build will have already been loaded with the " +
+      " new meta build sources so we should neither warn the user nor automatically restart the build"
+  private[sbt] val hasCheckedMetaBuild =
+    AttributeKey[AtomicBoolean]("has-checked-meta-build", hasCheckedMetaBuildMsg, Int.MaxValue)
+}
diff --git a/main/src/main/scala/sbt/nio/Settings.scala b/main/src/main/scala/sbt/nio/Settings.scala
new file mode 100644
index 000000000..3f78649af
--- /dev/null
+++ b/main/src/main/scala/sbt/nio/Settings.scala
@@ -0,0 +1,362 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package nio
+
+import java.nio.file.{ Files, Path }
+import java.util.concurrent.ConcurrentHashMap
+
+import sbt.Keys._
+import sbt.internal.Clean.ToSeqPath
+import sbt.internal.Continuous.FileStampRepository
+import sbt.internal.util.AttributeKey
+import sbt.internal.{ Clean, Continuous, DynamicInput, WatchTransitiveDependencies }
+import sbt.nio.FileStamp.Formats._
+import sbt.nio.FileStamper.{ Hash, LastModified }
+import sbt.nio.Keys._
+import sbt.nio.file.{ AllPass, FileAttributes, Glob, RecursiveGlob }
+import sbt.std.TaskExtra._
+import sjsonnew.JsonFormat
+
+import scala.annotation.nowarn
+import scala.collection.immutable.VectorBuilder
+
+private[sbt] object Settings {
+  private[sbt] def inject(transformed: Seq[Def.Setting[_]]): Seq[Def.Setting[_]] = {
+    val definedSettings = new java.util.HashMap[Def.ScopedKey[_], VectorBuilder[Def.Setting[_]]]
+    val fileOutputScopes = transformed.flatMap { s =>
+      val list = new VectorBuilder[Def.Setting[_]]
+      definedSettings.putIfAbsent(s.key, list) match {
+        case null => list += s
+        case l    => l += s
+      }
+      if (s.key.key == fileOutputs.key && s.key.scope.task.toOption.isDefined) Some(s.key.scope)
+      else None
+    }.toSet
+    transformed.flatMap { s =>
+      val inject =
+        if (s.key.key == fileInputs.key) inputPathSettings(s)
+        else maybeAddOutputsAndFileStamps(s, fileOutputScopes)
+      s +: inject.flatMap { setting =>
+        (definedSettings.get(setting.key) match {
+          case null => Vector(setting)
+          case set  => setting +: set.result()
+        }): Seq[Def.Setting[_]]
+      }
+    }
+  }
+
+  /**
+   * This method checks if the setting is for a task with a return type in:
+   * `File`, `Seq[File]`, `Path`, `Seq[Path`. If it does, then we inject a number of
+   * task definition settings that allow the user to check if the output paths of
+   * the task have changed. It also adds a custom clean task that will delete the
+   * paths returned by the task, provided that they are in the task's target directory. We also
+   * inject these tasks if the fileOutputs setting is defined for the task.
+   *
+   * @param setting the setting to possibly inject with additional settings
+   * @param fileOutputScopes the set of scopes for which the fileOutputs setting is defined
+   * @return the injected settings
+   */
+  @nowarn
+  private[this] def maybeAddOutputsAndFileStamps(
+      setting: Def.Setting[_],
+      fileOutputScopes: Set[Scope]
+  ): List[Def.Setting[_]] = {
+    setting.key.key match {
+      case ak: AttributeKey[_] if taskClass.isAssignableFrom(ak.manifest.runtimeClass) =>
+        def default: List[Def.Setting[_]] = {
+          val scope = setting.key.scope.copy(task = Select(ak))
+          if (fileOutputScopes.contains(scope)) {
+            val sk = setting.asInstanceOf[Def.Setting[Task[Any]]].key
+            val scopedKey = Keys.dynamicFileOutputs in (sk.scope in sk.key)
+            addTaskDefinition {
+              val init: Def.Initialize[Task[Seq[Path]]] = sk(_.map(_ => Nil))
+              Def.setting[Task[Seq[Path]]](scopedKey, init, setting.pos)
+            } :: allOutputPathsImpl(scope) :: outputFileStampsImpl(scope) :: cleanImpl(scope) :: Nil
+          } else Nil
+        }
+        def mkSetting[T: JsonFormat: ToSeqPath]: List[Def.Setting[_]] = {
+          val sk = setting.asInstanceOf[Def.Setting[Task[T]]].key
+          val taskKey = TaskKey(sk.key) in sk.scope
+          // We create a previous reference so that clean automatically works without the
+          // user having to explicitly call previous anywhere.
+          val init = Previous.runtime(taskKey).zip(taskKey) {
+            case (_, t) => t.map(implicitly[ToSeqPath[T]].apply)
+          }
+          val key = Def.ScopedKey(taskKey.scope in taskKey.key, Keys.dynamicFileOutputs.key)
+          addTaskDefinition(Def.setting[Task[Seq[Path]]](key, init, setting.pos)) ::
+            outputsAndStamps(taskKey)
+        }
+        ak.manifest.typeArguments match {
+          case t :: Nil if seqClass.isAssignableFrom(t.runtimeClass) =>
+            t.typeArguments match {
+              case p :: Nil if pathClass.isAssignableFrom(p.runtimeClass) => mkSetting[Seq[Path]]
+              case _                                                      => default
+            }
+          case t :: Nil if pathClass.isAssignableFrom(t.runtimeClass) => mkSetting[Path]
+          case _                                                      => default
+        }
+      case _ => Nil
+    }
+  }
+
+  @nowarn
+  private[sbt] val inject: Def.ScopedKey[_] => Seq[Def.Setting[_]] = scopedKey =>
+    scopedKey.key match {
+      case transitiveDynamicInputs.key =>
+        scopedKey.scope.task.toOption.toSeq.map { key =>
+          val updatedKey = Def.ScopedKey(scopedKey.scope.copy(task = Zero), key)
+          transitiveDynamicInputs in scopedKey.scope :=
+            WatchTransitiveDependencies.task(updatedKey).value
+        }
+      case dynamicDependency.key => (dynamicDependency in scopedKey.scope := { () }) :: Nil
+      case transitiveClasspathDependency.key =>
+        (transitiveClasspathDependency in scopedKey.scope := { () }) :: Nil
+      case _ => Nil
+    }
+
+  /**
+   * This adds the [[taskDefinitionKey]] to the work for each [[Task]]. Without
+   * this, the previous macro doesn't work correctly because [[Previous]] is unable to
+   * reference the task.
+   *
+   * @param setting the [[Def.Setting[_}]] for which we add the task definition
+   * @tparam T the generic type of the task (needed for type checking because [[Task]] is invariant)
+   * @return the setting with the task definition
+   */
+  private[this] def addTaskDefinition[T](setting: Def.Setting[Task[T]]): Def.Setting[Task[T]] =
+    setting.mapInit((sk, task) => Task(task.info.set(taskDefinitionKey, sk), task.work))
+
+  /**
+   * Returns all of the paths described by a glob along with their basic file attributes.
+   * No additional filtering is performed.
+   *
+   * @param setting the setting whose fileInputs we are seeking
+   * @return a task definition that retrieves the file input files and their attributes scoped
+   *         to a particular task.
+   */
+  @nowarn
+  private[sbt] def inputPathSettings(setting: Def.Setting[_]): Seq[Def.Setting[_]] = {
+    val scopedKey = setting.key
+    val scope = scopedKey.scope
+    (Keys.allInputPathsAndAttributes in scope := {
+      val view = (fileTreeView in scope).value
+      val inputs = (fileInputs in scope).value
+      val stamper = (inputFileStamper in scope).value
+      val forceTrigger = (watchForceTriggerOnAnyChange in scope).value
+      val dynamicInputs = (Continuous.dynamicInputs in scope).value
+      // This makes watch work by ensuring that the input glob is registered with the
+      // repository used by the watch process.
+      state.value.get(globalFileTreeRepository).foreach { repo =>
+        inputs.foreach(repo.register(_).foreach(_.close()))
+      }
+      dynamicInputs.foreach(_ ++= inputs.map(g => DynamicInput(g, stamper, forceTrigger)))
+      view.list(inputs)
+    }) :: fileStamps(scopedKey) :: allFilesImpl(scope) :: changedInputFilesImpl(scope)
+  }
+
+  private[this] val taskClass = classOf[Task[_]]
+  private[this] val seqClass = classOf[Seq[_]]
+  private[this] val pathClass = classOf[java.nio.file.Path]
+
+  /**
+   * Returns all of the paths for the regular files described by a glob. Directories and hidden
+   * files are excluded.
+   *
+   * @param scope the key whose file inputs we are seeking
+   * @return a task definition that retrieves all of the input paths scoped to the input key.
+   */
+  @nowarn
+  private[this] def allFilesImpl(scope: Scope): Def.Setting[_] = {
+    addTaskDefinition(Keys.allInputFiles in scope := {
+      val filter =
+        (fileInputIncludeFilter in scope).value && !(fileInputExcludeFilter in scope).value
+      (Keys.allInputPathsAndAttributes in scope).value.collect {
+        case (p, a) if filter.accept(p, a) => p
+      }
+    })
+  }
+
+  /**
+   * Returns all of the regular files whose stamp has changed since the last time the
+   * task was evaluated. The result includes new and modified files but not deleted
+   * files or files whose stamp has not changed since the previous run. Directories and hidden
+   * files are excluded
+   *
+   * @param scope the scope corresponding to the task whose fileInputs we are seeking
+   * @return a task definition that retrieves the changed input files scoped to the key.
+   */
+  @nowarn
+  private[this] def changedInputFilesImpl(scope: Scope): List[Def.Setting[_]] =
+    changedFilesImpl(scope, changedInputFiles, inputFileStamps) ::
+      (watchForceTriggerOnAnyChange in scope := {
+        (watchForceTriggerOnAnyChange in scope).?.value match {
+          case Some(t) => t
+          case None    => false
+        }
+      }) :: Nil
+
+  @nowarn
+  private[this] def changedFilesImpl(
+      scope: Scope,
+      changeKey: TaskKey[Seq[(Path, FileStamp)] => FileChanges],
+      stampKey: TaskKey[Seq[(Path, FileStamp)]]
+  ): Def.Setting[_] =
+    addTaskDefinition(changeKey in scope := {
+      val current = (stampKey in scope).value
+      changedFiles(_, current)
+    })
+  private[sbt] def changedFiles(
+      previous: Seq[(Path, FileStamp)],
+      current: Seq[(Path, FileStamp)]
+  ): FileChanges = {
+    val createdBuilder = new VectorBuilder[Path]
+    val deletedBuilder = new VectorBuilder[Path]
+    val modifiedBuilder = new VectorBuilder[Path]
+    val unmodifiedBuilder = new VectorBuilder[Path]
+    val seen = ConcurrentHashMap.newKeySet[Path]
+    val prevMap = new ConcurrentHashMap[Path, FileStamp]()
+    previous.foreach { case (k, v) => prevMap.put(k, v); () }
+    current.foreach {
+      case (path, currentStamp) =>
+        if (seen.add(path)) {
+          prevMap.remove(path) match {
+            case null => createdBuilder += path
+            case old  => (if (old != currentStamp) modifiedBuilder else unmodifiedBuilder) += path
+          }
+        }
+    }
+    prevMap.forEach((p, _) => deletedBuilder += p)
+    val unmodified = unmodifiedBuilder.result()
+    val deleted = deletedBuilder.result()
+    val created = createdBuilder.result()
+    val modified = modifiedBuilder.result()
+    if (created.isEmpty && deleted.isEmpty && modified.isEmpty) {
+      FileChanges.unmodified(unmodifiedBuilder.result)
+    } else {
+      FileChanges(created, deleted, modified, unmodified)
+    }
+  }
+
+  /**
+   * Provides an automatically generated clean method for a task that provides fileOutputs.
+   *
+   * @param scope the scope to add the custom clean
+   * @return a task specific clean implementation
+   */
+  @nowarn
+  private[sbt] def cleanImpl(scope: Scope): Def.Setting[_] = addTaskDefinition {
+    sbt.Keys.clean in scope := Clean.task(scope, full = false).value
+  }
+
+  /**
+   * Provides an automatically generated clean method for a task that provides fileOutputs.
+   *
+   * @param taskKey the task for which we add a custom clean implementation
+   * @return a task specificic clean implementation
+   */
+  @nowarn
+  private[sbt] def cleanImpl[T: JsonFormat: ToSeqPath](taskKey: TaskKey[T]): Def.Setting[_] = {
+    val taskScope = taskKey.scope in taskKey.key
+    addTaskDefinition(sbt.Keys.clean in taskScope := Def.taskDyn {
+      // the clean file task needs to run first because the previous cache gets blown away
+      // by the second task
+      Def.unit(Clean.cleanFileOutputTask(taskKey).value)
+      Clean.task(taskScope, full = false)
+    }.value)
+  }
+
+  /**
+   * Returns all of the regular files and the corresponding file stamps for the file inputs
+   * scoped to the input key. Directories and hidden files are excluded.
+   *
+   * @param scopedKey the key whose fileInputs we are seeking
+   * @return a task definition that retrieves the input files and their file stamps scoped to the
+   *         input key.
+   */
+  @nowarn
+  private[sbt] def fileStamps(scopedKey: Def.ScopedKey[_]): Def.Setting[_] = {
+    import sbt.internal.CompatParColls.Converters._
+    val scope = scopedKey.scope
+    addTaskDefinition(Keys.inputFileStamps in scope := {
+      val cache = (unmanagedFileStampCache in scope).value
+      val stamper = (Keys.inputFileStamper in scope).value
+      val stampFile: Path => Option[(Path, FileStamp)] =
+        state.value.get(globalFileTreeRepository) match {
+          case Some(repo: FileStampRepository) =>
+            (path: Path) =>
+              repo.putIfAbsent(path, stamper) match {
+                case (None, Some(s)) =>
+                  cache.put(path, s)
+                  Some(path -> s)
+                case _ => cache.getOrElseUpdate(path, stamper).map(path -> _)
+              }
+          case _ =>
+            (path: Path) => cache.getOrElseUpdate(path, stamper).map(path -> _)
+        }
+      val filter =
+        (fileInputIncludeFilter in scope).value && !(fileInputExcludeFilter in scope).value
+      (Keys.allInputPathsAndAttributes in scope).value.par.flatMap {
+        case (path, a) if filter.accept(path, a) => stampFile(path)
+        case _                                   => None
+      }.toVector
+    })
+  }
+
+  @nowarn
+  private[this] def outputsAndStamps[T: JsonFormat: ToSeqPath](
+      taskKey: TaskKey[T]
+  ): List[Def.Setting[_]] = {
+    val scope = taskKey.scope in taskKey.key
+    val changes = changedFilesImpl(scope, changedOutputFiles, outputFileStamps) :: Nil
+    allOutputPathsImpl(scope) :: outputFileStampsImpl(scope) :: cleanImpl(taskKey) :: changes
+  }
+
+  @nowarn
+  private[this] def allOutputPathsImpl(scope: Scope): Def.Setting[_] =
+    addTaskDefinition(allOutputFiles in scope := {
+      val filter =
+        (fileOutputIncludeFilter in scope).value && !(fileOutputExcludeFilter in scope).value
+      val view = (fileTreeView in scope).value
+      val fileOutputGlobs = (fileOutputs in scope).value
+      val allFileOutputs = view.list(fileOutputGlobs).map(_._1)
+      val dynamicOutputs = (dynamicFileOutputs in scope).value
+      val allDynamicOutputs = dynamicOutputs.flatMap {
+        case p if Files.isDirectory(p) => p +: view.list(Glob(p, RecursiveGlob)).map(_._1)
+        case p                         => p :: Nil
+      }
+      /*
+       * We want to avoid computing the FileAttributes in the common case where nothing is
+       * being filtered (which is the case with the default filters:
+       * include = AllPass, exclude = NoPass).
+       */
+      val attributeFilter: Path => Boolean = filter match {
+        case AllPass => _ => true
+        case f       => p => FileAttributes(p).map(f.accept(p, _)).getOrElse(false)
+      }
+      allFileOutputs ++ allDynamicOutputs.filterNot { p =>
+        fileOutputGlobs.exists(_.matches(p)) || !attributeFilter(p)
+      }
+    })
+
+  @nowarn
+  private[this] def outputFileStampsImpl(scope: Scope): Def.Setting[_] =
+    addTaskDefinition(outputFileStamps in scope := {
+      val stamper: Path => Option[FileStamp] = (outputFileStamper in scope).value match {
+        case LastModified => FileStamp.lastModified
+        case Hash         => FileStamp.hash
+      }
+      val allFiles = (allOutputFiles in scope).value
+      // The cache invalidation is specifically so that source formatters can run before
+      // the compile task and the file stamps seen by compile match the post-format stamps.
+      allFiles.foreach((unmanagedFileStampCache in scope).value.invalidate)
+      allFiles.flatMap(p => stamper(p).map(p -> _))
+    })
+
+}
diff --git a/main/src/main/scala/sbt/nio/Watch.scala b/main/src/main/scala/sbt/nio/Watch.scala
new file mode 100644
index 000000000..0e235ed13
--- /dev/null
+++ b/main/src/main/scala/sbt/nio/Watch.scala
@@ -0,0 +1,628 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.nio
+
+import java.nio.file.Path
+import java.time.format.{ DateTimeFormatter, TextStyle }
+import java.time.{ Instant, ZoneId, ZonedDateTime }
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+
+import sbt.BasicCommandStrings.{ ContinuousExecutePrefix, TerminateAction }
+import sbt.SlashSyntax0._
+import sbt._
+import sbt.internal.LabeledFunctions._
+import sbt.internal.nio.FileEvent
+import sbt.internal.util.complete.Parser
+import sbt.internal.util.complete.Parser._
+import sbt.nio.Keys._
+import sbt.nio.file.FileAttributes
+import sbt.util.{ Level, Logger }
+
+import scala.annotation.tailrec
+import scala.collection.mutable
+import scala.concurrent.duration._
+import scala.util.control.NonFatal
+
+object Watch {
+
+  /**
+   * Represents a file event that has been detected during a continuous build.
+   */
+  sealed trait Event {
+
+    /**
+     * The path that triggered the event.
+     *
+     * @return the path that triggered the event.
+     */
+    def path: Path
+
+    /**
+     * The time specified in milliseconds from the epoch at which this event occurred.
+     *
+     * @return the time at which the event occurred.
+     */
+    def occurredAt: FiniteDuration
+  }
+  private[this] val formatter = DateTimeFormatter.ofPattern("yyyy-MMM-dd HH:mm:ss.SSS")
+  private[this] val timeZone = ZoneId.systemDefault
+  private[this] val timeZoneName = timeZone.getDisplayName(TextStyle.SHORT, Locale.getDefault)
+  private[this] implicit class DurationOps(val d: Duration) extends AnyVal {
+    def finite: FiniteDuration = d match {
+      case f: FiniteDuration => f
+      case _                 => new FiniteDuration(Long.MaxValue, TimeUnit.MILLISECONDS)
+    }
+    def toEpochString: String = {
+      val zdt = ZonedDateTime.ofInstant(Instant.ofEpochMilli(d.toMillis), timeZone)
+      s"${formatter.format(zdt)} $timeZoneName"
+    }
+  }
+  private[sbt] implicit class EventOps(val event: Event) extends AnyVal {
+    def toEpochString: String = event.occurredAt.toEpochString
+  }
+  private[sbt] object Event {
+    trait Impl { self: Event =>
+      private val name = self.getClass.getSimpleName
+      override def equals(o: Any): Boolean = o match {
+        case that: Event => this.path == that.path
+        case _           => false
+      }
+      override def hashCode: Int = path.hashCode
+      override def toString: String = s"$name($path)"
+    }
+    def fromIO(fileEvent: FileEvent[FileAttributes]): Watch.Event = fileEvent match {
+      case c @ FileEvent.Creation(p, _) => new Watch.Creation(p, c.occurredAt.value.finite)
+      case d @ FileEvent.Deletion(p, _) => new Watch.Deletion(p, d.occurredAt.value.finite)
+      case u @ FileEvent.Update(p, _, _) =>
+        new Watch.Update(p, u.occurredAt.value.finite)
+    }
+  }
+  final class Creation private[sbt] (
+      override val path: Path,
+      override val occurredAt: FiniteDuration
+  ) extends Event
+      with Event.Impl {
+    override def toString: String = s"Creation($path, ${occurredAt.toEpochString})"
+  }
+  object Creation {
+    def apply(event: FileEvent[FileAttributes]): Creation =
+      new Creation(event.path, event.occurredAt.value.finite)
+    def unapply(creation: Creation): Option[Path] = Some(creation.path)
+  }
+  final class Deletion private[sbt] (
+      override val path: Path,
+      override val occurredAt: FiniteDuration
+  ) extends Event
+      with Event.Impl {
+    override def toString: String = s"Deletion($path, ${occurredAt.toEpochString})"
+  }
+  object Deletion {
+    def apply(event: FileEvent[FileAttributes]): Deletion =
+      new Deletion(event.path, event.occurredAt.value.finite)
+    def unapply(deletion: Deletion): Option[Path] = Some(deletion.path)
+  }
+  final class Update private[sbt] (
+      override val path: Path,
+      override val occurredAt: FiniteDuration
+  ) extends Event
+      with Event.Impl {
+    override def toString: String = s"Update($path, ${occurredAt.toEpochString})"
+  }
+  object Update {
+    def apply(event: FileEvent[FileAttributes]): Update =
+      new Update(event.path, event.occurredAt.value.finite)
+    def unapply(update: Update): Option[Path] = Some(update.path)
+  }
+
+  /**
+   * This trait is used to control the state of Watch. The [[Watch.Trigger]] action
+   * indicates that Watch should re-run the input task. The [[Watch.CancelWatch]]
+   * actions indicate that Watch should exit and return the [[Watch.CancelWatch]]
+   * instance that caused the function to exit. The [[Watch.Ignore]] action is used to indicate
+   * that the method should keep polling for new actions.
+   */
+  sealed trait Action
+
+  /**
+   * Provides a default `Ordering` for actions. Lower values correspond to higher priority actions.
+   * [[CancelWatch]] is higher priority than [[ContinueWatch]].
+   */
+  object Action {
+    implicit object ordering extends Ordering[Action] {
+      override def compare(left: Action, right: Action): Int = (left, right) match {
+        case (a: ContinueWatch, b: ContinueWatch) => ContinueWatch.ordering.compare(a, b)
+        case (_: ContinueWatch, _: CancelWatch)   => 1
+        case (a: CancelWatch, b: CancelWatch)     => CancelWatch.ordering.compare(a, b)
+        case (_: CancelWatch, _: ContinueWatch)   => -1
+      }
+    }
+  }
+
+  /**
+   * Action that indicates that the watch should stop.
+   */
+  sealed trait CancelWatch extends Action
+
+  /**
+   * Action that does not terminate the watch but might trigger a build.
+   */
+  sealed trait ContinueWatch extends Action
+
+  /**
+   * Provides a default `Ordering` for classes extending [[ContinueWatch]]. [[Trigger]] is higher
+   * priority than [[Ignore]].
+   */
+  object ContinueWatch {
+
+    /**
+     * A default `Ordering` for [[ContinueWatch]]. [[Trigger]] is higher priority than [[Ignore]].
+     */
+    implicit object ordering extends Ordering[ContinueWatch] {
+      override def compare(left: ContinueWatch, right: ContinueWatch): Int = left match {
+        case ShowOptions => if (right == ShowOptions) 0 else -1
+        case Ignore      => if (right == Ignore) 0 else 1
+        case Trigger     => if (right == Trigger) 0 else if (right == ShowOptions) 1 else -1
+      }
+    }
+  }
+
+  /**
+   * Action that indicates that the watch should stop.
+   */
+  case object CancelWatch extends CancelWatch {
+
+    /**
+     * A default `Ordering` for [[ContinueWatch]]. The priority of each type of [[CancelWatch]]
+     * is reflected by the ordering of the case statements in the [[ordering.compare]] method,
+     * e.g. [[Custom]] is higher priority than [[HandleError]].
+     */
+    implicit object ordering extends Ordering[CancelWatch] {
+      override def compare(left: CancelWatch, right: CancelWatch): Int = left match {
+        // Note that a negative return value means the left CancelWatch is preferred to the right
+        // CancelWatch while the inverse is true for a positive return value. This logic could
+        // likely be simplified, but the pattern matching approach makes it very clear what happens
+        // for each type of Action.
+        case _: Custom =>
+          right match {
+            case _: Custom => 0
+            case _         => -1
+          }
+        case _: HandleError =>
+          right match {
+            case _: Custom      => 1
+            case _: HandleError => 0
+            case _              => -1
+          }
+        case Prompt =>
+          right match {
+            case Prompt                          => 0
+            case CancelWatch | Reload | (_: Run) => -1
+            case _                               => 1
+          }
+        case _: Run =>
+          right match {
+            case _: Run               => 0
+            case CancelWatch | Reload => -1
+            case _                    => 1
+          }
+        case CancelWatch =>
+          right match {
+            case CancelWatch => 0
+            case Reload      => -1
+            case _           => 1
+          }
+        case Reload => if (right == Reload) 0 else 1
+      }
+    }
+  }
+
+  /**
+   * Action that indicates that an error has occurred. The watch will be terminated when this action
+   * is produced.
+   */
+  sealed class HandleError(val throwable: Throwable) extends CancelWatch {
+    override def equals(o: Any): Boolean = o match {
+      case that: HandleError => this.throwable == that.throwable
+      case _                 => false
+    }
+    override def hashCode: Int = throwable.hashCode
+    override def toString: String = s"HandleError($throwable)"
+  }
+  object HandleError {
+    def unapply(h: HandleError): Option[Throwable] = Some(h.throwable)
+  }
+
+  /**
+   * Action that indicates that an error has occurred. The watch will be terminated when this action
+   * is produced.
+   */
+  private[sbt] final class HandleUnexpectedError(override val throwable: Throwable)
+      extends HandleError(throwable) {
+    override def toString: String = s"HandleUnexpectedError($throwable)"
+  }
+  object HandleUnexpectedError {
+    def unapply(h: HandleUnexpectedError): Option[Throwable] = Some(h.throwable)
+  }
+
+  /**
+   * Action that indicates that the watch should continue as though nothing happened. This may be
+   * because, for example, no user input was yet available. This trait can be used when we don't
+   * want to take action but we do want to perform a side effect like printing options to the
+   * terminal.
+   */
+  sealed trait Ignore extends ContinueWatch
+
+  /**
+   * Action that indicates that the available options should be printed.
+   */
+  case object ShowOptions extends Ignore
+
+  /**
+   * Action that indicates that the watch should continue as though nothing happened. This may be
+   * because, for example, no user input was yet available.
+   */
+  case object Ignore extends Ignore
+
+  /**
+   * Action that indicates that the watch should pause while the build is reloaded. This is used to
+   * automatically reload the project when the build files (e.g. build.sbt) are changed.
+   */
+  case object Reload extends CancelWatch
+
+  /**
+   * Action that indicates that we should exit and run the provided command.
+   *
+   * @param commands the commands to run after we exit the watch
+   */
+  final class Run(val commands: String*) extends CancelWatch {
+    override def toString: String = s"Run(${commands.mkString(", ")})"
+  }
+  // For now leave this private in case this isn't the best unapply type signature since it can't
+  // be evolved in a binary compatible way.
+  object Run {
+    def apply(commands: String*): Run = new Watch.Run(commands: _*)
+    def unapply(r: Run): Option[List[Exec]] = Some(r.commands.toList.map(Exec(_, None)))
+  }
+
+  case object Prompt extends CancelWatch
+
+  /**
+   * Action that indicates that the watch process should re-run the command.
+   */
+  case object Trigger extends ContinueWatch
+
+  /**
+   * A user defined Action. It is not sealed so that the user can create custom instances. If
+   * the onStart or nextAction function passed into Watch returns [[Watch.Custom]], then
+   * the watch will terminate.
+   */
+  trait Custom extends CancelWatch
+
+  trait InputOption {
+    private[sbt] def parser: Parser[Watch.Action]
+    def input: String
+    def display: String
+    def description: String
+    override def toString: String =
+      s"InputOption(input = $input, display = $display, description = $description)"
+  }
+  object InputOption {
+    private class impl(
+        override val input: String,
+        override val display: String,
+        override val description: String,
+        action: Action
+    ) extends InputOption {
+      override private[sbt] def parser: Parser[Watch.Action] = input ^^^ action
+    }
+    def apply(key: Char, description: String, action: Action): InputOption =
+      new impl(key.toString, s"'$key'", description, action)
+    def apply(key: Char, display: String, description: String, action: Action): InputOption =
+      new impl(key.toString, display, description, action)
+    def apply(
+        display: String,
+        description: String,
+        action: Action,
+        chars: Char*
+    ): InputOption =
+      new impl(chars.mkString("|"), display, description, action) {
+        override private[sbt] def parser: Parser[Watch.Action] = chars match {
+          case Seq(c)            => c ^^^ action
+          case Seq(h, rest @ _*) => rest.foldLeft(h: Parser[Char])(_ | _) ^^^ action
+        }
+      }
+    def apply(input: String, description: String, action: Action): InputOption =
+      new impl(input, s"'$input'", description, action)
+    def apply(input: String, display: String, description: String, action: Action): InputOption =
+      new impl(input, display, description, action)
+  }
+
+  private type NextAction = Int => Watch.Action
+
+  @deprecated(
+    "Unused in sbt but left for binary compatibility. Use five argument version instead.",
+    "1.4.0"
+  )
+  def apply(
+      task: () => Unit,
+      onStart: () => Watch.Action,
+      nextAction: () => Watch.Action,
+  ): Watch.Action = apply(0, _ => task(), _ => onStart(), _ => nextAction(), recursive = true)
+
+  /**
+   * Runs a task and then blocks until the task is ready to run again or we no longer wish to
+   * block execution.
+   *
+   * @param task the aggregated task to run with each iteration
+   * @param onStart function to be invoked before we start polling for events
+   * @param nextAction function that returns the next state transition [[Watch.Action]].
+   * @return the exit [[Watch.Action]] that can be used to potentially modify the build state and
+   *         the count of the number of iterations that were run. If
+   */
+  def apply(
+      initialCount: Int,
+      task: Int => Unit,
+      onStart: NextAction,
+      nextAction: NextAction,
+      recursive: Boolean
+  ): Watch.Action = {
+    def safeNextAction(count: Int, delegate: NextAction): Watch.Action =
+      try delegate(count)
+      catch {
+        case NonFatal(t) =>
+          System.err.println(s"Watch caught unexpected error:")
+          t.printStackTrace(System.err)
+          new HandleError(t)
+      }
+    @tailrec def next(count: Int): Watch.Action = safeNextAction(count, nextAction) match {
+      // This should never return Ignore due to this condition.
+      case Ignore => next(count)
+      case action => action
+    }
+    @tailrec def impl(count: Int): Watch.Action = {
+      task(count)
+      safeNextAction(count, onStart) match {
+        case Ignore =>
+          next(count) match {
+            case Trigger =>
+              if (recursive) impl(count + 1)
+              else {
+                task(count)
+                Watch.Trigger
+              }
+            case action => action
+          }
+        case Trigger =>
+          if (recursive) impl(count + 1)
+          else {
+            task(count)
+            Watch.Trigger
+          }
+        case a => a
+      }
+    }
+    try impl(initialCount)
+    catch { case NonFatal(t) => new HandleError(t) }
+  }
+
+  private[sbt] object NullLogger extends Logger {
+    override def trace(t: => Throwable): Unit = {}
+    override def success(message: => String): Unit = {}
+    override def log(level: Level.Value, message: => String): Unit = {}
+  }
+
+  /**
+   * Traverse all of the events and find the one for which we give the highest
+   * weight. Within the [[Action]] hierarchy:
+   * [[Custom]] > [[HandleError]] > [[CancelWatch]] > [[Reload]] > [[Trigger]] > [[Ignore]]
+   * the first event of each kind is returned so long as there are no higher priority events
+   * in the collection. For example, if there are multiple events that all return [[Trigger]], then
+   * the first one is returned. If, on the other hand, one of the events returns [[Reload]],
+   * then that event "wins" and the [[Reload]] action is returned with the [[Event[FileAttributes]]] that triggered it.
+   *
+   * @param events the ([[Action]], [[Event[FileAttributes]]]) pairs
+   * @return the ([[Action]], [[Event[FileAttributes]]]) pair with highest weight if the input events
+   *         are non empty.
+   */
+  @inline
+  private[sbt] def aggregate(events: Seq[(Action, Event)]): Option[(Action, Event)] =
+    if (events.isEmpty) None else Some(events.minBy(_._1))
+
+  private implicit class StringToExec(val s: String) extends AnyVal {
+    def toExec: Exec = Exec(s, None)
+  }
+
+  /**
+   * A constant function that returns [[Trigger]].
+   */
+  final val trigger: (Int, Event) => Watch.Action = { (_: Int, _: Event) =>
+    Trigger
+  }.label("Watched.trigger")
+
+  /**
+   * The minimum delay between build triggers for the same file. If the file is detected
+   * to have changed within this period from the last build trigger, the event will be discarded.
+   */
+  final val defaultAntiEntropy: FiniteDuration = 500.milliseconds
+
+  /**
+   * The duration for which we will poll for new file events when we are buffering events
+   * after an initial event has been detected to avoid spurious rebuilds.
+   *
+   * If this value is ever updated, please update the comment in Continuous.getFileEvents.
+   */
+  final val defaultAntiEntropyPollPeriod: FiniteDuration = 5.milliseconds
+
+  /**
+   * The duration in wall clock time for which a FileEventMonitor will retain anti-entropy
+   * events for files. This is an implementation detail of the FileEventMonitor. It should
+   * hopefully not need to be set by the users. It is needed because when a task takes a long time
+   * to run, it is possible that events will be detected for the file that triggered the build that
+   * occur within the anti-entropy period. We still allow it to be configured to limit the memory
+   * usage of the FileEventMonitor (but this is somewhat unlikely to be a problem).
+   */
+  final val defaultAntiEntropyRetentionPeriod: FiniteDuration = 10.minutes
+
+  /**
+   * The duration for which we delay triggering when a file is deleted. This is needed because
+   * many programs implement save as a file move of a temporary file onto the target file.
+   * Depending on how the move is implemented, this may be detected as a deletion immediately
+   * followed by a creation. If we trigger immediately on delete, we may, for example, try to
+   * compile before all of the source files are actually available. The longer this value is set,
+   * the less likely we are to spuriously trigger a build before all files are available, but
+   * the longer it will take to trigger a build when the file is actually deleted and not renamed.
+   */
+  final val defaultDeletionQuarantinePeriod: FiniteDuration = 50.milliseconds
+
+  /**
+   * Converts user input to an Action with the following rules:
+   * 1) 'x' or 'X' will exit sbt
+   * 2) 'r' or 'R' will trigger a build
+   * 3) new line characters cancel the watch and return to the shell
+   */
+  final def defaultInputParser(options: Seq[Watch.InputOption]): Parser[Action] =
+    distinctOptions(options) match {
+      case Seq()             => (('\n': Parser[Char]) | '\r' | 4.toChar) ^^^ Run("")
+      case Seq(h, rest @ _*) => rest.foldLeft(h.parser)(_ | _.parser)
+    }
+  final val defaultInputOptions: Seq[Watch.InputOption] = Seq(
+    Watch.InputOption("<enter>", "interrupt (exits sbt in batch mode)", CancelWatch, '\n', '\r'),
+    Watch.InputOption(4.toChar, "<ctrl-d>", "interrupt (exits sbt in batch mode)", CancelWatch),
+    Watch.InputOption('l', "reload the build", Reload),
+    Watch.InputOption('r', "re-run the command", Trigger),
+    Watch.InputOption('s', "return to shell", Prompt),
+    Watch.InputOption('q', "quit sbt", Run(TerminateAction)),
+    Watch.InputOption('?', "print options", ShowOptions)
+  )
+
+  def defaultInputOptionsMessage(options: Seq[InputOption]): String = {
+    val opts = distinctOptions(options).sortBy(_.input)
+    val alignmentLength = opts.map(_.display.length).max + 1
+    val formatted =
+      opts.map(o => s"${o.display}${" " * (alignmentLength - o.display.length)}: ${o.description}")
+    s"Options:\n${formatted.mkString("  ", "\n  ", "")}"
+  }
+  private def distinctOptions(options: Seq[InputOption]): Seq[InputOption] = {
+    val distinctOpts = mutable.Set.empty[String]
+    val opts = new mutable.ArrayBuffer[InputOption]
+    (options match {
+      case Seq() => defaultInputOptions.headOption.toSeq
+      case s     => s
+    }).reverse.foreach { o =>
+      if (distinctOpts.add(o.input)) opts += o
+    }
+    opts.toSeq.reverse
+  }
+  private def waitMessage(project: ProjectRef, commands: Seq[String]): Seq[String] = {
+    val cmds = commands.map(project.project + "/" + _.trim).mkString("; ")
+    Seq(
+      s"Monitoring source files for $cmds...",
+      s"Press <enter> to interrupt or '?' for more options."
+    )
+  }
+
+  /**
+   * A function that prints out the current iteration count and gives instructions for exiting
+   * or triggering the build.
+   */
+  val defaultStartWatch: (Int, ProjectRef, Seq[String]) => Option[String] = {
+    (count: Int, project: ProjectRef, commands: Seq[String]) =>
+      {
+        val countStr = s"$count. "
+        Some(s"$countStr${waitMessage(project, commands).mkString(s"\n${" " * countStr.length}")}")
+      }
+  }.label("Watched.defaultStartWatch")
+
+  /**
+   * Default no-op callback.
+   */
+  val defaultBeforeCommand: () => Unit = (() => {}).label("Watch.defaultBeforeCommand")
+
+  private[sbt] val defaultCommandOnTermination: (Action, String, Int, State) => State =
+    onTerminationImpl(ContinuousExecutePrefix).label("Watched.defaultCommandOnTermination")
+  private[sbt] val defaultTaskOnTermination: (Action, String, Int, State) => State =
+    onTerminationImpl("watch", ContinuousExecutePrefix)
+      .label("Watched.defaultTaskOnTermination")
+
+  /**
+   * Default handler to transform the state when the watch terminates. When the [[Watch.Action]]
+   * is [[Reload]], the handler will prepend the original command (prefixed by ~) to the
+   * [[State.remainingCommands]] and then invoke the [[StateOps.reload]] method. When the
+   * [[Watch.Action]] is [[HandleError]], the handler returns the result of [[StateOps.fail]].
+   * When the [[Watch.Action]] is [[Watch.Run]], we add the commands specified by
+   * [[Watch.Run.commands]] to the stat's remaining commands. Otherwise the original state is
+   * returned.
+   */
+  private def onTerminationImpl(
+      watchPrefixes: String*
+  ): (Action, String, Int, State) => State = { (action, command, count, state) =>
+    val prefix = watchPrefixes.head
+    val rc = state.remainingCommands
+      .filterNot(c => watchPrefixes.exists(c.commandLine.trim.startsWith))
+    action match {
+      case Run(commands) => state.copy(remainingCommands = commands ++ rc)
+      case Reload =>
+        state.copy(remainingCommands = "reload".toExec :: s"$prefix $count $command".toExec :: rc)
+      case _: HandleError => state.copy(remainingCommands = rc).fail
+      case _              => state.copy(remainingCommands = rc)
+    }
+  }
+
+  /**
+   * A constant function that always returns `None`. When
+   * `Keys.watchTriggeredMessage := Watched.defaultOnTriggerMessage`, then nothing is logged when
+   * a build is triggered.
+   */
+  final val defaultOnTriggerMessage: (Int, Path, Seq[String]) => Option[String] =
+    ((_: Int, path: Path, commands: Seq[String]) => {
+      val msg = s"Build triggered by $path. " +
+        s"Running ${commands.mkString("'", "; ", "'")}."
+      Some(msg)
+    }).label("Watched.defaultOnTriggerMessage")
+
+  final val noTriggerMessage: (Int, Path, Seq[String]) => Option[String] =
+    (_, _, _) => None
+
+  /**
+   * The minimum delay between file system polling when a `PollingWatchService` is used.
+   */
+  final val defaultPollInterval: FiniteDuration = 500.milliseconds
+
+  /**
+   * Clears the console screen when evaluated.
+   */
+  final val clearScreen: () => Unit =
+    (() => println("\u001b[2J\u001b[0;0H")).label("Watch.clearScreen")
+
+  /**
+   * A function that first clears the screen and then returns the default on trigger message.
+   */
+  final val clearScreenOnTrigger: (Int, Path, Seq[String]) => Option[String] = {
+    (count: Int, path: Path, commands: Seq[String]) =>
+      clearScreen()
+      defaultOnTriggerMessage(count, path, commands)
+  }.label("Watch.clearScreenOnTrigger")
+
+  private[sbt] def defaults: Seq[Def.Setting[_]] = Seq(
+    sbt.Keys.watchAntiEntropy :== Watch.defaultAntiEntropy,
+    watchAntiEntropyRetentionPeriod :== Watch.defaultAntiEntropyRetentionPeriod,
+    watchLogLevel :== Level.Info,
+    watchBeforeCommand :== Watch.defaultBeforeCommand,
+    watchOnFileInputEvent :== Watch.trigger,
+    watchDeletionQuarantinePeriod :== Watch.defaultDeletionQuarantinePeriod,
+    sbt.Keys.watchService :== Watched.newWatchService,
+    watchInputOptions :== Watch.defaultInputOptions,
+    watchStartMessage :== Watch.defaultStartWatch,
+    watchTriggeredMessage :== Watch.defaultOnTriggerMessage,
+    watchForceTriggerOnAnyChange :== false,
+    watchPersistFileStamps := (ThisBuild / sbt.Keys.turbo).value,
+    watchTriggers :== Nil,
+    watchAntiEntropyPollPeriod := Watch.defaultAntiEntropyPollPeriod,
+  )
+}
diff --git a/main/src/main/scala/sbt/plugins/CorePlugin.scala b/main/src/main/scala/sbt/plugins/CorePlugin.scala
index 97cd52f40..c0ea66a10 100644
--- a/main/src/main/scala/sbt/plugins/CorePlugin.scala
+++ b/main/src/main/scala/sbt/plugins/CorePlugin.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package plugins
 
@@ -17,4 +24,4 @@ object CorePlugin extends AutoPlugin {
     Defaults.coreDefaultSettings
   override lazy val globalSettings: Seq[Setting[_]] =
     Defaults.globalSbtCore
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/plugins/DependencyTreeKeys.scala b/main/src/main/scala/sbt/plugins/DependencyTreeKeys.scala
new file mode 100644
index 000000000..24d1d08b2
--- /dev/null
+++ b/main/src/main/scala/sbt/plugins/DependencyTreeKeys.scala
@@ -0,0 +1,87 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package plugins
+
+import java.io.File
+import java.net.URI
+import sbt.internal.graph._
+import sbt.BuildSyntax._
+import sbt.librarymanagement.{ ModuleID, UpdateReport }
+
+trait MiniDependencyTreeKeys {
+  val dependencyTreeIncludeScalaLibrary = settingKey[Boolean](
+    "Specifies if scala dependency should be included in dependencyTree output"
+  )
+  val dependencyTree = taskKey[Unit]("Prints an ascii tree of all the dependencies to the console")
+  val asString = taskKey[String]("Provides the string value for the task it is scoped for")
+  // val printToConsole = TaskKey[Unit]("printToConsole", "Prints the tasks value to the console")
+  val toFile = inputKey[File]("Writes the task value to the given file")
+
+  // internal
+  private[sbt] val dependencyTreeIgnoreMissingUpdate =
+    taskKey[UpdateReport]("update used for dependencyTree task")
+  private[sbt] val dependencyTreeModuleGraphStore =
+    taskKey[ModuleGraph]("The stored module-graph from the last run")
+  val whatDependsOn = inputKey[String]("Shows information about what depends on the given module")
+  private[sbt] val dependencyTreeCrossProjectId = settingKey[ModuleID]("")
+}
+
+object MiniDependencyTreeKeys extends MiniDependencyTreeKeys
+
+abstract class DependencyTreeKeys {
+  val dependencyGraphMLFile =
+    settingKey[File]("The location the graphml file should be generated at")
+  val dependencyGraphML =
+    taskKey[File]("Creates a graphml file containing the dependency-graph for a project")
+  val dependencyDotFile =
+    settingKey[File]("The location the dot file should be generated at")
+  val dependencyDotNodeLabel = settingKey[(String, String, String) => String](
+    "Returns a formated string of a dependency. Takes organization, name and version as parameters"
+  )
+  val dependencyDotHeader = settingKey[String](
+    "The header of the dot file. (e.g. to set your preferred node shapes)"
+  )
+  val dependencyDot = taskKey[File](
+    "Creates a dot file containing the dependency-graph for a project"
+  )
+  val dependencyDotString = taskKey[String](
+    "Creates a String containing the dependency-graph for a project in dot format"
+  )
+  val dependencyBrowseGraphTarget = settingKey[File](
+    "The location dependency browse graph files should be put."
+  )
+  val dependencyBrowseGraphHTML = taskKey[URI](
+    "Creates an HTML page that can be used to view the graph."
+  )
+  val dependencyBrowseGraph = taskKey[URI](
+    "Opens an HTML page that can be used to view the graph."
+  )
+  val dependencyBrowseTreeTarget = settingKey[File](
+    "The location dependency browse tree files should be put."
+  )
+  val dependencyBrowseTreeHTML = taskKey[URI](
+    "Creates an HTML page that can be used to view the dependency tree"
+  )
+  val dependencyBrowseTree = taskKey[URI](
+    "Opens an HTML page that can be used to view the dependency tree"
+  )
+  // 0 was added to avoid conflict with sbt-dependency-tree
+  private[sbt] val dependencyTreeModuleGraph0 =
+    taskKey[ModuleGraph]("The dependency graph for a project")
+
+  val dependencyList =
+    taskKey[Unit]("Prints a list of all dependencies to the console")
+  val dependencyStats =
+    taskKey[Unit]("Prints statistics for all dependencies to the console")
+  val dependencyLicenseInfo = taskKey[Unit](
+    "Aggregates and shows information about the licenses of dependencies"
+  )
+}
+
+object DependencyTreeKeys extends DependencyTreeKeys
diff --git a/main/src/main/scala/sbt/plugins/DependencyTreeSettings.scala b/main/src/main/scala/sbt/plugins/DependencyTreeSettings.scala
new file mode 100644
index 000000000..2c20525e9
--- /dev/null
+++ b/main/src/main/scala/sbt/plugins/DependencyTreeSettings.scala
@@ -0,0 +1,300 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package plugins
+
+import java.io.File
+
+import sbt.Def._
+import sbt.Keys._
+import sbt.SlashSyntax0._
+import sbt.Project._
+import sbt.internal.graph._
+import sbt.internal.graph.backend.SbtUpdateReport
+import sbt.internal.graph.rendering.{ DagreHTML, TreeView }
+import sbt.internal.librarymanagement._
+import sbt.internal.util.complete.{ Parser, Parsers }
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.librarymanagement._
+
+object DependencyTreeSettings {
+  import sjsonnew.BasicJsonProtocol._
+  import MiniDependencyTreeKeys._
+  import DependencyTreeKeys._
+
+  /**
+   * Core settings needed for any graphing tasks.
+   */
+  def coreSettings =
+    Seq(
+      // disable the cached resolution engine (exposing a scoped `ivyModule` used directly by `updateTask`), as it
+      // generates artificial module descriptors which are internal to sbt, making it hard to reconstruct the
+      // dependency tree
+      dependencyTreeIgnoreMissingUpdate / updateOptions := updateOptions.value
+        .withCachedResolution(false),
+      dependencyTreeIgnoreMissingUpdate / ivyConfiguration := {
+        // inTask will make sure the new definition will pick up `updateOptions in dependencyTreeIgnoreMissingUpdate`
+        inTask(dependencyTreeIgnoreMissingUpdate, Classpaths.mkIvyConfiguration).value
+      },
+      dependencyTreeIgnoreMissingUpdate / ivyModule := {
+        // concatenating & inlining ivySbt & ivyModule default task implementations, as `SbtAccess.inTask` does
+        // NOT correctly force the scope when applied to `TaskKey.toTask` instances (as opposed to raw
+        // implementations like `Classpaths.mkIvyConfiguration` or `Classpaths.updateTask`)
+        val is = new IvySbt((dependencyTreeIgnoreMissingUpdate / ivyConfiguration).value)
+        new is.Module(moduleSettings.value)
+      },
+      // don't fail on missing dependencies
+      dependencyTreeIgnoreMissingUpdate / updateConfiguration := updateConfiguration.value
+        .withMissingOk(true),
+      dependencyTreeIgnoreMissingUpdate := {
+        // inTask will make sure the new definition will pick up `ivyModule/updateConfiguration in ignoreMissingUpdate`
+        inTask(dependencyTreeIgnoreMissingUpdate, Classpaths.updateTask).value
+      },
+    )
+
+  /**
+   * MiniDependencyTreePlugin includes these settings for Compile and Test scopes
+   * to provide dependencyTree task.
+   */
+  lazy val baseBasicReportingSettings: Seq[Def.Setting[_]] =
+    Seq(
+      dependencyTreeCrossProjectId := CrossVersion(scalaVersion.value, scalaBinaryVersion.value)(
+        projectID.value
+      ),
+      dependencyTreeModuleGraph0 := {
+        val sv = scalaVersion.value
+        val g = dependencyTreeIgnoreMissingUpdate.value
+          .configuration(configuration.value)
+          .map(
+            report =>
+              SbtUpdateReport.fromConfigurationReport(report, dependencyTreeCrossProjectId.value)
+          )
+          .getOrElse(ModuleGraph.empty)
+        if (dependencyTreeIncludeScalaLibrary.value) g
+        else GraphTransformations.ignoreScalaLibrary(sv, g)
+      },
+      dependencyTreeModuleGraphStore := (dependencyTreeModuleGraph0 storeAs dependencyTreeModuleGraphStore triggeredBy dependencyTreeModuleGraph0).value,
+    ) ++ renderingTaskSettings(dependencyTree, rendering.AsciiTree.asciiTree _)
+
+  /**
+   * This is the maximum strength settings for DependencyTreePlugin.
+   */
+  lazy val baseFullReportingSettings: Seq[Def.Setting[_]] =
+    Seq(
+      // browse
+      dependencyBrowseGraphTarget := { target.value / "browse-dependency-graph" },
+      dependencyBrowseGraphHTML := browseGraphHTMLTask.value,
+      dependencyBrowseGraph := openBrowser(dependencyBrowseGraphHTML).value,
+      dependencyBrowseTreeTarget := { target.value / "browse-dependency-tree" },
+      dependencyBrowseTreeHTML := browseTreeHTMLTask.value,
+      dependencyBrowseTree := openBrowser(dependencyBrowseTreeHTML).value,
+      // dot support
+      dependencyDotFile := {
+        val config = configuration.value
+        target.value / "dependencies-%s.dot".format(config.toString)
+      },
+      dependencyDot / asString := rendering.DOT.dotGraph(
+        dependencyTreeModuleGraph0.value,
+        dependencyDotHeader.value,
+        dependencyDotNodeLabel.value,
+        rendering.DOT.AngleBrackets
+      ),
+      dependencyDot := writeToFile(dependencyDot / asString, dependencyDotFile).value,
+      dependencyDotHeader :=
+        """|digraph "dependency-graph" {
+         |    graph[rankdir="LR"]
+         |    edge [
+         |        arrowtail="none"
+         |    ]""".stripMargin,
+      dependencyDotNodeLabel := { (organization: String, name: String, version: String) =>
+        """%s<BR/><B>%s</B><BR/>%s""".format(organization, name, version)
+      },
+      // GraphML support
+      dependencyGraphMLFile := {
+        val config = configuration.value
+        target.value / "dependencies-%s.graphml".format(config.toString)
+      },
+      dependencyGraphML := dependencyGraphMLTask.value,
+      whatDependsOn := {
+        val ArtifactPattern(org, name, versionFilter) = artifactPatternParser.parsed
+        val graph = dependencyTreeModuleGraph0.value
+        val modules =
+          versionFilter match {
+            case Some(version) => GraphModuleId(org, name, version) :: Nil
+            case None =>
+              graph.nodes.filter(m => m.id.organization == org && m.id.name == name).map(_.id)
+          }
+        val output =
+          modules
+            .map { module =>
+              rendering.AsciiTree
+                .asciiTree(GraphTransformations.reverseGraphStartingAt(graph, module))
+            }
+            .mkString("\n")
+
+        streams.value.log.info(output)
+        output
+      },
+    ) ++
+      renderingAlternatives.flatMap((renderingTaskSettings _).tupled)
+
+  def renderingAlternatives: Seq[(TaskKey[Unit], ModuleGraph => String)] =
+    Seq(
+      dependencyList -> rendering.FlatList.render(_.id.idString),
+      dependencyStats -> rendering.Statistics.renderModuleStatsList _,
+      dependencyLicenseInfo -> rendering.LicenseInfo.render _
+    )
+
+  def renderingTaskSettings(key: TaskKey[Unit], renderer: ModuleGraph => String): Seq[Setting[_]] =
+    Seq(
+      key := {
+        val s = streams.value
+        val str = (key / asString).value
+        s.log.info(str)
+      },
+      key / asString := renderer(dependencyTreeModuleGraph0.value),
+      key / toFile := {
+        val (targetFile, force) = targetFileAndForceParser.parsed
+        writeToFile(key.key.label, (key / asString).value, targetFile, force, streams.value)
+      },
+    )
+
+  def dependencyGraphMLTask =
+    Def.task {
+      val resultFile = dependencyGraphMLFile.value
+      val graph = dependencyTreeModuleGraph0.value
+      rendering.GraphML.saveAsGraphML(graph, resultFile.getAbsolutePath)
+      streams.value.log.info("Wrote dependency graph to '%s'" format resultFile)
+      resultFile
+    }
+
+  def browseGraphHTMLTask =
+    Def.task {
+      val graph = dependencyTreeModuleGraph0.value
+      val dotGraph = rendering.DOT.dotGraph(
+        graph,
+        dependencyDotHeader.value,
+        dependencyDotNodeLabel.value,
+        rendering.DOT.LabelTypeHtml
+      )
+      val link = DagreHTML.createLink(dotGraph, target.value)
+      streams.value.log.info(s"HTML graph written to $link")
+      link
+    }
+
+  def browseTreeHTMLTask =
+    Def.task {
+      val graph = dependencyTreeModuleGraph0.value
+      val renderedTree = TreeView.createJson(graph)
+      val link = TreeView.createLink(renderedTree, target.value)
+      streams.value.log.info(s"HTML tree written to $link")
+      link
+    }
+
+  def writeToFile(dataTask: TaskKey[String], fileTask: SettingKey[File]) =
+    Def.task {
+      val outFile = fileTask.value
+      IO.write(outFile, dataTask.value, IO.utf8)
+
+      streams.value.log.info("Wrote dependency graph to '%s'" format outFile)
+      outFile
+    }
+
+  def writeToFile(
+      what: String,
+      data: String,
+      targetFile: File,
+      force: Boolean,
+      streams: TaskStreams
+  ): File =
+    if (targetFile.exists && !force)
+      throw new RuntimeException(
+        s"Target file for $what already exists at ${targetFile.getAbsolutePath}. Use '-f' to override"
+      )
+    else {
+      IO.write(targetFile, data, IO.utf8)
+
+      streams.log.info(s"Wrote $what to '$targetFile'")
+      targetFile
+    }
+
+  def absoluteReportPath = (file: File) => file.getAbsolutePath
+
+  def openBrowser(uriKey: TaskKey[URI]) =
+    Def.task {
+      val uri = uriKey.value
+      streams.value.log.info("Opening in browser...")
+      java.awt.Desktop.getDesktop.browse(uri)
+      uri
+    }
+
+  case class ArtifactPattern(organization: String, name: String, version: Option[String])
+
+  import sbt.internal.util.complete.DefaultParsers._
+  val artifactPatternParser: Def.Initialize[State => Parser[ArtifactPattern]] =
+    Keys.resolvedScoped { ctx => (state: State) =>
+      val graph = Defaults.loadFromContext(dependencyTreeModuleGraphStore, ctx, state) getOrElse ModuleGraph(
+        Nil,
+        Nil
+      )
+
+      graph.nodes
+        .map(_.id)
+        .groupBy(m => (m.organization, m.name))
+        .map {
+          case ((org, name), modules) =>
+            val versionParsers: Seq[Parser[Option[String]]] =
+              modules.map { id =>
+                token(Space ~> id.version).?
+              }
+
+            (Space ~> token(org) ~ token(Space ~> name) ~ oneOf(versionParsers)).map {
+              case ((org, name), version) => ArtifactPattern(org, name, version)
+            }
+        }
+        .reduceOption(_ | _)
+        .getOrElse {
+          // If the dependencyTreeModuleGraphStore couldn't be loaded because no dependency tree command was run before, we should still provide a parser for the command.
+          ((Space ~> token(StringBasic, "<organization>")) ~ (Space ~> token(
+            StringBasic,
+            "<module>"
+          )) ~ (Space ~> token(StringBasic, "<version?>")).?).map {
+            case ((org, mod), version) =>
+              ArtifactPattern(org, mod, version)
+          }
+        }
+    }
+  val shouldForceParser: Parser[Boolean] =
+    (Space ~> (Parser.literal("-f") | "--force")).?.map(_.isDefined)
+
+  val targetFileAndForceParser: Parser[(File, Boolean)] =
+    Parsers.fileParser(new File(".")) ~ shouldForceParser
+
+  // This is to support 0.13.8's InlineConfigurationWithExcludes while not forcing 0.13.8
+  type HasModule = {
+    val module: ModuleID
+  }
+  def crossName(ivyModule: IvySbt#Module) =
+    ivyModule.moduleSettings match {
+      case ic: ModuleDescriptorConfiguration => ic.module.name
+      case _ =>
+        throw new IllegalStateException(
+          "sbt-dependency-graph plugin currently only supports ModuleDescriptorConfiguration of ivy settings (the default in sbt)"
+        )
+    }
+
+  val VersionPattern = """(\d+)\.(\d+)\.(\d+)(?:-(.*))?""".r
+  object Version {
+    def unapply(str: String): Option[(Int, Int, Int, Option[String])] = str match {
+      case VersionPattern(major, minor, fix, appendix) =>
+        Some((major.toInt, minor.toInt, fix.toInt, Option(appendix)))
+      case _ => None
+    }
+  }
+}
diff --git a/main/src/main/scala/sbt/plugins/Giter8TemplatePlugin.scala b/main/src/main/scala/sbt/plugins/Giter8TemplatePlugin.scala
new file mode 100644
index 000000000..a5cc5efce
--- /dev/null
+++ b/main/src/main/scala/sbt/plugins/Giter8TemplatePlugin.scala
@@ -0,0 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package plugins
+
+import Def.Setting
+import Keys._
+import librarymanagement._
+
+/**
+ * An experimental plugin that adds the ability for Giter8 templates to be resolved
+ */
+object Giter8TemplatePlugin extends AutoPlugin {
+  override def requires = CorePlugin
+  override def trigger = allRequirements
+
+  override lazy val globalSettings: Seq[Setting[_]] =
+    Seq(
+      templateResolverInfos +=
+        TemplateResolverInfo(
+          ModuleID(
+            "org.scala-sbt.sbt-giter8-resolver",
+            "sbt-giter8-resolver",
+            "0.13.1"
+          ) cross CrossVersion.binary,
+          "sbtgiter8resolver.Giter8TemplateResolver"
+        )
+    )
+}
diff --git a/main/src/main/scala/sbt/plugins/IvyPlugin.scala b/main/src/main/scala/sbt/plugins/IvyPlugin.scala
index 43239bdbf..97a7a1371 100644
--- a/main/src/main/scala/sbt/plugins/IvyPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/IvyPlugin.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package plugins
 
@@ -19,8 +26,11 @@ object IvyPlugin extends AutoPlugin {
   override def requires = CorePlugin
   override def trigger = allRequirements
 
-  override lazy val projectSettings: Seq[Setting[_]] = 
-    Classpaths.ivyPublishSettings ++ Classpaths.ivyBaseSettings
   override lazy val globalSettings: Seq[Setting[_]] =
-     Defaults.globalIvyCore
+    Defaults.globalIvyCore
+  override lazy val buildSettings: Seq[Setting[_]] =
+    Defaults.buildLevelIvySettings
+  override lazy val projectSettings: Seq[Setting[_]] =
+    Classpaths.ivyPublishSettings ++ Classpaths.ivyBaseSettings
+
 }
diff --git a/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala b/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
index b84057346..39baa07a6 100644
--- a/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
@@ -1,10 +1,19 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package plugins
 
 import Def.Setting
 import Keys._
+import sbt.internal.SysProp
 
-/** An experimental plugin that adds the ability for junit-xml to be generated.
+/**
+ * An experimental plugin that adds the ability for junit-xml to be generated.
  *
  *  To disable this plugin, you need to add:
  *  {{{
@@ -17,11 +26,15 @@ object JUnitXmlReportPlugin extends AutoPlugin {
   // TODO - If testing becomes its own plugin, we only rely on the core settings.
   override def requires = JvmPlugin
   override def trigger = allRequirements
-  
+
   // Right now we add to the global test listeners which should capture *all* tests.
   // It might be a good idea to derive this setting into specific test scopes.
   override lazy val projectSettings: Seq[Setting[_]] =
     Seq(
-      testListeners += new JUnitXmlTestsListener(target.value.getAbsolutePath)
+      testListeners += new JUnitXmlTestsListener(
+        target.value.getAbsolutePath,
+        SysProp.legacyTestReport,
+        streams.value.log
+      )
     )
 }
diff --git a/main/src/main/scala/sbt/plugins/JvmPlugin.scala b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
index e34dc835d..be930f5e5 100644
--- a/main/src/main/scala/sbt/plugins/JvmPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package plugins
 
@@ -5,7 +12,8 @@ import sbt.librarymanagement.{ Configuration, Configurations }
 
 import Def.Setting
 
-/** A plugin representing the ability to build a JVM project.
+/**
+ * A plugin representing the ability to build a JVM project.
  *
  *  Core tasks/keys:
  *  - `run`
@@ -21,18 +29,22 @@ object JvmPlugin extends AutoPlugin {
   // for ours to work.
   override def requires = IvyPlugin
   override def trigger = allRequirements
-  
-  override lazy val projectSettings: Seq[Setting[_]] = 
-    Defaults.runnerSettings ++
-    Defaults.paths ++
-    Classpaths.jvmPublishSettings ++
-    Classpaths.jvmBaseSettings ++
-    Defaults.baseTasks ++
-    Defaults.compileBase ++
-    Defaults.defaultConfigs
-  override lazy val globalSettings: Seq[Setting[_]] =
-     Defaults.globalJvmCore
 
-  override def projectConfigurations: Seq[Configuration] = 
+  override lazy val globalSettings: Seq[Setting[_]] =
+    Defaults.globalJvmCore
+
+  override lazy val buildSettings: Seq[Setting[_]] =
+    Defaults.buildLevelJvmSettings
+
+  override lazy val projectSettings: Seq[Setting[_]] =
+    Defaults.runnerSettings ++
+      Defaults.paths ++
+      Classpaths.jvmPublishSettings ++
+      Classpaths.jvmBaseSettings ++
+      Defaults.baseTasks ++
+      Defaults.compileBase ++
+      Defaults.defaultConfigs
+
+  override def projectConfigurations: Seq[Configuration] =
     Configurations.default
 }
diff --git a/main/src/main/scala/sbt/plugins/MiniDependencyTreePlugin.scala b/main/src/main/scala/sbt/plugins/MiniDependencyTreePlugin.scala
new file mode 100644
index 000000000..2236c21c9
--- /dev/null
+++ b/main/src/main/scala/sbt/plugins/MiniDependencyTreePlugin.scala
@@ -0,0 +1,27 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package plugins
+
+import sbt.PluginTrigger.AllRequirements
+import sbt.Project._
+import sbt.librarymanagement.Configurations.{ Compile, Test }
+
+object MiniDependencyTreePlugin extends AutoPlugin {
+  object autoImport extends MiniDependencyTreeKeys
+
+  import autoImport._
+  override def trigger: PluginTrigger = AllRequirements
+  override def globalSettings: Seq[Def.Setting[_]] = Seq(
+    dependencyTreeIncludeScalaLibrary := false
+  )
+  override def projectSettings: Seq[Def.Setting[_]] =
+    DependencyTreeSettings.coreSettings ++
+      inConfig(Compile)(DependencyTreeSettings.baseBasicReportingSettings) ++
+      inConfig(Test)(DependencyTreeSettings.baseBasicReportingSettings)
+}
diff --git a/main/src/main/scala/sbt/plugins/SbtPlugin.scala b/main/src/main/scala/sbt/plugins/SbtPlugin.scala
new file mode 100644
index 000000000..5873d2412
--- /dev/null
+++ b/main/src/main/scala/sbt/plugins/SbtPlugin.scala
@@ -0,0 +1,20 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package plugins
+
+import Keys._
+import Def.Setting
+
+object SbtPlugin extends AutoPlugin {
+  override def requires = ScriptedPlugin
+
+  override lazy val projectSettings: Seq[Setting[_]] = Seq(
+    sbtPlugin := true
+  )
+}
diff --git a/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala b/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
new file mode 100644
index 000000000..ee0df6f42
--- /dev/null
+++ b/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
@@ -0,0 +1,103 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package plugins
+
+import java.io.File
+
+import Keys._
+import sbt.internal.SysProp
+import sbt.librarymanagement.syntax._
+import sbt.librarymanagement.{ Configuration, CrossVersion }
+import Project.inConfig
+import sbt.internal.inc.ScalaInstance
+import sbt.ScopeFilter.Make._
+
+object SemanticdbPlugin extends AutoPlugin {
+  override def requires = JvmPlugin
+  override def trigger = allRequirements
+
+  override lazy val globalSettings: Seq[Def.Setting[_]] = Seq(
+    semanticdbEnabled := SysProp.semanticdb,
+    semanticdbIncludeInJar := false,
+    semanticdbOptions := List(),
+    semanticdbVersion := "4.4.10"
+  )
+
+  override lazy val projectSettings: Seq[Def.Setting[_]] = Seq(
+    semanticdbCompilerPlugin := {
+      val v = semanticdbVersion.value
+      ("org.scalameta" % "semanticdb-scalac" % v).cross(CrossVersion.full)
+    },
+    allDependencies ++= {
+      val sdb = semanticdbEnabled.value
+      val m = semanticdbCompilerPlugin.value
+      val sv = scalaVersion.value
+      if (sdb && !ScalaInstance.isDotty(sv)) List(Build0.compilerPlugin(m))
+      else Nil
+    },
+    semanticdbOptions += {
+      val sv = scalaVersion.value
+      if (sv.startsWith("0.") || sv.startsWith("3.0.0-M1") || sv.startsWith("3.0.0-M2"))
+        "-Ysemanticdb"
+      else if (sv.startsWith("3.")) "-Xsemanticdb"
+      else "-Yrangepos"
+    }
+  ) ++
+    inConfig(Compile)(configurationSettings) ++
+    inConfig(Test)(configurationSettings)
+
+  lazy val configurationSettings: Seq[Def.Setting[_]] = List(
+    semanticdbTargetRoot := {
+      val in = semanticdbIncludeInJar.value
+      if (in) classDirectory.value
+      else semanticdbTargetRoot.value
+    },
+    semanticdbOptions --= Def.settingDyn {
+      val scalaV = scalaVersion.value
+      val config = configuration.value
+      Def.setting {
+        semanticdbTargetRoot.?.all(ancestorConfigs(config)).value.flatten
+          .flatMap(targetRootOptions(scalaV, _))
+      }
+    }.value,
+    semanticdbOptions ++=
+      targetRootOptions(scalaVersion.value, semanticdbTargetRoot.value),
+    scalacOptions --= Def.settingDyn {
+      val config = configuration.value
+      val enabled = semanticdbEnabled.value
+      if (enabled)
+        Def.setting {
+          semanticdbOptions.?.all(ancestorConfigs(config)).value.flatten.flatten
+        } else Def.setting { Nil }
+    }.value,
+    scalacOptions ++= {
+      if (semanticdbEnabled.value)
+        semanticdbOptions.value
+      else Seq.empty
+    }
+  )
+
+  @deprecated("use configurationSettings only", "1.5.0")
+  lazy val testSettings: Seq[Def.Setting[_]] = List()
+
+  def targetRootOptions(scalaVersion: String, targetRoot: File): Seq[String] = {
+    if (ScalaInstance.isDotty(scalaVersion)) {
+      Seq("-semanticdb-target", targetRoot.toString)
+    } else {
+      Seq(s"-P:semanticdb:targetroot:$targetRoot")
+    }
+  }
+
+  private def ancestorConfigs(config: Configuration) = {
+    def ancestors(configs: Vector[Configuration]): Vector[Configuration] =
+      configs ++ configs.flatMap(conf => ancestors(conf.extendsConfigs))
+
+    ScopeFilter(configurations = inConfigurations(ancestors(config.extendsConfigs): _*))
+  }
+}
diff --git a/main/src/test/resources/new-format/1.sbt.txt b/main/src/test/resources/new-format/1.sbt.txt
index c7aacc410..536d659a3 100644
--- a/main/src/test/resources/new-format/1.sbt.txt
+++ b/main/src/test/resources/new-format/1.sbt.txt
@@ -7,7 +7,7 @@ checkPom := {
 	val tpe = pom \\ "type"
 
 	if(!tpe.isEmpty)
-		error("Expected no <type> sections, got: " + tpe + " in \n\n" + pom)
+		sys.error("Expected no <type> sections, got: " + tpe + " in \n\n" + pom)
 }
 val b = ( <b/>)
 val a = <aaa
diff --git a/main/src/test/resources/new-format/2.sbt.txt b/main/src/test/resources/new-format/2.sbt.txt
index 899c65995..7d7f79493 100644
--- a/main/src/test/resources/new-format/2.sbt.txt
+++ b/main/src/test/resources/new-format/2.sbt.txt
@@ -6,7 +6,7 @@ lazy val checkPom = taskKey[Unit]("check pom to ensure no <type> sections are ge
 	val pom = xml.XML.loadFile(pomFile)
 	val tpe = pom \\ "type"
 	if(!tpe.isEmpty)
-		error("Expected no <type> sections, got: " + tpe + " in \n\n" + pom)
+		sys.error("Expected no <type> sections, got: " + tpe + " in \n\n" + pom)
 }
 
 val b = ( <b/>)
diff --git a/main/src/test/scala/BuildPathsTest.scala b/main/src/test/scala/BuildPathsTest.scala
new file mode 100644
index 000000000..0fe69ab13
--- /dev/null
+++ b/main/src/test/scala/BuildPathsTest.scala
@@ -0,0 +1,49 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import BuildPaths.expandTildePrefix
+
+object BuildPathsTest extends verify.BasicTestSuite {
+
+  test("expandTildePrefix should expand empty path to itself") {
+    assertEquals("", expandTildePrefix(""))
+  }
+
+  test("it should expand /home/user/path to itself") {
+    assertEquals("/home/user/path", expandTildePrefix("/home/user/path"))
+  }
+
+  test("it should expand /~/foo/ to itself") {
+    assertEquals("/~/foo/", expandTildePrefix("/~/foo/"))
+  }
+
+  test("it should expand ~ to $HOME") {
+    assertEquals(sys.env.getOrElse("HOME", ""), expandTildePrefix("~"))
+  }
+
+  test("it should expand ~/foo/bar to $HOME/foo/bar") {
+    assertEquals(sys.env.getOrElse("HOME", "") + "/foo/bar", expandTildePrefix("~/foo/bar"))
+  }
+
+  test("it should expand ~+ to $PWD") {
+    assertEquals(sys.env.getOrElse("PWD", ""), expandTildePrefix("~+"))
+  }
+
+  test("it should expand ~+/foo/bar to $PWD/foo/bar") {
+    assertEquals(sys.env.getOrElse("PWD", "") + "/foo/bar", expandTildePrefix("~+/foo/bar"))
+  }
+
+  test("it should expand ~- to $OLDPWD") {
+    assertEquals(sys.env.getOrElse("OLDPWD", ""), expandTildePrefix("~-"))
+  }
+
+  test("it should expand ~-/foo/bar to $OLDPWD/foo/bar") {
+    assertEquals(sys.env.getOrElse("OLDPWD", "") + "/foo/bar", expandTildePrefix("~-/foo/bar"))
+  }
+}
diff --git a/main/src/test/scala/ClasspathsTest.scala b/main/src/test/scala/ClasspathsTest.scala
new file mode 100644
index 000000000..ff155199c
--- /dev/null
+++ b/main/src/test/scala/ClasspathsTest.scala
@@ -0,0 +1,46 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.test
+
+import sbt._
+import sbt.Classpaths._
+import sbt.Def.Initialize
+
+class ClasspathsTest[T](
+    settKey: SettingKey[Seq[T]],
+    taskKey: TaskKey[Seq[T]],
+    initVal: Initialize[Seq[T]],
+    taskVal: Initialize[Task[Seq[T]]],
+) {
+
+  def testConcat() = {
+    concat(settKey, settKey)
+    concat(settKey, taskKey)
+    concat(settKey, initVal)
+    concat(settKey, taskVal)
+    concat(taskKey, settKey)
+    concat(taskKey, taskKey)
+    concat(taskKey, initVal)
+    concat(taskKey, taskVal)
+    concat(initVal, settKey)
+    concat(initVal, taskKey)
+    concat(initVal, initVal)
+    concat(initVal, taskVal)
+    concat(taskVal, settKey)
+    concat(taskVal, taskKey)
+    concat(taskVal, initVal)
+    concat(taskVal, taskVal)
+  }
+
+  def testConcatSettings() = {
+    concatSettings(settKey, settKey)
+    concatSettings(settKey, initVal)
+    concatSettings(initVal, settKey)
+    concatSettings(initVal, initVal)
+  }
+}
diff --git a/main/src/test/scala/DefaultsTest.scala b/main/src/test/scala/DefaultsTest.scala
index 0a1ef615c..fa73a5795 100644
--- a/main/src/test/scala/DefaultsTest.scala
+++ b/main/src/test/scala/DefaultsTest.scala
@@ -1,51 +1,83 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import org.specs2.mutable.Specification
+object DefaultsTest extends verify.BasicTestSuite {
 
-object DefaultsTest extends Specification {
-  private def assertFiltered(filter: List[String], expected: Map[String, Boolean]) = {
-    val actual = expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1))))
-
-    actual must be equalTo (expected)
+  test("`selectedFilter` should return all tests for an empty list") {
+    val expected = Map("Test1" -> true, "Test2" -> true)
+    val filter = List.empty[String]
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
   }
 
-  "`selectedFilter`" should {
-    "return all tests for an empty list" in {
-      assertFiltered(List(), Map("Test1" -> true, "Test2" -> true))
-    }
-
-    "work correctly with exact matches" in {
-      assertFiltered(List("Test1", "foo"), Map("Test1" -> true, "Test2" -> false, "Foo" -> false))
-    }
-
-    "work correctly with glob" in {
-      assertFiltered(List("Test*"), Map("Test1" -> true, "Test2" -> true, "Foo" -> false))
-    }
-
-    "work correctly with excludes" in {
-      assertFiltered(List("Test*", "-Test2"), Map("Test1" -> true, "Test2" -> false, "Foo" -> false))
-    }
-
-    "work correctly without includes" in {
-      assertFiltered(List("-Test2"), Map("Test1" -> true, "Test2" -> false, "Foo" -> true))
-    }
-
-    "work correctly with excluded globs" in {
-      assertFiltered(List("Test*", "-F*"), Map("Test1" -> true, "Test2" -> true, "Foo" -> false))
-    }
-
-    "cope with multiple filters" in {
-      assertFiltered(List("T*1", "T*2", "-F*"), Map("Test1" -> true, "Test2" -> true, "Foo" -> false))
-    }
-
-    "cope with multiple exclusion filters, no includes" in {
-      assertFiltered(List("-A*", "-F*"), Map("Test1" -> true, "Test2" -> true, "AAA" -> false, "Foo" -> false))
-    }
-
-    "cope with multiple exclusion filters with includes" in {
-      assertFiltered(List("T*", "-T*1", "-T*2"), Map("Test1" -> false, "Test2" -> false, "Test3" -> true))
-    }
+  test("it should work correctly with exact matches") {
+    val expected = Map("Test1" -> true, "Test2" -> false, "Foo" -> false)
+    val filter = List("Test1", "foo")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
   }
 
+  test("it should work correctly with glob") {
+    val expected = Map("Test1" -> true, "Test2" -> true, "Foo" -> false)
+    val filter = List("Test*")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
+  }
+
+  test("it should work correctly with excludes") {
+    val expected = Map("Test1" -> true, "Test2" -> false, "Foo" -> false)
+    val filter = List("Test*", "-Test2")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
+  }
+
+  test("it should work correctly without includes") {
+    val expected = Map("Test1" -> true, "Test2" -> false, "Foo" -> true)
+    val filter = List("-Test2")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
+  }
+
+  test("it should work correctly with excluded globs") {
+    val expected = Map("Test1" -> true, "Test2" -> true, "Foo" -> false)
+    val filter = List("Test*", "-F*")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
+  }
+
+  test("it should cope with multiple filters") {
+    val expected = Map("Test1" -> true, "Test2" -> true, "Foo" -> false)
+    val filter = List("T*1", "T*2", "-F*")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
+  }
+
+  test("it should cope with multiple exclusion filters, no includes") {
+    val expected = Map("Test1" -> true, "Test2" -> true, "AAA" -> false, "Foo" -> false)
+    val filter = List("-A*", "-F*")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
+  }
+
+  test("it should cope with multiple exclusion filters with includes") {
+    val expected = Map("Test1" -> false, "Test2" -> false, "Test3" -> true)
+    val filter = List("T*", "-T*1", "-T*2")
+    assert(
+      expected.map(t => (t._1, Defaults.selectedFilter(filter).exists(fn => fn(t._1)))) == expected
+    )
+  }
 }
-
diff --git a/main/src/test/scala/Delegates.scala b/main/src/test/scala/Delegates.scala
index b338734e7..2d317e8c2 100644
--- a/main/src/test/scala/Delegates.scala
+++ b/main/src/test/scala/Delegates.scala
@@ -1,71 +1,164 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import Project._
 import sbt.internal.util.Types.idFun
 import sbt.internal.TestBuild._
+import hedgehog._
+import hedgehog.Result.{ all, assert, failure, success }
+import hedgehog.runner._
 
-import org.scalacheck._
-import Prop._
-import Gen._
+object Delegates extends Properties {
 
-object Delegates extends Properties("delegates") {
-  property("generate non-empty configs") = forAll { (c: Seq[Config]) => c.nonEmpty }
-  property("generate non-empty tasks") = forAll { (t: Seq[Taskk]) => t.nonEmpty }
+  override def tests: List[Test] =
+    List(
+      property("generate non-empty configs", cGen.forAll.map { c =>
+        assert(c.nonEmpty)
+      }),
+      property("generate non-empty tasks", tGen.forAll.map { t =>
+        assert(t.nonEmpty)
+      }),
+      property("no duplicate scopes", keysGen.forAll.map { keys =>
+        allDelegates(keys) { (_, ds) =>
+          ds.distinct.size ==== ds.size
+        }
+      }),
+      property("delegates non-empty", keysGen.forAll.map { keys =>
+        allDelegates(keys) { (_, ds) =>
+          assert(ds.nonEmpty)
+        }
+      }),
+      property("An initially Zero axis is Zero in all delegates", allAxes(alwaysZero)),
+      property(
+        "Projects precede builds precede Zero",
+        keysGen.forAll.map { keys =>
+          allDelegates(keys) { (scope, ds) =>
+            val projectAxes = ds.map(_.project)
+            val nonProject = projectAxes.dropWhile {
+              case Select(_: ProjectRef) => true; case _ => false
+            }
+            val global = nonProject.dropWhile { case Select(_: BuildRef) => true; case _ => false }
+            all(global.map { _ ==== Zero }.toList)
+          }
+        }
+      ),
+      property(
+        "Initial scope present with all combinations of Global axes",
+        allAxes(
+          (s, ds, _) => globalCombinations(s, ds)
+        )
+      ),
+      property("initial scope first", keysGen.forAll.map { keys =>
+        allDelegates(keys) { (scope, ds) =>
+          ds.head ==== scope
+        }
+      }),
+      property("global scope last", keysGen.forAll.map { keys =>
+        allDelegates(keys) { (_, ds) =>
+          ds.last ==== Scope.GlobalScope
+        }
+      }),
+      property(
+        "Project axis delegates to BuildRef then Zero",
+        keysGen.forAll.map { keys =>
+          allDelegates(keys) {
+            (key, ds) =>
+              key.project match {
+                case Zero => success // filtering out of testing
+                case Select(rr: ResolvedReference) =>
+                  rr match {
+                    case BuildRef(_) =>
+                      assert(ds.indexOf(key) < ds.indexOf(key.copy(project = Zero)))
+                    case ProjectRef(uri, _) =>
+                      val buildScoped = key.copy(project = Select(BuildRef(uri)))
+                      val idxKey = ds.indexOf(key)
+                      val idxB = ds.indexOf(buildScoped)
+                      val z = key.copy(project = Zero)
+                      val idxZ = ds.indexOf(z)
+                      (z ==== Scope.GlobalScope)
+                        .or(
+                          assert((idxKey < idxB) && (idxB < idxZ))
+                            .log(s"idxKey = $idxKey; idxB = $idxB; idxZ = $idxZ")
+                        )
+                  }
+                case Select(_) | This =>
+                  failure.log(s"Scope's reference should be resolved, but was ${key.project}")
+              }
+          }
+        }
+      ),
+      property(
+        "Config axis delegates to parent configuration",
+        keysGen.forAll.map { keys =>
+          allDelegates(keys) {
+            (key, ds) =>
+              key.config match {
+                case Zero => success
+                case Select(config) =>
+                  key.project match {
+                    case Select(p @ ProjectRef(_, _)) =>
+                      val r = keys.env.resolve(p)
+                      keys.env.inheritConfig(r, config).headOption.fold(success) { parent =>
+                        val idxKey = ds.indexOf(key)
+                        val a = key.copy(config = Select(parent))
+                        val idxA = ds.indexOf(a)
+                        assert(idxKey < idxA)
+                          .log(s"idxKey = $idxKey; a = $a; idxA = $idxA")
+                      }
+                    case _ => success
+                  }
+                case _ => success
+              }
+          }
+        }
+      )
+    )
 
-  property("no duplicate scopes") = forAll { (keys: Keys) =>
-    allDelegates(keys) { (_, ds) => ds.distinct.size == ds.size }
-  }
-  property("delegates non-empty") = forAll { (keys: Keys) =>
-    allDelegates(keys) { (_, ds) => ds.nonEmpty }
-  }
-
-  property("An initially Global axis is Global in all delegates") = allAxes(alwaysGlobal)
-
-  property("Projects precede builds precede Global") = forAll { (keys: Keys) =>
-    allDelegates(keys) { (scope, ds) =>
-      val projectAxes = ds.map(_.project)
-      val nonProject = projectAxes.dropWhile { case Select(_: ProjectRef) => true; case _ => false }
-      val global = nonProject.dropWhile { case Select(_: BuildRef) => true; case _ => false }
-      global forall { _ == Global }
+  def allAxes(f: (Scope, Seq[Scope], Scope => ScopeAxis[_]) => hedgehog.Result): Property =
+    keysGen.forAll.map { keys =>
+      allDelegates(keys) { (s, ds) =>
+        all(List(f(s, ds, _.project), f(s, ds, _.config), f(s, ds, _.task), f(s, ds, _.extra)))
+      }
     }
-  }
-  property("Initial scope present with all combinations of Global axes") = allAxes(globalCombinations)
 
-  property("initial scope first") = forAll { (keys: Keys) =>
-    allDelegates(keys) { (scope, ds) => ds.head == scope }
-  }
-  property("global scope last") = forAll { (keys: Keys) =>
-    allDelegates(keys) { (_, ds) => ds.last == Scope.GlobalScope }
-  }
-
-  def allAxes(f: (Scope, Seq[Scope], Scope => ScopeAxis[_]) => Prop): Prop = forAll { (keys: Keys) =>
-    allDelegates(keys) { (s, ds) =>
-      all(f(s, ds, _.project), f(s, ds, _.config), f(s, ds, _.task), f(s, ds, _.extra))
-    }
-  }
-  def allDelegates(keys: Keys)(f: (Scope, Seq[Scope]) => Prop): Prop = all(keys.scopes map { scope =>
-    val delegates = keys.env.delegates(scope)
-    ("Scope: " + Scope.display(scope, "_")) |:
-      ("Delegates:\n\t" + delegates.map(scope => Scope.display(scope, "_")).mkString("\n\t")) |:
+  def allDelegates(keys: TestKeys)(f: (Scope, Seq[Scope]) => hedgehog.Result): hedgehog.Result =
+    all(keys.scopes.map { scope =>
+      val delegates = keys.env.delegates(scope)
       f(scope, delegates)
-  }: _*)
-  def alwaysGlobal(s: Scope, ds: Seq[Scope], axis: Scope => ScopeAxis[_]): Prop =
-    (axis(s) != Global) ||
-      all(ds map { d => (axis(d) == Global): Prop }: _*)
-  def globalCombinations(s: Scope, ds: Seq[Scope], axis: Scope => ScopeAxis[_]): Prop =
-    {
-      val value = axis(s)
-      val mods = List[Scope => Scope](_.copy(project = Global), _.copy(config = Global), _.copy(task = Global), _.copy(extra = Global))
-      val modAndIdent = mods.map(_ :: idFun[Scope] :: Nil)
+        .log("Scope: " + Scope.display(scope, "_"))
+        .log("Delegates:\n\t" + delegates.map(scope => Scope.display(scope, "_")).mkString("\n\t"))
+    }.toList)
 
-      def loop(cur: Scope, acc: List[Scope], rem: List[Seq[Scope => Scope]]): Seq[Scope] =
-        rem match {
-          case Nil => acc
-          case x :: xs => x flatMap { mod =>
+  def alwaysZero(s: Scope, ds: Seq[Scope], axis: Scope => ScopeAxis[_]): hedgehog.Result =
+    assert(axis(s) != Zero).or(
+      all(ds.map { d =>
+        axis(d) ==== Zero
+      }.toList)
+    )
+
+  def globalCombinations(s: Scope, ds: Seq[Scope]): hedgehog.Result = {
+    val mods = List[Scope => Scope](
+      _.copy(project = Zero),
+      _.copy(config = Zero),
+      _.copy(task = Zero),
+      _.copy(extra = Zero),
+    )
+    val modAndIdent = mods.map(_ :: idFun[Scope] :: Nil)
+
+    def loop(cur: Scope, acc: List[Scope], rem: List[Seq[Scope => Scope]]): Seq[Scope] =
+      rem match {
+        case Nil => acc
+        case x :: xs =>
+          x flatMap { mod =>
             val s = mod(cur)
             loop(s, s :: acc, xs)
           }
-        }
-      all(loop(s, Nil, modAndIdent).map(ds contains _: Prop): _*)
-    }
+      }
+    all(loop(s, Nil, modAndIdent).map(x => assert(ds contains x)).toList)
+  }
 }
diff --git a/main/src/test/scala/ParseKey.scala b/main/src/test/scala/ParseKey.scala
index 147b54bf2..343e0bfe2 100644
--- a/main/src/test/scala/ParseKey.scala
+++ b/main/src/test/scala/ParseKey.scala
@@ -1,141 +1,198 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import Def.{ displayFull, displayMasked, ScopedKey }
-import sbt.internal.{ TestBuild, Resolve }
-import TestBuild._
-import sbt.internal.util.complete._
-
-import org.scalacheck._
-import Gen._
-import Prop._
-import Arbitrary.arbBool
+import sbt.Def.{ ScopedKey, displayFull, displayMasked }
+import sbt.internal.TestBuild._
+import sbt.internal.util.complete.Parser
+import sbt.internal.{ Resolve, TestBuild }
+import hedgehog._
+import hedgehog.core.{ ShrinkLimit, SuccessCount }
+import hedgehog.runner._
 
 /**
  * Tests that the scoped key parser in Act can correctly parse a ScopedKey converted by Def.show*Key.
  * This includes properly resolving omitted components.
  */
-object ParseKey extends Properties("Key parser test") {
-  final val MaxKeys = 5
-  final val MaxScopedKeys = 100
+object ParseKey extends Properties {
+  val exampleCount = 1000
 
-  implicit val gstructure = genStructure
+  override def tests: List[Test] = List(
+    propertyN(
+      "An explicitly specified axis is always parsed to that explicit value",
+      arbStructureKeyMask.forAll.map(roundtrip),
+      5000
+    ),
+    propertyN(
+      "An unspecified project axis resolves to the current project",
+      arbStructureKeyMask.forAll.map(noProject),
+      5000
+    ),
+    propertyN(
+      "An unspecified task axis resolves to Zero",
+      arbStructureKeyMask.forAll.map(noTask),
+      exampleCount
+    ),
+    propertyN(
+      "An unspecified configuration axis resolves to the first configuration directly defining the key or else Zero",
+      arbStructureKeyMask.forAll.map(noConfig),
+      exampleCount
+    )
+  )
 
-  property("An explicitly specified axis is always parsed to that explicit value") =
-    forAllNoShrink(structureDefinedKey) { (skm: StructureKeyMask) =>
-      import skm.{ structure, key, mask }
+  def propertyN(name: String, result: => Property, n: Int): Test =
+    Test(name, result)
+      .config(_.copy(testLimit = SuccessCount(n), shrinkLimit = ShrinkLimit(n * 10)))
 
-      val expected = resolve(structure, key, mask)
-      val string = displayMasked(key, mask)
+  def roundtrip(skm: StructureKeyMask) = {
+    import skm.{ structure, key }
 
-      ("Key: " + displayFull(key)) |:
-        parseExpected(structure, string, expected, mask)
-    }
+    // if the configuration axis == Zero
+    // then a scoped key like `proj/Zero/Zero/name` could render potentially as `Zero/name`
+    // which would be interpreted as `Zero/Zero/Zero/name` (Global/name)
+    // so we mitigate this by explicitly displaying the configuration axis set to Zero
+    val hasZeroConfig = key.scope.config == Zero
 
-  property("An unspecified project axis resolves to the current project or the build of the current project") =
-    forAllNoShrink(structureDefinedKey) { (skm: StructureKeyMask) =>
-      import skm.{ structure, key }
+    val showZeroConfig = hasZeroConfig || hasAmbiguousLowercaseAxes(key, structure)
+    val mask = if (showZeroConfig) skm.mask.copy(project = true) else skm.mask
 
-      val mask = skm.mask.copy(project = false)
-      val string = displayMasked(key, mask)
-
-      ("Key: " + displayFull(key)) |:
-        ("Mask: " + mask) |:
-        ("Current: " + structure.current) |:
-        parse(structure, string) {
-          case Left(err) => false
-          case Right(sk) => sk.scope.project == Select(structure.current) || sk.scope.project == Select(BuildRef(structure.current.build))
-        }
-    }
-
-  property("An unspecified task axis resolves to Global") =
-    forAllNoShrink(structureDefinedKey) { (skm: StructureKeyMask) =>
-      import skm.{ structure, key }
-      val mask = skm.mask.copy(task = false)
-      val string = displayMasked(key, mask)
-
-      ("Key: " + displayFull(key)) |:
-        ("Mask: " + mask) |:
-        parse(structure, string) {
-          case Left(err) => false
-          case Right(sk) => sk.scope.task == Global
-        }
-    }
-
-  property("An unspecified configuration axis resolves to the first configuration directly defining the key or else Global") =
-    forAllNoShrink(structureDefinedKey) { (skm: StructureKeyMask) =>
-      import skm.{ structure, key }
-      val mask = ScopeMask(config = false)
-      val string = displayMasked(key, mask)
-      val resolvedConfig = Resolve.resolveConfig(structure.extra, key.key, mask)(key.scope).config
-
-      ("Key: " + displayFull(key)) |:
-        ("Mask: " + mask) |:
-        ("Expected configuration: " + resolvedConfig.map(_.name)) |:
-        parse(structure, string) {
-          case Right(sk) => sk.scope.config == resolvedConfig
-          case Left(err) => false
-        }
-    }
-
-  lazy val structureDefinedKey: Gen[StructureKeyMask] = structureKeyMask { s =>
-    for (scope <- TestBuild.scope(s.env); key <- oneOf(s.allAttributeKeys.toSeq)) yield ScopedKey(scope, key)
+    val expected = resolve(structure, key, mask)
+    parseCheck(structure, key, mask, showZeroConfig)(
+      sk =>
+        hedgehog.Result
+          .assert(Project.equal(sk, expected, mask))
+          .log(s"$sk.key == $expected.key: ${sk.key == expected.key}")
+          .log(s"${sk.scope} == ${expected.scope}: ${Scope.equal(sk.scope, expected.scope, mask)}")
+    ).log(s"Expected: ${displayFull(expected)}")
   }
-  def structureKeyMask(genKey: Structure => Gen[ScopedKey[_]])(implicit maskGen: Gen[ScopeMask], structureGen: Gen[Structure]): Gen[StructureKeyMask] =
-    for (mask <- maskGen; structure <- structureGen; key <- genKey(structure)) yield new StructureKeyMask(structure, key, mask)
-  final class StructureKeyMask(val structure: Structure, val key: ScopedKey[_], val mask: ScopeMask)
 
-  def resolve(structure: Structure, key: ScopedKey[_], mask: ScopeMask): ScopedKey[_] =
-    ScopedKey(Resolve(structure.extra, Select(structure.current), key.key, mask)(key.scope), key.key)
+  def noProject(skm: StructureKeyMask) = {
+    import skm.{ structure, key }
+    val mask = skm.mask.copy(project = false)
+    // skip when config axis is set to Zero
+    val hasZeroConfig = key.scope.config ==== Zero
+    val showZeroConfig = hasAmbiguousLowercaseAxes(key, structure)
+    parseCheck(structure, key, mask, showZeroConfig)(
+      sk =>
+        (hasZeroConfig or sk.scope.project ==== Select(structure.current))
+          .log(s"parsed subproject: ${sk.scope.project}")
+          .log(s"current subproject: ${structure.current}")
+    )
+  }
 
-  def parseExpected(structure: Structure, s: String, expected: ScopedKey[_], mask: ScopeMask): Prop =
-    ("Expected: " + displayFull(expected)) |:
-      ("Mask: " + mask) |:
-      parse(structure, s) {
-        case Left(err) => false
-        case Right(sk) => Project.equal(sk, expected, mask)
-      }
+  def noTask(skm: StructureKeyMask) = {
+    import skm.{ structure, key }
+    val mask = skm.mask.copy(task = false)
+    parseCheck(structure, key, mask)(_.scope.task ==== Zero)
+  }
 
-  def parse(structure: Structure, s: String)(f: Either[String, ScopedKey[_]] => Prop): Prop =
-    {
-      val parser = makeParser(structure)
-      val parsed = DefaultParsers.result(parser, s).left.map(_().toString)
-      val showParsed = parsed.right.map(displayFull)
-      ("Key string: '" + s + "'") |:
-        ("Parsed: " + showParsed) |:
-        ("Structure: " + structure) |:
-        f(parsed)
-    }
+  def noConfig(skm: StructureKeyMask) = {
+    import skm.{ structure, key }
+    val mask = ScopeMask(config = false)
+    val resolvedConfig = Resolve.resolveConfig(structure.extra, key.key, mask)(key.scope).config
+    val showZeroConfig = hasAmbiguousLowercaseAxes(key, structure)
+    parseCheck(structure, key, mask, showZeroConfig)(
+      sk => (sk.scope.config ==== resolvedConfig) or (sk.scope ==== Scope.GlobalScope)
+    ).log(s"Expected configuration: ${resolvedConfig map (_.name)}")
+  }
 
-  // Here we're shadowing the in-scope implicit called `mkEnv` for this method
-  // so that it will use the passed-in `Gen` rather than the one imported
-  // from TestBuild.
-  def genStructure(implicit mkEnv: Gen[Env]): Gen[Structure] =
-    structureGenF { (scopes: Seq[Scope], env: Env, current: ProjectRef) =>
-      val settings =
-        for {
-          scope <- scopes
-          t <- env.tasks
-        } yield Def.setting(ScopedKey(scope, t.key), Def.value(""))
+  val arbStructure: Gen[Structure] =
+    for {
+      env <- mkEnv
+      loadFactor <- Gen.double(Range.linearFrac(0.0, 1.0))
+      scopes <- pickN(loadFactor, env.allFullScopes)
+      current <- oneOf(env.allProjects.unzip._1)
+    } yield {
+      val settings = structureSettings(scopes, env)
       TestBuild.structure(env, settings, current)
     }
 
-  // Here we're shadowing the in-scope implicit called `mkEnv` for this method
-  // so that it will use the passed-in `Gen` rather than the one imported
-  // from TestBuild.
-  def structureGenF(f: (Seq[Scope], Env, ProjectRef) => Structure)(implicit mkEnv: Gen[Env]): Gen[Structure] =
-    structureGen((s, e, p) => Gen.const(f(s, e, p)))
-  // Here we're shadowing the in-scope implicit called `mkEnv` for this method
-  // so that it will use the passed-in `Gen` rather than the one imported
-  // from TestBuild.
-  def structureGen(f: (Seq[Scope], Env, ProjectRef) => Gen[Structure])(implicit mkEnv: Gen[Env]): Gen[Structure] =
+  def structureSettings(scopes: Seq[Scope], env: Env): Seq[Def.Setting[String]] = {
     for {
-      env <- mkEnv
-      loadFactor <- choose(0.0, 1.0)
-      scopes <- pickN(loadFactor, env.allFullScopes)
-      current <- oneOf(env.allProjects.unzip._1)
-      structure <- f(scopes, env, current)
-    } yield structure
+      scope <- scopes
+      t <- env.tasks
+    } yield Def.setting(ScopedKey(scope, t.key), Def.value(""))
+  }
 
+  final case class StructureKeyMask(structure: Structure, key: ScopedKey[_], mask: ScopeMask)
+
+  val arbStructureKeyMask: Gen[StructureKeyMask] =
+    (for {
+      structure <- arbStructure
+      // NOTE: Generating this after the structure improves shrinking
+      mask <- maskGen
+      key <- for {
+        scope <- TestBuild.scope(structure.env)
+        key <- oneOf(structure.allAttributeKeys.toSeq)
+      } yield ScopedKey(scope, key)
+      skm = StructureKeyMask(structure, key, mask)
+    } yield skm)
+      .filter(configExistsInIndex)
+
+  private def configExistsInIndex(skm: StructureKeyMask): Boolean = {
+    import skm._
+    val resolvedKey = resolve(structure, key, mask)
+    val proj = resolvedKey.scope.project.toOption
+    val maybeResolvedProj = proj.collect {
+      case ref: ResolvedReference => ref
+    }
+    val checkName = for {
+      configKey <- resolvedKey.scope.config.toOption
+    } yield {
+      val configID = Scope.display(configKey)
+      // This only works for known configurations or those that were guessed correctly.
+      val name = structure.keyIndex.fromConfigIdent(maybeResolvedProj)(configID)
+      name == configKey.name
+    }
+    checkName.getOrElse(true)
+  }
+
+  def resolve(structure: Structure, key: ScopedKey[_], mask: ScopeMask): ScopedKey[_] =
+    ScopedKey(
+      Resolve(structure.extra, Select(structure.current), key.key, mask)(key.scope),
+      key.key
+    )
+
+  def parseCheck(
+      structure: Structure,
+      key: ScopedKey[_],
+      mask: ScopeMask,
+      showZeroConfig: Boolean = false,
+  )(f: ScopedKey[_] => hedgehog.Result): hedgehog.Result = {
+    val s = displayMasked(key, mask, showZeroConfig)
+    val parser = makeParser(structure)
+    val parsed = Parser.result(parser, s).left.map(_().toString)
+    (
+      parsed
+        .fold(_ => hedgehog.Result.failure, f)
+        .log(s"Key: ${Scope.displayPedantic(key.scope, key.key.label)}")
+        .log(s"Mask: $mask")
+        .log(s"Key string: '$s'")
+        .log(s"Parsed: ${parsed.right.map(displayFull)}")
+        .log(s"Structure: $structure")
+      )
+  }
+
+  // pickN is a function that randomly picks load % items from the "from" sequence.
+  // The rest of the tests expect at least one item, so I changed it to return 1 in case of 0.
   def pickN[T](load: Double, from: Seq[T]): Gen[Seq[T]] =
-    pick((load * from.size).toInt, from)
+    pick((load * from.size).toInt max 1, from)
+
+  // if both a project and a key share the same name (e.g. "foo")
+  // then a scoped key like `foo/<conf>/foo/name` would render as `foo/name`
+  // which would be interpreted as `foo/Zero/Zero/name`
+  // so we mitigate this by explicitly displaying the configuration axis set to Zero
+  def hasAmbiguousLowercaseAxes(key: ScopedKey[_], structure: Structure): Boolean = {
+    val label = key.key.label
+    val allProjects = for {
+      uri <- structure.keyIndex.buildURIs
+      project <- structure.keyIndex.projects(uri)
+    } yield project
+    allProjects(label)
+  }
 }
diff --git a/main/src/test/scala/ParserSpec.scala b/main/src/test/scala/ParserSpec.scala
new file mode 100644
index 000000000..5022fa9d3
--- /dev/null
+++ b/main/src/test/scala/ParserSpec.scala
@@ -0,0 +1,72 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.net.URI
+
+import sbt.Def._
+import sbt.internal.TestBuild
+import sbt.internal.TestBuild._
+import sbt.internal.util.AttributeKey
+import sbt.internal.util.complete.DefaultParsers
+import sbt.librarymanagement.Configuration
+import hedgehog._
+import hedgehog.runner._
+
+object ParserSpec extends Properties {
+  override def tests: List[Test] =
+    List(
+      property("can parse any build", TestBuild.uriGen.forAll.map { uri =>
+        parse(buildURI = uri)
+      }),
+      property("can parse any project", TestBuild.nonEmptyId.forAll.map { id =>
+        parse(projectID = id)
+      }),
+      property("can parse any configuration", TestBuild.nonEmptyId.map(_.capitalize).forAll.map {
+        name =>
+          parse(configName = name)
+      }),
+      property("can parse any attribute", TestBuild.kebabIdGen.forAll.map { name =>
+        parse(attributeName = name)
+      })
+    )
+
+  private def parse(
+      buildURI: URI = new java.net.URI("file", "///path/", null),
+      projectID: String = "p",
+      configName: String = "c",
+      attributeName: String = "a"
+  ) = {
+    val attributeKey = AttributeKey[String](attributeName)
+    val scope = Scope(
+      Select(BuildRef(buildURI)),
+      Select(ConfigKey(configName)),
+      Select(attributeKey),
+      Zero
+    )
+    val scopedKey = ScopedKey(scope, attributeKey)
+    val config = Configuration.of(configName.capitalize, configName)
+    val project = Proj(projectID, Nil, Seq(config))
+    val projects = Vector(project)
+    val build = Build(buildURI, projects)
+    val builds = Vector(build)
+    val task = Taskk(attributeKey, Nil)
+    val tasks = Vector(task)
+    val env = Env(builds, tasks)
+    val settings = env.tasks.map { t =>
+      Def.setting(ScopedKey(scope, t.key), Def.value("value"))
+    }
+    val structure = TestBuild.structure(env, settings, build.allProjects.head._1)
+    val string = displayMasked(scopedKey, ScopeMask())
+    val parser = makeParser(structure)
+    val result = DefaultParsers.result(parser, string)
+    val resultStr = result.fold(_ => "<parse error>", _.toString)
+    (result ==== Right(scopedKey))
+      .log(s"$string parsed back to $resultStr rather than $scopedKey")
+  }
+}
diff --git a/main/src/test/scala/PluginCommandTest.scala b/main/src/test/scala/PluginCommandTest.scala
index 2ce29a6dd..46ec1c753 100644
--- a/main/src/test/scala/PluginCommandTest.scala
+++ b/main/src/test/scala/PluginCommandTest.scala
@@ -1,11 +1,24 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import java.io._
 
-import org.specs2.mutable.Specification
-
 import sbt.internal._
-import sbt.internal.util.{ AttributeEntry, AttributeMap, ConsoleOut, GlobalLogging, MainLogging, Settings }
+import sbt.internal.util.{
+  AttributeEntry,
+  AttributeMap,
+  ConsoleOut,
+  GlobalLogging,
+  MainAppender,
+  Settings,
+  Terminal => ITerminal,
+}
 
 object PluginCommandTestPlugin0 extends AutoPlugin { override def requires = empty }
 
@@ -15,51 +28,61 @@ package subpackage {
 
 }
 
-object PluginCommandTest extends Specification {
-  sequential
-
+object PluginCommandTest extends verify.BasicTestSuite {
   import subpackage._
   import FakeState._
 
-  "The `plugin` command" should {
-
-    "should work for plugins within nested in one package" in {
-      val output = processCommand("plugin sbt.PluginCommandTestPlugin0", PluginCommandTestPlugin0, PluginCommandTestPlugin1)
-      output must contain("sbt.PluginCommandTestPlugin0 is activated.")
-    }
-
-    "should work for plugins nested more than one package" in {
-      val output = processCommand("plugin sbt.subpackage.PluginCommandTestPlugin1", PluginCommandTestPlugin0, PluginCommandTestPlugin1)
-      output must contain("sbt.subpackage.PluginCommandTestPlugin1 is activated.")
-    }
-
-    "suggest a plugin when given an incorrect plugin with a similar name" in {
-      val output = processCommand("plugin PluginCommandTestPlugin0", PluginCommandTestPlugin0, PluginCommandTestPlugin1)
-      output must contain(
-        "Not a valid plugin: PluginCommandTestPlugin0 (similar: sbt.PluginCommandTestPlugin0, sbt.subpackage.PluginCommandTestPlugin1)"
-      )
-    }
-
+  test("`plugin` command should work for plugins within nested in one package") {
+    val output = processCommand(
+      "plugin sbt.PluginCommandTestPlugin0",
+      PluginCommandTestPlugin0,
+      PluginCommandTestPlugin1
+    )
+    assert(output.contains("sbt.PluginCommandTestPlugin0 is activated."))
   }
 
+  test("it should work for plugins nested more than one package") {
+    val output = processCommand(
+      "plugin sbt.subpackage.PluginCommandTestPlugin1",
+      PluginCommandTestPlugin0,
+      PluginCommandTestPlugin1
+    )
+    assert(output.contains("sbt.subpackage.PluginCommandTestPlugin1 is activated."))
+  }
+
+  test("it should suggest a plugin when given an incorrect plugin with a similar name") {
+
+    val output = processCommand(
+      "plugin PluginCommandTestPlugin0",
+      PluginCommandTestPlugin0,
+      PluginCommandTestPlugin1
+    )
+    assert(
+      output.contains(
+        "Not a valid plugin: PluginCommandTestPlugin0 (similar: sbt.PluginCommandTestPlugin0, sbt.subpackage.PluginCommandTestPlugin1)"
+      )
+    )
+  }
 }
 
 object FakeState {
 
   def processCommand(input: String, enabledPlugins: AutoPlugin*): String = {
-    val previousOut = System.out
     val outBuffer = new ByteArrayOutputStream
+    val logFile = File.createTempFile("sbt", ".log")
     try {
-      System.setOut(new PrintStream(outBuffer, true))
-      val state = FakeState(enabledPlugins: _*)
-      Command.process(input, state)
+      val state = FakeState(logFile, enabledPlugins: _*)
+      ITerminal.withOut(new PrintStream(outBuffer, true)) {
+        MainLoop.processCommand(Exec(input, None), state)
+      }
       new String(outBuffer.toByteArray)
     } finally {
-      System.setOut(previousOut)
+      logFile.delete()
+      ()
     }
   }
 
-  def apply(plugins: AutoPlugin*) = {
+  def apply(logFile: File, plugins: AutoPlugin*) = {
 
     val base = new File("").getAbsoluteFile
     val testProject = Project("test-project", base).setAutoPlugins(plugins)
@@ -68,33 +91,54 @@ object FakeState {
 
     val currentProject = Map(testProject.base.toURI -> testProject.id)
     val currentEval: () => sbt.compiler.Eval = () => Load.mkEval(Nil, base, Nil)
-    val sessionSettings = SessionSettings(base.toURI, currentProject, Nil, Map.empty, Nil, currentEval)
+    val sessionSettings =
+      SessionSettings(base.toURI, currentProject, Nil, Map.empty, Nil, currentEval)
 
     val delegates: (Scope) => Seq[Scope] = _ => Nil
     val scopeLocal: Def.ScopeLocal = _ => Nil
 
-    val data: Settings[Scope] = Def.make(settings)(delegates, scopeLocal, Def.showFullKey)
-    val extra: KeyIndex => BuildUtil[_] = (keyIndex) => BuildUtil(base.toURI, Map.empty, keyIndex, data)
-    val structureIndex: StructureIndex = Load.structureIndex(data, settings, extra, Map.empty)
+    val (cMap, data: Settings[Scope]) =
+      Def.makeWithCompiledMap(settings)(delegates, scopeLocal, Def.showFullKey)
+    val extra: KeyIndex => BuildUtil[_] = (keyIndex) =>
+      BuildUtil(base.toURI, Map.empty, keyIndex, data)
+    val structureIndex: StructureIndex =
+      Load.structureIndex(data, settings, extra, Map.empty)
     val streams: (State) => BuildStreams.Streams = null
 
     val loadedDefinitions: LoadedDefinitions = new LoadedDefinitions(
-      base, Nil, ClassLoader.getSystemClassLoader, Nil, Seq(testProject), Nil
+      base,
+      Nil,
+      ClassLoader.getSystemClassLoader,
+      Nil,
+      Seq(testProject),
+      Nil
     )
 
     val pluginData = PluginData(Nil, Nil, None, None, Nil)
     val builds: DetectedModules[BuildDef] = new DetectedModules[BuildDef](Nil)
 
-    val detectedAutoPlugins: Seq[DetectedAutoPlugin] = plugins.map(p => DetectedAutoPlugin(p.label, p, hasAutoImport = false))
+    val detectedAutoPlugins: Seq[DetectedAutoPlugin] =
+      plugins.map(p => DetectedAutoPlugin(p.label, p, hasAutoImport = false))
     val detectedPlugins = new DetectedPlugins(detectedAutoPlugins, builds)
-    val loadedPlugins = new LoadedPlugins(base, pluginData, ClassLoader.getSystemClassLoader, detectedPlugins)
+    val loadedPlugins =
+      new LoadedPlugins(base, pluginData, ClassLoader.getSystemClassLoader, detectedPlugins)
     val buildUnit = new BuildUnit(base.toURI, base, loadedDefinitions, loadedPlugins)
 
     val (partBuildUnit: PartBuildUnit, _) = Load.loaded(buildUnit)
     val loadedBuildUnit = Load.resolveProjects(base.toURI, partBuildUnit, _ => testProject.id)
 
     val units = Map(base.toURI -> loadedBuildUnit)
-    val buildStructure = new BuildStructure(units, base.toURI, settings, data, structureIndex, streams, delegates, scopeLocal)
+    val buildStructure = new BuildStructure(
+      units,
+      base.toURI,
+      settings,
+      data,
+      structureIndex,
+      streams,
+      delegates,
+      scopeLocal,
+      cMap,
+    )
 
     val attributes = AttributeMap.empty ++ AttributeMap(
       AttributeEntry(Keys.sessionSettings, sessionSettings),
@@ -106,10 +150,15 @@ object FakeState {
       Seq(BuiltinCommands.plugin),
       Set.empty,
       None,
-      Seq.empty,
+      List(),
       State.newHistory,
       attributes,
-      GlobalLogging.initial(MainLogging.globalDefault(ConsoleOut.systemOut), File.createTempFile("sbt", ".log"), ConsoleOut.systemOut),
+      GlobalLogging.initial(
+        MainAppender.globalDefault(ConsoleOut.globalProxy),
+        logFile,
+        ConsoleOut.globalProxy
+      ),
+      None,
       State.Continue
     )
 
diff --git a/main/src/test/scala/PluginsTest.scala b/main/src/test/scala/PluginsTest.scala
index 575c85d35..a3be3a322 100644
--- a/main/src/test/scala/PluginsTest.scala
+++ b/main/src/test/scala/PluginsTest.scala
@@ -1,90 +1,108 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import org.specs2._
-import mutable.Specification
 import sbt.util.Logger
 
-object PluginsTest extends Specification
-{
-	import AI._
+object PluginsTest extends verify.BasicTestSuite {
+  import AI._
 
-	"Auto plugin" should {
-		"enable plugins with trigger=allRequirements AND requirements met" in {
-			deducePlugin(A && B, log) must contain(Q)
-		}
-		"enable transitive plugins with trigger=allRequirements AND requirements met" in {
-			deducePlugin(A && B, log) must contain(R)
-		}
-		"order enable plugins after required plugins" in {
-			val ns = deducePlugin(A && B, log)
-			( (ns indexOf Q) must beGreaterThan(ns indexOf A) ) and
-			( (ns indexOf Q) must beGreaterThan(ns indexOf B) ) and
-			( (ns indexOf R) must beGreaterThan(ns indexOf A) ) and
-			( (ns indexOf R) must beGreaterThan(ns indexOf B) ) and
-			( (ns indexOf R) must beGreaterThan(ns indexOf Q) )	
-		}
-		"not enable plugins with trigger=allRequirements but conflicting requirements" in {
-			deducePlugin(A && B, log) must not contain(S)
-		}
-		"enable plugins that are required by the requested plugins" in {
-			val ns = deducePlugin(Q, log)
-			(ns must contain(A)) and
-			(ns must contain(B))
-		}
-		"throw an AutoPluginException on conflicting requirements" in {
-			deducePlugin(S, log) must throwAn[AutoPluginException](message = """Contradiction in enabled plugins:
-  - requested: sbt.AI\$S
-  - enabled: sbt.AI\$S, sbt.AI\$Q, sbt.AI\$R, sbt.AI\$B, sbt.AI\$A
-  - conflict: sbt.AI\$R is enabled by sbt.AI\$Q; excluded by sbt.AI\$S""")
-		}
-		"generates a detailed report on conflicting requirements" in {
-			deducePlugin(T && U, log) must throwAn[AutoPluginException](message = """Contradiction in enabled plugins:
-  - requested: sbt.AI\$T && sbt.AI\$U
-  - enabled: sbt.AI\$U, sbt.AI\$T, sbt.AI\$A, sbt.AI\$Q, sbt.AI\$R, sbt.AI\$B
-  - conflict: sbt.AI\$Q is enabled by sbt.AI\$A && sbt.AI\$B; required by sbt.AI\$T, sbt.AI\$R; excluded by sbt.AI\$U
-  - conflict: sbt.AI\$R is enabled by sbt.AI\$Q; excluded by sbt.AI\$T""")
-		}
-	}
+  test("Auto plugin should enable plugins with trigger=allRequirements AND requirements met") {
+    assert(deducePlugin(A && B, log).contains(Q))
+  }
+
+  test("it should enable transitive plugins with trigger=allRequirements AND requirements met") {
+    assert(deducePlugin(A && B, log) contains (R))
+  }
+
+  test("it should order enable plugins after required plugins") {
+    val ns = deducePlugin(A && B, log)
+    assert((ns indexOf Q) > (ns indexOf A))
+    assert((ns indexOf Q) > (ns indexOf B))
+    assert((ns indexOf R) > (ns indexOf A))
+    assert((ns indexOf R) > (ns indexOf B))
+    assert((ns indexOf R) > (ns indexOf Q))
+  }
+
+  test("it should not enable plugins with trigger=allRequirements but conflicting requirements") {
+    assert(!deducePlugin(A && B, log).contains(S))
+  }
+
+  test("it should enable plugins that are required by the requested plugins") {
+    val ns = deducePlugin(Q, log)
+    assert(ns.contains(A))
+    assert(ns.contains(B))
+  }
+
+  test("it should throw an AutoPluginException on conflicting requirements") {
+    try {
+      deducePlugin(S, log)
+    } catch {
+      case e: AutoPluginException =>
+        assertEquals(
+          s"""Contradiction in enabled plugins:
+  - requested: sbt.AI$$S
+  - enabled: sbt.AI$$S, sbt.AI$$Q, sbt.AI$$R, sbt.AI$$B, sbt.AI$$A
+  - conflict: sbt.AI$$R is enabled by sbt.AI$$Q; excluded by sbt.AI$$S""",
+          e.message
+        )
+    }
+  }
+
+  test("it should generate a detailed report on conflicting requirements") {
+    try {
+      deducePlugin(T && U, log)
+    } catch {
+      case e: AutoPluginException =>
+        assertEquals(
+          s"""Contradiction in enabled plugins:
+  - requested: sbt.AI$$T && sbt.AI$$U
+  - enabled: sbt.AI$$U, sbt.AI$$T, sbt.AI$$A, sbt.AI$$Q, sbt.AI$$R, sbt.AI$$B
+  - conflict: sbt.AI$$Q is enabled by sbt.AI$$A && sbt.AI$$B; required by sbt.AI$$T, sbt.AI$$R; excluded by sbt.AI$$U
+  - conflict: sbt.AI$$R is enabled by sbt.AI$$Q; excluded by sbt.AI$$T""",
+          e.message
+        )
+    }
+  }
 }
 
-object AI
-{
-	lazy val allPlugins: List[AutoPlugin] = List(A, B, Q, R, S, T, U)
-	lazy val deducePlugin = Plugins.deducer(allPlugins)
-	lazy val log = Logger.Null
+object AI {
+  lazy val allPlugins: List[AutoPlugin] = List(A, B, Q, R, S, T, U)
+  lazy val deducePlugin = Plugins.deducer(allPlugins)
+  lazy val log = Logger.Null
 
-	object A extends AutoPlugin { override def requires = empty }
-	object B extends AutoPlugin { override def requires = empty }
+  object A extends AutoPlugin { override def requires = empty }
+  object B extends AutoPlugin { override def requires = empty }
 
-	object Q extends AutoPlugin
-	{
-		override def requires: Plugins = A && B
-		override def trigger = allRequirements
-	}
+  object Q extends AutoPlugin {
+    override def requires: Plugins = A && B
+    override def trigger = allRequirements
+  }
 
-	object R extends AutoPlugin
-	{
-		override def requires = Q
-		override def trigger = allRequirements
-	}
+  object R extends AutoPlugin {
+    override def requires = Q
+    override def trigger = allRequirements
+  }
 
-	object S extends AutoPlugin
-	{
-		override def requires = Q && !R
-		override def trigger = allRequirements
-	}
+  object S extends AutoPlugin {
+    override def requires = Q && !R
+    override def trigger = allRequirements
+  }
 
-	// This is an opt-in plugin with a requirement
-	// Unless explicitly loaded by the build user, this will not be activated.
-	object T extends AutoPlugin
-	{
-		override def requires = Q && !R
-	}
+  // This is an opt-in plugin with a requirement
+  // Unless explicitly loaded by the build user, this will not be activated.
+  object T extends AutoPlugin {
+    override def requires = Q && !R
+  }
 
-	// This is an opt-in plugin with a requirement
-	// Unless explicitly loaded by the build user, this will not be activated.
-	object U extends AutoPlugin
-	{
-		override def requires = A && !Q
-	}
+  // This is an opt-in plugin with a requirement
+  // Unless explicitly loaded by the build user, this will not be activated.
+  object U extends AutoPlugin {
+    override def requires = A && !Q
+  }
 }
diff --git a/main/src/test/scala/ProjectMacro.scala b/main/src/test/scala/ProjectMacro.scala
index 55575e630..d66146688 100644
--- a/main/src/test/scala/ProjectMacro.scala
+++ b/main/src/test/scala/ProjectMacro.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import scala.util.control.NonFatal
@@ -25,13 +32,14 @@ object ProjectMacro extends Properties("ProjectMacro") {
   lazy val pd = new ProjectDefs
   import pd._
 
-  def secure(f: => Prop): Prop = try {
-    Prop.secure(f)
-  } catch {
-    case NonFatal(e) =>
-      e.printStackTrace
-      throw e
-  }
+  def secure(f: => Prop): Prop =
+    try {
+      Prop.secure(f)
+    } catch {
+      case NonFatal(e) =>
+        e.printStackTrace
+        throw e
+    }
 
   property("Explicit type on lazy val supported") = secure {
     check(aa, "aa", "aa")
@@ -53,13 +61,12 @@ object ProjectMacro extends Properties("ProjectMacro") {
     check(z, "z", "dir")
   }
 
-  def check(p: Project, id: String, dir: String): Prop =
-    {
-      s"Expected id: $id" |:
-        s"Expected dir: $dir" |:
-        s"Actual id: ${p.id}" |:
-        s"Actual dir: ${p.base}" |:
-        (p.id == id) &&
-        (p.base.getName == dir)
-    }
+  def check(p: Project, id: String, dir: String): Prop = {
+    s"Expected id: $id" |:
+      s"Expected dir: $dir" |:
+      s"Actual id: ${p.id}" |:
+      s"Actual dir: ${p.base}" |:
+      (p.id == id) &&
+    (p.base.getName == dir)
+  }
 }
diff --git a/main/src/test/scala/ProjectSpec.scala b/main/src/test/scala/ProjectSpec.scala
index 5dd9d6511..aa61bac9c 100644
--- a/main/src/test/scala/ProjectSpec.scala
+++ b/main/src/test/scala/ProjectSpec.scala
@@ -1,18 +1,16 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import org.specs2.Specification
-
-class ProjectSpec extends Specification {
-  def is = s2"""
-
-  This is a specification to check utility methods on the Project object
-
-  Project should
-    normalize projectIDs if they are empty  ${normalizeEmptyFileName}
-
-  """
+object ProjectSpec extends verify.BasicTestSuite {
+  test("Project should normalize projectIDs if they are empty") {
+    assert(Project.normalizeProjectID(emptyFilename) == Right("root"))
+  }
 
   def emptyFilename = ""
-
-  def normalizeEmptyFileName = Project.normalizeProjectID(emptyFilename) must equalTo(Right("root"))
-}
\ No newline at end of file
+}
diff --git a/main/src/test/scala/TagsTest.scala b/main/src/test/scala/TagsTest.scala
index 9fa087908..d56160df9 100644
--- a/main/src/test/scala/TagsTest.scala
+++ b/main/src/test/scala/TagsTest.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import org.scalacheck._
@@ -9,24 +16,29 @@ object TagsTest extends Properties("Tags") {
   final case class Size(value: Int)
 
   def tagMap: Gen[TagMap] = for (ts <- listOf(tagAndFrequency)) yield ts.toMap
-  def tagAndFrequency: Gen[(Tag, Int)] = for (t <- tag; count <- Arbitrary.arbitrary[Int]) yield (t, count)
+  def tagAndFrequency: Gen[(Tag, Int)] =
+    for (t <- tag; count <- Arbitrary.arbitrary[Int]) yield (t, count)
   def tag: Gen[Tag] = for (s <- Gen.alphaStr if !s.isEmpty) yield Tag(s)
-  def size: Gen[Size] = for (i <- Arbitrary.arbitrary[Int] if i != Int.MinValue) yield Size(math.abs(i))
+  def size: Gen[Size] =
+    for (i <- Arbitrary.arbitrary[Int] if i != Int.MinValue) yield Size(math.abs(i))
 
   implicit def aTagMap = Arbitrary(tagMap)
   implicit def aTagAndFrequency = Arbitrary(tagAndFrequency)
   implicit def aTag = Arbitrary(tag)
   implicit def aSize = Arbitrary(size)
 
-  property("exclusive allows all groups without the exclusive tag") = forAll { (tm: TagMap, tag: Tag) =>
-    excl(tag)(tm - tag)
+  property("exclusive allows all groups without the exclusive tag") = forAll {
+    (tm: TagMap, tag: Tag) =>
+      excl(tag)(tm - tag)
   }
 
-  property("exclusive only allows a group with an excusive tag when the size is one") = forAll { (tm: TagMap, size: Size, etag: Tag) =>
-    val absSize = size.value
-    val tm2: TagMap = tm.updated(etag, absSize).updated(Tags.All, tm.getOrElse(Tags.All, 0) + absSize)
-    (s"TagMap: $tm2") |:
-      (excl(etag)(tm2) == (absSize <= 1))
+  property("exclusive only allows a group with an excusive tag when the size is one") = forAll {
+    (tm: TagMap, size: Size, etag: Tag) =>
+      val absSize = size.value
+      val tm2: TagMap =
+        tm.updated(etag, absSize).updated(Tags.All, tm.getOrElse(Tags.All, 0) + absSize)
+      (s"TagMap: $tm2") |:
+        (excl(etag)(tm2) == (absSize <= 1))
   }
 
   property("exclusive always allows a group of size one") = forAll { (etag: Tag, mapTag: Tag) =>
diff --git a/main/src/test/scala/sbt/internal/AggregationSpec.scala b/main/src/test/scala/sbt/internal/AggregationSpec.scala
new file mode 100644
index 000000000..f8c7f7179
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/AggregationSpec.scala
@@ -0,0 +1,24 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+object AggregationSpec extends verify.BasicTestSuite {
+  val timing = Aggregation.timing(Aggregation.defaultFormat, 0, _: Long)
+
+  test("timing should format total time properly") {
+    assert(timing(101).startsWith("Total time: 0 s,"))
+    assert(timing(1000).startsWith("Total time: 1 s,"))
+    assert(timing(3000).startsWith("Total time: 3 s,"))
+    assert(timing(30399).startsWith("Total time: 30 s,"))
+    assert(timing(60399).startsWith("Total time: 60 s,"))
+    assert(timing(60699).startsWith("Total time: 61 s (01:01),"))
+    assert(timing(303099).startsWith("Total time: 303 s (05:03),"))
+    assert(timing(6003099).startsWith("Total time: 6003 s (01:40:03),"))
+    assert(timing(96003099).startsWith("Total time: 96003 s (26:40:03),"))
+  }
+}
diff --git a/main/src/test/scala/sbt/internal/CrossJavaTest.scala b/main/src/test/scala/sbt/internal/CrossJavaTest.scala
new file mode 100644
index 000000000..b7a21fdf6
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/CrossJavaTest.scala
@@ -0,0 +1,184 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import org.scalatest._
+import sbt.internal.CrossJava.JavaDiscoverConfig._
+import scala.collection.immutable.ListMap
+
+class CrossJavaTest extends FunSuite with DiagrammedAssertions {
+  test("The Java home selector should select the most recent") {
+    assert(
+      List("jdk1.8.0.jdk", "jdk1.8.0_121.jdk", "jdk1.8.0_45.jdk")
+        .sortWith(CrossJava.versionOrder)
+        .last == "jdk1.8.0_121.jdk"
+    )
+  }
+
+  test("The Linux Java home selector should correctly pick up Fedora Java installations") {
+    val conf = new LinuxDiscoverConfig(sbt.io.syntax.file(".")) {
+      override def candidates(): Vector[String] =
+        """
+            |java-1.8.0-openjdk-1.8.0.162-3.b12.fc28.x86_64
+            |java-1.8.0-openjdk-1.8.0.172-9.b11.fc28.x86_64
+            |java-1.8.0
+            |java-1.8.0-openjdk
+            |java-openjdk
+            |jre-1.8.0
+            |jre-1.8.0-openjdk
+            |jre-1.8.0-openjdk-1.8.0.172-9.b11.fc28.x86_64
+            |jre-openjdk
+          """.stripMargin.split("\n").filter(_.nonEmpty).toVector
+    }
+    val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
+    assert(version == "1.8")
+    assert(file.getName == "java-1.8.0-openjdk-1.8.0.172-9.b11.fc28.x86_64")
+  }
+
+  test("The Linux Java home selector should correctly pick up Oracle RPM installations") {
+    val conf = new LinuxDiscoverConfig(sbt.io.syntax.file(".")) {
+      override def candidates(): Vector[String] = Vector("jdk1.8.0_172-amd64")
+    }
+    val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
+    assert(version == "1.8")
+    assert(file.getName == "jdk1.8.0_172-amd64")
+  }
+
+  test("The Windows Java home selector should correctly pick up a JDK") {
+    val conf = new WindowsDiscoverConfig(sbt.io.syntax.file(".")) {
+      override def candidates() = Vector("jdk1.7.0")
+    }
+    val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
+    assert(version == "1.7")
+    assert(file.getName == "jdk1.7.0")
+  }
+
+  test("The JAVA_HOME selector should correctly pick up a JDK") {
+    val conf = new JavaHomeDiscoverConfig {
+      override def home() = Some("/opt/jdk8")
+    }
+    val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
+    assert(version == "8")
+    assert(file.getName == "jdk8")
+  }
+
+  test("The JAVA_HOME selector should correctly pick up an Oracle JDK") {
+    val conf = new JavaHomeDiscoverConfig {
+      override def home() = Some("/opt/oracle-jdk-bin-1.8.0.181")
+    }
+    val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
+    assert(version == "1.8")
+    assert(file.getName == "oracle-jdk-bin-1.8.0.181")
+  }
+
+  test("The SDKMAN selector should correctly pick up an AdoptOpenJDK") {
+    val conf = new SdkmanDiscoverConfig {
+      override def candidates() = Vector("11.0.2.hs-adpt")
+    }
+    val (version, file) = conf.javaHomes.sortWith(CrossJava.versionOrder).last
+    assert(version == "adopt@11.0.2")
+    assert(file.getName == "11.0.2.hs-adpt")
+  }
+
+  test("expandJavaHomes") {
+    val conf = new SdkmanDiscoverConfig {
+      override def candidates() = Vector("11.0.2.hs-adpt")
+    }
+    val hs = CrossJava.expandJavaHomes(ListMap(conf.javaHomes: _*))
+    assert(hs.contains("11"))
+  }
+
+  test("SDKMAN candidate parsing") {
+    assert(
+      CrossJava
+        .parseSdkmanString("11.0.2.hs-adpt")
+        .get == JavaVersion(Vector(11L, 0L, 2L), Some("adopt"))
+    )
+    assert(
+      CrossJava
+        .parseSdkmanString("11.0.2.j9-adpt")
+        .get == JavaVersion(
+        Vector(11L, 0L, 2L),
+        Some("adopt-openj9")
+      )
+    )
+    assert(
+      CrossJava
+        .parseSdkmanString("13.ea.13-open")
+        .get == JavaVersion(
+        Vector(13L),
+        Vector("ea13"),
+        Some("openjdk")
+      )
+    )
+    assert(
+      CrossJava
+        .parseSdkmanString("12.0.0-zulu")
+        .get == JavaVersion(
+        Vector(12L, 0L, 0L),
+        Some("zulu")
+      )
+    )
+    assert(
+      CrossJava
+        .parseSdkmanString("8u152-zulu")
+        .get == JavaVersion(
+        Vector(8L, 0L, 152L),
+        Vector(),
+        Some("zulu")
+      )
+    )
+    assert(
+      CrossJava
+        .parseSdkmanString("8x152-zulu")
+        .isFailure
+    )
+    assert(
+      CrossJava
+        .parseSdkmanString("8.0.201-oracle")
+        .get == JavaVersion(
+        Vector(8L, 0L, 201L),
+        Some("oracle")
+      )
+    )
+    assert(
+      CrossJava
+        .parseSdkmanString("1.0.0-rc-14-grl")
+        .get == JavaVersion(
+        Vector(1L, 0L, 0L),
+        Vector("rc14"),
+        Some("graalvm")
+      )
+    )
+  }
+
+  test("SDKMAN version can round trip") {
+    assert(
+      CrossJava.parseJavaVersion(
+        CrossJava
+          .parseSdkmanString("11.0.2.hs-adpt")
+          .get
+          .toString
+      ) == JavaVersion(Vector(11L, 0L, 2L), Some("adopt"))
+    )
+
+    assert(
+      CrossJava.parseJavaVersion(
+        CrossJava
+          .parseSdkmanString("1.0.0-rc-14-grl")
+          .get
+          .toString
+      ) == JavaVersion(
+        Vector(1L, 0L, 0L),
+        Vector("rc14"),
+        Some("graalvm")
+      )
+    )
+  }
+}
diff --git a/main/src/test/scala/sbt/internal/FileStampJsonSpec.scala b/main/src/test/scala/sbt/internal/FileStampJsonSpec.scala
new file mode 100644
index 000000000..fe4dacb53
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/FileStampJsonSpec.scala
@@ -0,0 +1,56 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.nio.file.{ Path, Paths }
+
+import org.scalatest.FlatSpec
+import sbt.nio.FileStamp
+import sbt.nio.FileStamp.Formats
+import sjsonnew.JsonFormat
+import sjsonnew.support.scalajson.unsafe.Converter
+
+class FileStampJsonSpec extends FlatSpec {
+  "file hashes" should "be serializable" in {
+    val hashes = Seq(
+      Paths.get("foo") -> FileStamp.hash("bar"),
+      Paths.get("bar") -> FileStamp.hash("buzz")
+    )
+    implicit val formatter: JsonFormat[Seq[(Path, FileStamp.Hash)]] =
+      Formats.seqPathHashJsonFormatter
+    val json = Converter.toJsonUnsafe(hashes)
+    val deserialized = Converter.fromJsonUnsafe(json)
+    assert(hashes == deserialized)
+  }
+  "file last modified times" should "be serializable" in {
+    val lastModifiedTimes = Seq(
+      Paths.get("foo") -> FileStamp.LastModified(1234),
+      Paths.get("bar") -> FileStamp.LastModified(5678)
+    )
+    implicit val formatter: JsonFormat[Seq[(Path, FileStamp.LastModified)]] =
+      Formats.seqPathLastModifiedJsonFormatter
+    val json = Converter.toJsonUnsafe(lastModifiedTimes)
+    val deserialized = Converter.fromJsonUnsafe(json)
+    assert(lastModifiedTimes == deserialized)
+  }
+  "both" should "be serializable" in {
+    val hashes = Seq(
+      Paths.get("foo") -> FileStamp.hash("bar"),
+      Paths.get("bar") -> FileStamp.hash("buzz")
+    )
+    val lastModifiedTimes = Seq(
+      Paths.get("foo") -> FileStamp.LastModified(1234),
+      Paths.get("bar") -> FileStamp.LastModified(5678)
+    )
+    val both: Seq[(Path, FileStamp)] = hashes ++ lastModifiedTimes
+    import Formats.seqPathFileStampJsonFormatter
+    val json = Converter.toJsonUnsafe(both)
+    val deserialized = Converter.fromJsonUnsafe(json)
+    assert(both == deserialized)
+  }
+}
diff --git a/main/src/test/scala/sbt/internal/GCMonitorTest.scala b/main/src/test/scala/sbt/internal/GCMonitorTest.scala
new file mode 100644
index 000000000..02356e0a3
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/GCMonitorTest.scala
@@ -0,0 +1,62 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import java.util.concurrent.atomic.AtomicReference
+
+import org.scalatest.FunSuite
+
+import scala.collection.mutable.ListBuffer
+import scala.concurrent.duration._
+
+class GCMonitorTest extends FunSuite {
+  class TestMonitor extends GCMonitorBase {
+    val loggedTotals = ListBuffer.empty[Long]
+    override protected val window = 10.seconds
+    override protected val ratio = 0.5
+
+    override protected def emitWarning(total: Long, over: Option[Long]): Unit =
+      loggedTotals += total
+  }
+
+  val collectionTimeStore = new AtomicReference(0.millis -> 0L)
+
+  def simulateBy(f: Long => Long): Long => List[Long] = { duration =>
+    collectionTimeStore.set(0.millis -> 0)
+    val testMonitor = new TestMonitor
+    for (x <- 0L to duration by 100)
+      testMonitor.totalCollectionTimeChanged(x, f(x), collectionTimeStore)
+    testMonitor.loggedTotals.toList
+  }
+
+  test("GC time = time") {
+    val simulate = simulateBy(identity)
+    assertResult(List())(simulate(5000))
+    assertResult(List(5100))(simulate(10000))
+    assertResult(List(5100, 10000))(simulate(20000))
+    assertResult(List(5100, 10000, 10000))(simulate(30000))
+    assertResult(List(5100, 10000, 10000, 10000))(simulate(40000))
+  }
+
+  test("GC time = 0.5 * time") {
+    val simulate = simulateBy(_ / 2)
+    assertResult(List())(simulate(10000))
+    assertResult(List())(simulate(20000))
+    assertResult(List())(simulate(30000))
+    assertResult(List())(simulate(40000))
+  }
+
+  test("GC time = 2 * time") {
+    val simulate = simulateBy(_ * 2)
+    assertResult(List(5200))(simulate(5000))
+    assertResult(List(5200))(simulate(10000))
+    assertResult(List(5200, 20000))(simulate(20000))
+    assertResult(List(5200, 20000, 20000))(simulate(30000))
+    assertResult(List(5200, 20000, 20000, 20000))(simulate(40000))
+  }
+}
diff --git a/main/src/test/scala/sbt/internal/InstallSbtnSpec.scala b/main/src/test/scala/sbt/internal/InstallSbtnSpec.scala
new file mode 100644
index 000000000..3580007ed
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/InstallSbtnSpec.scala
@@ -0,0 +1,67 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+
+import java.io.{ InputStream, OutputStream, PrintStream }
+import java.lang.ProcessBuilder
+import java.lang.ProcessBuilder.Redirect
+import java.nio.file.{ Files, Path }
+import java.util.concurrent.TimeUnit
+import org.scalatest.FlatSpec
+import sbt.io.IO
+
+class InstallSbtnSpec extends FlatSpec {
+  private def withTemp[R](ext: String)(f: Path => R): R = {
+    val tmp = Files.createTempFile("sbt-1.4.1-", ext)
+    try f(tmp)
+    finally {
+      Files.deleteIfExists(tmp)
+      ()
+    }
+  }
+  private[this] val term = new Terminal {
+    def getHeight: Int = 0
+    def getWidth: Int = 0
+    def inputStream: InputStream = () => -1
+    def printStream: PrintStream = new PrintStream((_ => {}): OutputStream)
+    def setMode(canonical: Boolean, echo: Boolean): Unit = {}
+
+  }
+  // This test has issues in ci but runs ok locally on all platforms
+  "InstallSbtn" should "extract native sbtn" ignore
+    withTemp(".zip") { tmp =>
+      withTemp(".exe") { sbtn =>
+        InstallSbtn.extractSbtn(term, "1.4.1", tmp, sbtn)
+        val tmpDir = Files.createTempDirectory("sbtn-test").toRealPath()
+        Files.createDirectories(tmpDir.resolve("project"))
+        val foo = tmpDir.resolve("foo")
+        val fooPath = foo.toString.replaceAllLiterally("\\", "\\\\")
+        val build = s"""TaskKey[Unit]("foo") := IO.write(file("$fooPath"), "foo")"""
+        IO.write(tmpDir.resolve("build.sbt").toFile, build)
+        IO.write(
+          tmpDir.resolve("project").resolve("build.properties").toFile,
+          "sbt.version=1.4.1"
+        )
+        try {
+          val proc =
+            new ProcessBuilder(sbtn.toString, "foo;shutdown")
+              .redirectInput(Redirect.INHERIT)
+              .redirectOutput(Redirect.INHERIT)
+              .redirectError(Redirect.INHERIT)
+              .directory(tmpDir.toFile)
+              .start()
+          proc.waitFor(1, TimeUnit.MINUTES)
+          assert(proc.exitValue == 0)
+          assert(IO.read(foo.toFile) == "foo")
+        } finally {
+          sbt.io.IO.delete(tmpDir.toFile)
+        }
+      }
+    }
+}
diff --git a/main/src/test/scala/sbt/internal/StressGCMonitor.scala b/main/src/test/scala/sbt/internal/StressGCMonitor.scala
new file mode 100644
index 000000000..d9593ef79
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/StressGCMonitor.scala
@@ -0,0 +1,30 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal
+
+import sbt.internal.util.ConsoleLogger
+
+import scala.concurrent.duration._
+import scala.util.Random
+
+object StressGCMonitor {
+  var list = List.empty[Int]
+
+  def main(args: Array[String]): Unit = {
+    new GCMonitor(ConsoleLogger())
+    val deadline = Deadline.now + 10.seconds
+    while (!deadline.isOverdue()) {
+      println(deadline.timeLeft.toSeconds + " seconds left...")
+      list = List.fill(1000 * 1000 * 100)(Random.nextInt(100))
+      System.gc()
+      Thread.sleep(10)
+    }
+  }
+
+  def print(): Unit = println(s"random number: ${list.sum}")
+}
diff --git a/main/src/test/scala/sbt/internal/TestBuild.scala b/main/src/test/scala/sbt/internal/TestBuild.scala
index bac5fa0ab..48bf993b9 100644
--- a/main/src/test/scala/sbt/internal/TestBuild.scala
+++ b/main/src/test/scala/sbt/internal/TestBuild.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -5,14 +12,15 @@ import Def.{ ScopedKey, Setting }
 import sbt.internal.util.{ AttributeKey, AttributeMap, Relation, Settings }
 import sbt.internal.util.Types.{ const, some }
 import sbt.internal.util.complete.Parser
+import sbt.librarymanagement.Configuration
 
 import java.net.URI
-import org.scalacheck._
-import Gen._
 
-// Notes:
-//  Generator doesn't produce cross-build project dependencies or do anything with the 'extra' axis
-object TestBuild {
+import hedgehog._
+import hedgehog.predef.sequence
+
+object TestBuild extends TestBuild
+abstract class TestBuild {
   val MaxTasks = 6
   val MaxProjects = 7
   val MaxConfigs = 5
@@ -21,126 +29,176 @@ object TestBuild {
   val MaxDeps = 8
   val KeysPerEnv = 10
 
-  val MaxTasksGen = chooseShrinkable(1, MaxTasks)
-  val MaxProjectsGen = chooseShrinkable(1, MaxProjects)
-  val MaxConfigsGen = chooseShrinkable(1, MaxConfigs)
-  val MaxBuildsGen = chooseShrinkable(1, MaxBuilds)
-  val MaxDepsGen = chooseShrinkable(0, MaxDeps)
+  val MaxTasksGen = Range.linear(1, MaxTasks)
+  val MaxProjectsGen = Range.linear(1, MaxProjects)
+  val MaxConfigsGen = Range.linear(1, MaxConfigs)
+  val MaxBuildsGen = Range.linear(1, MaxBuilds)
+  val MaxDepsGen = Range.linear(0, MaxDeps)
+  val MaxIDSizeGen = Range.linear(0, MaxIDSize)
 
-  def chooseShrinkable(min: Int, max: Int): Gen[Int] =
-    sized(sz => choose(min, (max min sz) max 1))
+  def alphaLowerChar: Gen[Char] = Gen.char('a', 'z')
+  def alphaUpperChar: Gen[Char] = Gen.char('A', 'Z')
+  def numChar: Gen[Char] = Gen.char('0', '9')
+  def alphaNumChar: Gen[Char] =
+    Gen.frequency1(8 -> alphaLowerChar, 1 -> alphaUpperChar, 1 -> numChar)
 
-  implicit val cGen = Arbitrary { genConfigs(idGen, MaxDepsGen, MaxConfigsGen) }
-  implicit val tGen = Arbitrary { genTasks(idGen, MaxDepsGen, MaxTasksGen) }
+  val nonEmptyId = for {
+    c <- alphaLowerChar
+    cs <- Gen.list(alphaNumChar, MaxIDSizeGen)
+  } yield (c :: cs).mkString
 
-  final class Keys(val env: Env, val scopes: Seq[Scope]) {
+  def cGen = genConfigs(nonEmptyId map { _.capitalize }, MaxDepsGen, MaxConfigsGen)
+  def tGen = genTasks(kebabIdGen, MaxDepsGen, MaxTasksGen)
+
+  class TestKeys(val env: Env, val scopes: Seq[Scope]) {
     override def toString = env + "\n" + scopes.mkString("Scopes:\n\t", "\n\t", "")
     lazy val delegated = scopes map env.delegates
   }
 
-  final case class Structure(env: Env, current: ProjectRef, data: Settings[Scope], keyIndex: KeyIndex, keyMap: Map[String, AttributeKey[_]]) {
-    override def toString = env.toString + "\n" + "current: " + current + "\nSettings:\n\t" + showData + keyMap.keys.mkString("All keys:\n\t", ", ", "")
+  sealed case class Structure(
+      env: Env,
+      current: ProjectRef,
+      data: Settings[Scope],
+      keyIndex: KeyIndex,
+      keyMap: Map[String, AttributeKey[_]]
+  ) {
+    override def toString =
+      env.toString + "\n" + "current: " + current + "\nSettings:\n\t" + showData + keyMap.keys
+        .mkString("All keys:\n\t", ", ", "")
     def showKeys(map: AttributeMap): String = map.keys.mkString("\n\t   ", ",", "\n")
-    def showData: String =
-      {
-        val scopeStrings =
-          for ((scope, map) <- data.data) yield (Scope.display(scope, "<key>"), showKeys(map))
-        scopeStrings.toSeq.sorted.map(t => t._1 + t._2).mkString("\n\t")
-      }
-    val extra: BuildUtil[Proj] =
-      {
-        val getp = (build: URI, project: String) => env.buildMap(build).projectMap(project)
-        new BuildUtil(keyIndex, data, env.root.uri, env.rootProject, getp, _.configurations.map(c => ConfigKey(c.name)), Relation.empty)
+    def showData: String = {
+      val scopeStrings =
+        for ((scope, map) <- data.data) yield (Scope.display(scope, "<key>"), showKeys(map))
+      scopeStrings.toSeq.sorted.map(t => t._1 + t._2).mkString("\n\t")
+    }
+    val extra: BuildUtil[Proj] = {
+      val getp = (build: URI, project: String) => env.buildMap(build).projectMap(project)
+      new BuildUtil(
+        keyIndex,
+        data,
+        env.root.uri,
+        env.rootProject,
+        getp,
+        _.configurations.map(c => ConfigKey(c.name)),
+        Relation.empty
+      )
+    }
+
+    lazy val allAttributeKeys: Set[AttributeKey[_]] = {
+      val x = data.data.values.flatMap(_.keys).toSet
+      if (x.isEmpty) {
+        sys.error("allAttributeKeys is empty")
       }
+      x
+    }
+    lazy val (taskAxes, zeroTaskAxis, onlyTaskAxis, multiTaskAxis) = {
+      import collection.mutable
+      import mutable.HashSet
 
-    lazy val allAttributeKeys: Set[AttributeKey[_]] = data.data.values.flatMap(_.keys).toSet
-    lazy val (taskAxes, globalTaskAxis, onlyTaskAxis, multiTaskAxis) =
-      {
-        import collection.mutable
-        import mutable.HashSet
+      // task axis of Scope is set to Zero and the value of the second map is the original task axis
+      val taskAxesMappings =
+        for ((scope, keys) <- data.data.toIterable; key <- keys.keys)
+          yield (ScopedKey(scope.copy(task = Zero), key), scope.task): (
+              ScopedKey[_],
+              ScopeAxis[AttributeKey[_]]
+          )
 
-        // task axis of Scope is set to Global and the value of the second map is the original task axis
-        val taskAxesMappings =
-          for ((scope, keys) <- data.data.toIterable; key <- keys.keys) yield (ScopedKey(scope.copy(task = Global), key), scope.task): (ScopedKey[_], ScopeAxis[AttributeKey[_]])
-
-        val taskAxes = Relation.empty ++ taskAxesMappings
-        val global = new HashSet[ScopedKey[_]]
-        val single = new HashSet[ScopedKey[_]]
-        val multi = new HashSet[ScopedKey[_]]
-        for ((skey, tasks) <- taskAxes.forwardMap) {
-          def makeKey(task: ScopeAxis[AttributeKey[_]]) = ScopedKey(skey.scope.copy(task = task), skey.key)
-          val hasGlobal = tasks(Global)
-          if (hasGlobal)
-            global += skey
-          else {
-            val keys = tasks map makeKey
-            keys.size match {
-              case 0 =>
-              case 1 => single ++= keys
-              case _ => multi ++= keys
-            }
+      val taskAxes = Relation.empty ++ taskAxesMappings
+      val zero = new HashSet[ScopedKey[_]]
+      val single = new HashSet[ScopedKey[_]]
+      val multi = new HashSet[ScopedKey[_]]
+      for ((skey, tasks) <- taskAxes.forwardMap) {
+        def makeKey(task: ScopeAxis[AttributeKey[_]]) =
+          ScopedKey(skey.scope.copy(task = task), skey.key)
+        val hasGlobal = tasks(Zero)
+        if (hasGlobal)
+          zero += skey
+        else {
+          val keys = tasks map makeKey
+          keys.size match {
+            case 0 =>
+            case 1 => single ++= keys
+            case _ => multi ++= keys
           }
         }
-        (taskAxes, global.toSet, single.toSet, multi.toSet)
       }
+      (taskAxes, zero.toSet, single.toSet, multi.toSet)
+    }
   }
-  final class Env(val builds: Seq[Build], val tasks: Seq[Taskk]) {
-    override def toString = "Env:\n  " + "  Tasks:\n    " + tasks.mkString("\n    ") + "\n" + builds.mkString("\n  ")
+  case class Env(builds: Vector[Build], tasks: Vector[Taskk]) {
+    override def toString =
+      "Env:\n  " + "  Tasks:\n    " + tasks.mkString("\n    ") + "\n" + builds.mkString("\n  ")
     val root = builds.head
     val buildMap = mapBy(builds)(_.uri)
     val taskMap = mapBy(tasks)(getKey)
     def project(ref: ProjectRef) = buildMap(ref.build).projectMap(ref.project)
-    def projectFor(ref: ResolvedReference) = ref match { case pr: ProjectRef => project(pr); case BuildRef(uri) => buildMap(uri).root }
+    def projectFor(ref: ResolvedReference) = ref match {
+      case pr: ProjectRef => project(pr); case BuildRef(uri) => buildMap(uri).root
+    }
 
     lazy val allProjects = builds.flatMap(_.allProjects)
     def rootProject(uri: URI): String = buildMap(uri).root.id
-    def inheritConfig(ref: ResolvedReference, config: ConfigKey) = projectFor(ref).confMap(config.name).extended map toConfigKey
-    def inheritTask(task: AttributeKey[_]) = taskMap.get(task) match { case None => Nil; case Some(t) => t.delegates map getKey }
-    def inheritProject(ref: ProjectRef) = project(ref).delegates
+    def inheritConfig(ref: ResolvedReference, config: ConfigKey) =
+      projectFor(ref).confMap(config.name).extendsConfigs map toConfigKey
+    def inheritTask(task: AttributeKey[_]) = taskMap.get(task) match {
+      case None    => Vector()
+      case Some(t) => t.delegates.toVector map getKey
+    }
+    def inheritProject(ref: ProjectRef) = project(ref).delegates.toVector
     def resolve(ref: Reference) = Scope.resolveReference(root.uri, rootProject, ref)
     lazy val delegates: Scope => Seq[Scope] =
       Scope.delegates(
         allProjects,
-        (_: Proj).configurations.map(toConfigKey),
+        (_: Proj).configurations.toVector.map(toConfigKey),
         resolve,
         uri => buildMap(uri).root.id,
         inheritProject,
         inheritConfig,
         inheritTask,
-        (ref, mp) => Nil
       )
     lazy val allFullScopes: Seq[Scope] =
       for {
-        (ref, p) <- (Global, root.root) +: allProjects.map { case (ref, p) => (Select(ref), p) }
-        t <- Global +: tasks.map(t => Select(t.key))
-        c <- Global +: p.configurations.map(c => Select(ConfigKey(c.name)))
-      } yield Scope(project = ref, config = c, task = t, extra = Global)
+        (ref, p) <- (Zero, root.root) +: allProjects.map { case (ref, p) => (Select(ref), p) }
+        t <- Zero +: tasks.map(t => Select(t.key))
+        c <- Zero +: p.configurations.map(c => Select(ConfigKey(c.name)))
+      } yield Scope(project = ref, config = c, task = t, extra = Zero)
   }
   def getKey: Taskk => AttributeKey[_] = _.key
-  def toConfigKey: Config => ConfigKey = c => ConfigKey(c.name)
-  final class Build(val uri: URI, val projects: Seq[Proj]) {
+  def toConfigKey: Configuration => ConfigKey = c => ConfigKey(c.name)
+  case class Build(uri: URI, projects: Seq[Proj]) {
     override def toString = "Build " + uri.toString + " :\n    " + projects.mkString("\n    ")
-    val allProjects = projects map { p => (ProjectRef(uri, p.id), p) }
+    val allProjects = projects map { p =>
+      (ProjectRef(uri, p.id), p)
+    }
     val root = projects.head
     val projectMap = mapBy(projects)(_.id)
   }
-  final class Proj(val id: String, val delegates: Seq[ProjectRef], val configurations: Seq[Config]) {
-    override def toString = "Project " + id + "\n      Delegates:\n        " + delegates.mkString("\n        ") +
-      "\n      Configurations:\n        " + configurations.mkString("\n        ")
+  case class Proj(
+      id: String,
+      delegates: Seq[ProjectRef],
+      configurations: Seq[Configuration]
+  ) {
+    override def toString =
+      "Project " + id + "\n      Delegates:\n        " + delegates.mkString("\n        ") +
+        "\n      Configurations:\n        " + configurations.mkString("\n        ")
     val confMap = mapBy(configurations)(_.name)
   }
 
-  final class Config(val name: String, val extended: Seq[Config]) {
-    override def toString = name + " (extends: " + extended.map(_.name).mkString(", ") + ")"
-  }
-  final class Taskk(val key: AttributeKey[String], val delegates: Seq[Taskk]) {
-    override def toString = key.label + " (delegates: " + delegates.map(_.key.label).mkString(", ") + ")"
+  case class Taskk(key: AttributeKey[String], delegates: Seq[Taskk]) {
+    override def toString =
+      key.label + " (delegates: " + delegates.map(_.key.label).mkString(", ") + ")"
   }
 
-  def mapBy[K, T](s: Seq[T])(f: T => K): Map[K, T] = s map { t => (f(t), t) } toMap;
+  def mapBy[K, T](s: Seq[T])(f: T => K): Map[K, T] =
+    s map { t =>
+      (f(t), t)
+    } toMap;
 
-  implicit lazy val arbKeys: Arbitrary[Keys] = Arbitrary(keysGen)
-  lazy val keysGen: Gen[Keys] = for (env <- mkEnv; keyCount <- chooseShrinkable(1, KeysPerEnv); keys <- listOfN(keyCount, scope(env))) yield new Keys(env, keys)
+  lazy val keysGen: Gen[TestKeys] =
+    for {
+      env <- mkEnv
+      keys <- scope(env).list(Range.linear(1, KeysPerEnv))
+    } yield new TestKeys(env, keys)
 
   def scope(env: Env): Gen[Scope] =
     for {
@@ -148,86 +206,153 @@ object TestBuild {
       project <- oneOf(build.projects)
       cAxis <- oneOrGlobal(project.configurations map toConfigKey)
       tAxis <- oneOrGlobal(env.tasks map getKey)
-      pAxis <- orGlobal(frequency((1, BuildRef(build.uri)), (3, ProjectRef(build.uri, project.id))))
-    } yield Scope(pAxis, cAxis, tAxis, Global)
+      pAxis <- orGlobal(
+        Gen.frequency1(
+          (1, Gen.constant[Reference](BuildRef(build.uri))),
+          (3, Gen.constant[Reference](ProjectRef(build.uri, project.id)))
+        )
+      )
+    } yield Scope(pAxis, cAxis, tAxis, Zero)
 
   def orGlobal[T](gen: Gen[T]): Gen[ScopeAxis[T]] =
-    frequency((1, gen map Select.apply), (1, Global))
+    Gen.frequency1((1, gen map Select.apply), (1, Gen.constant(Zero)))
   def oneOrGlobal[T](gen: Seq[T]): Gen[ScopeAxis[T]] = orGlobal(oneOf(gen))
 
-  def makeParser(structure: Structure): Parser[ScopedKey[_]] =
-    {
-      import structure._
-      def confs(uri: URI) = env.buildMap.get(uri).toList.flatMap { _.root.configurations.map(_.name) }
-      val defaultConfs: Option[ResolvedReference] => Seq[String] = {
-        case None                  => confs(env.root.uri)
-        case Some(BuildRef(uri))   => confs(uri)
-        case Some(ref: ProjectRef) => env.project(ref).configurations.map(_.name)
+  def makeParser(structure: Structure): Parser[ScopedKey[_]] = {
+    import structure._
+    def confs(uri: URI) =
+      env.buildMap.get(uri).toList.flatMap { _.root.configurations.map(_.name) }
+    val defaultConfs: Option[ResolvedReference] => Seq[String] = {
+      case None                  => confs(env.root.uri)
+      case Some(BuildRef(uri))   => confs(uri)
+      case Some(ref: ProjectRef) => env.project(ref).configurations.map(_.name)
+    }
+    Act.scopedKey(keyIndex, current, defaultConfs, keyMap, data)
+  }
+
+  def structure(env: Env, settings: Seq[Setting[_]], current: ProjectRef): Structure = {
+    val display = Def.showRelativeKey2(current)
+    if (settings.isEmpty) {
+      try {
+        sys.error("settings is empty")
+      } catch {
+        case e: Throwable =>
+          e.printStackTrace
+          throw e
       }
-      Act.scopedKey(keyIndex, current, defaultConfs, keyMap, data)
     }
+    val data = Def.makeWithCompiledMap(settings)(env.delegates, const(Nil), display)._2
+    val keys = data.allKeys((s, key) => ScopedKey(s, key))
+    val keyMap = keys.map(k => (k.key.label, k.key)).toMap[String, AttributeKey[_]]
+    val projectsMap = env.builds.map(b => (b.uri, b.projects.map(_.id).toSet)).toMap
+    val confs = for {
+      b <- env.builds
+      p <- b.projects
+    } yield p.id -> p.configurations
+    val confMap = confs.toMap
+    Structure(env, current, data, KeyIndex(keys, projectsMap, confMap), keyMap)
+  }
 
-  def structure(env: Env, settings: Seq[Setting[_]], current: ProjectRef): Structure =
-    {
-      implicit val display = Def.showRelativeKey(current, env.allProjects.size > 1)
-      val data = Def.make(settings)(env.delegates, const(Nil), display)
-      val keys = data.allKeys((s, key) => ScopedKey(s, key))
-      val keyMap = keys.map(k => (k.key.label, k.key)).toMap[String, AttributeKey[_]]
-      val projectsMap = env.builds.map(b => (b.uri, b.projects.map(_.id).toSet)).toMap
-      new Structure(env, current, data, KeyIndex(keys, projectsMap), keyMap)
-    }
+  lazy val mkEnv: Gen[Env] = {
+    val pGen = (uri: URI) => genProjects(uri)(nonEmptyId, MaxDepsGen, MaxProjectsGen, cGen)
+    envGen(buildGen(uriGen, pGen), tGen)
+  }
 
-  implicit lazy val mkEnv: Gen[Env] =
-    {
-      implicit val cGen = genConfigs(idGen, MaxDepsGen, MaxConfigsGen)
-      implicit val tGen = genTasks(idGen, MaxDepsGen, MaxTasksGen)
-      implicit val pGen = (uri: URI) => genProjects(uri)(idGen, MaxDepsGen, MaxProjectsGen, cGen)
-      envGen(buildGen(uriGen, pGen), tGen)
-    }
+  def maskGen: Gen[ScopeMask] = {
+    val b = Gen.boolean
+    for (p <- b; c <- b; t <- b; x <- b)
+      yield ScopeMask(project = p, config = c, task = t, extra = x)
+  }
 
-  implicit def maskGen(implicit arbBoolean: Arbitrary[Boolean]): Gen[ScopeMask] =
-    {
-      val b = arbBoolean.arbitrary
-      for (p <- b; c <- b; t <- b; x <- b) yield ScopeMask(project = p, config = c, task = t, extra = x)
-    }
+  val kebabIdGen: Gen[String] = for {
+    c <- alphaLowerChar
+    cs <- Gen.list(
+      Gen.frequency(MaxIDSize -> alphaNumChar, List(1 -> Gen.constant('-'))),
+      Range.linear(0, MaxIDSize - 2)
+    )
+    end <- alphaNumChar
+  } yield (List(c) ++ cs ++ List(end)).mkString
 
-  implicit lazy val idGen: Gen[String] = for (size <- chooseShrinkable(1, MaxIDSize); cs <- listOfN(size, alphaChar)) yield cs.mkString
-  implicit lazy val optIDGen: Gen[Option[String]] = frequency((1, idGen map some.fn), (1, None))
-  implicit lazy val uriGen: Gen[URI] = for (sch <- idGen; ssp <- idGen; frag <- optIDGen) yield new URI(sch, ssp, frag.orNull)
+  val optIDGen: Gen[Option[String]] = Gen.choice1(nonEmptyId.map(some.fn), Gen.constant(None))
 
-  implicit def envGen(implicit bGen: Gen[Build], tasks: Gen[Seq[Taskk]]): Gen[Env] =
-    for (i <- MaxBuildsGen; bs <- listOfN(i, bGen); ts <- tasks) yield new Env(bs, ts)
-  implicit def buildGen(implicit uGen: Gen[URI], pGen: URI => Gen[Seq[Proj]]): Gen[Build] = for (u <- uGen; ps <- pGen(u)) yield new Build(u, ps)
+  val pathGen = for {
+    c <- alphaLowerChar
+    cs <- Gen.list(alphaNumChar, Range.linear(6, MaxIDSize))
+  } yield (c :: cs).mkString
 
-  def nGen[T](igen: Gen[Int])(implicit g: Gen[T]): Gen[List[T]] = igen flatMap { ig => listOfN(ig, g) }
+  val uriGen: Gen[URI] = {
+    for {
+      ssp <- pathGen
+      frag <- optIDGen
+    } yield new URI("file", "///" + ssp + "/", frag.orNull)
+  }
 
-  implicit def genProjects(build: URI)(implicit genID: Gen[String], maxDeps: Gen[Int], count: Gen[Int], confs: Gen[Seq[Config]]): Gen[Seq[Proj]] =
+  def envGen(bGen: Gen[Build], tasks: Gen[Vector[Taskk]]): Gen[Env] =
+    for (bs <- bGen.list(MaxBuildsGen).map(_.toVector); ts <- tasks)
+      yield new Env(bs, ts)
+  def buildGen(uGen: Gen[URI], pGen: URI => Gen[Vector[Proj]]): Gen[Build] =
+    for (u <- uGen; ps <- pGen(u)) yield new Build(u, ps)
+
+  def nGen[T](igen: Gen[Int])(g: Gen[T]): Gen[Vector[T]] = igen flatMap { ig =>
+    g.list(Range.linear(ig, ig)).map(_.toVector)
+  }
+
+  def genProjects(build: URI)(
+      genID: Gen[String],
+      maxDeps: Range[Int],
+      count: Range[Int],
+      confs: Gen[Vector[Configuration]]
+  ): Gen[Vector[Proj]] =
     genAcyclic(maxDeps, genID, count) { (id: String) =>
       for (cs <- confs) yield { (deps: Seq[Proj]) =>
-        new Proj(id, deps.map { dep => ProjectRef(build, dep.id) }, cs)
+        new Proj(id, deps.map { dep =>
+          ProjectRef(build, dep.id)
+        }, cs)
       }
     }
-  def genConfigs(implicit genName: Gen[String], maxDeps: Gen[Int], count: Gen[Int]): Gen[Seq[Config]] =
-    genAcyclicDirect[Config, String](maxDeps, genName, count)((key, deps) => new Config(key, deps))
-  def genTasks(implicit genName: Gen[String], maxDeps: Gen[Int], count: Gen[Int]): Gen[Seq[Taskk]] =
-    genAcyclicDirect[Taskk, String](maxDeps, genName, count)((key, deps) => new Taskk(AttributeKey[String](key), deps))
 
-  def genAcyclicDirect[A, T](maxDeps: Gen[Int], keyGen: Gen[T], max: Gen[Int])(make: (T, Seq[A]) => A): Gen[Seq[A]] =
+  def genConfigs(
+      implicit genName: Gen[String],
+      maxDeps: Range[Int],
+      count: Range[Int]
+  ): Gen[Vector[Configuration]] =
+    genAcyclicDirect[Configuration, String](maxDeps, genName, count)(
+      (key, deps) =>
+        Configuration
+          .of(key.capitalize, key)
+          .withExtendsConfigs(deps.toVector)
+    )
+
+  def genTasks(
+      implicit genName: Gen[String],
+      maxDeps: Range[Int],
+      count: Range[Int]
+  ): Gen[Vector[Taskk]] =
+    genAcyclicDirect[Taskk, String](maxDeps, genName, count)(
+      (key, deps) => new Taskk(AttributeKey[String](key), deps)
+    )
+
+  def genAcyclicDirect[A, T](maxDeps: Range[Int], keyGen: Gen[T], max: Range[Int])(
+      make: (T, Vector[A]) => A
+  ): Gen[Vector[A]] =
     genAcyclic[A, T](maxDeps, keyGen, max) { t =>
-      Gen.const { deps =>
-        make(t, deps)
+      Gen.constant { deps =>
+        make(t, deps.toVector)
       }
     }
 
-  def genAcyclic[A, T](maxDeps: Gen[Int], keyGen: Gen[T], max: Gen[Int])(make: T => Gen[Seq[A] => A]): Gen[Seq[A]] =
-    max flatMap { count =>
-      listOfN(count, keyGen) flatMap { keys =>
-        genAcyclic(maxDeps, keys.distinct)(make)
-      }
+  def genAcyclic[A, T](maxDeps: Range[Int], keyGen: Gen[T], max: Range[Int])(
+      make: T => Gen[Vector[A] => A]
+  ): Gen[Vector[A]] = {
+    keyGen.list(max) flatMap { keys =>
+      genAcyclic(maxDeps, keys.distinct.toVector)(make)
     }
-  def genAcyclic[A, T](maxDeps: Gen[Int], keys: List[T])(make: T => Gen[Seq[A] => A]): Gen[Seq[A]] =
-    genAcyclic(maxDeps, keys, Nil) flatMap { pairs =>
-      sequence(pairs.map { case (key, deps) => mapMake(key, deps, make) }) flatMap { inputs =>
+  }
+  def genAcyclic[A, T](maxDeps: Range[Int], keys: Vector[T])(
+      make: T => Gen[Vector[A] => A]
+  ): Gen[Vector[A]] =
+    genAcyclic(maxDeps, keys, Vector()) flatMap { pairs =>
+      sequence(pairs.map { case (key, deps) => mapMake(key, deps, make) }.toList) map { inputs =>
         val made = new collection.mutable.HashMap[T, A]
         for ((key, deps, mk) <- inputs)
           made(key) = mk(deps map made)
@@ -235,18 +360,42 @@ object TestBuild {
       }
     }
 
-  def mapMake[A, T](key: T, deps: Seq[T], make: T => Gen[Seq[A] => A]): Gen[Inputs[A, T]] =
-    make(key) map { (mk: Seq[A] => A) => (key, deps, mk) }
-
-  def genAcyclic[T](maxDeps: Gen[Int], names: List[T], acc: List[Gen[(T, Seq[T])]]): Gen[Seq[(T, Seq[T])]] =
-    names match {
-      case Nil => sequence(acc)
-      case x :: xs =>
-        val next = for (depCount <- maxDeps; d <- pick(depCount min xs.size, xs)) yield (x, d.toList)
-        genAcyclic(maxDeps, xs, next :: acc)
+  def mapMake[A, T](key: T, deps: Vector[T], make: T => Gen[Vector[A] => A]): Gen[Inputs[A, T]] =
+    make(key) map { (mk: Vector[A] => A) =>
+      (key, deps, mk)
+    }
+
+  def genAcyclic[T](
+      maxDeps: Range[Int],
+      names: Vector[T],
+      acc: Vector[Gen[(T, Vector[T])]]
+  ): Gen[Vector[(T, Vector[T])]] =
+    names match {
+      case Vector() => sequence(acc.toList).map(_.toVector)
+      case Vector(x, xs @ _*) =>
+        val next =
+          for (depCount <- Gen.int(maxDeps); d <- pick(depCount, xs))
+            yield (x, d.toVector)
+        genAcyclic(maxDeps, xs.toVector, next +: acc)
+    }
+
+  type Inputs[A, T] = (T, Vector[T], Vector[A] => A)
+
+  def oneOf[A](a: Seq[A]): Gen[A] =
+    Gen.element(a.head, a.tail.toList)
+
+  // TODO Should move to hedgehog possible?
+  def pick[A](n: Int, as: Seq[A]): Gen[Seq[A]] = {
+    if (n >= as.length) {
+      Gen.constant(as)
+    } else {
+      def go(m: Int, bs: Set[Int], cs: Set[Int]): Gen[Set[Int]] =
+        if (m == 0)
+          Gen.constant(cs)
+        else
+          Gen.element(bs.head, bs.tail.toList).flatMap(a => go(m - 1, bs - a, cs + a))
+      go(n, as.indices.toSet, Set())
+        .map(is => as.zipWithIndex.flatMap(a => if (is(a._2)) Seq(a._1) else Seq()))
     }
-  def sequence[T](gs: Seq[Gen[T]]): Gen[Seq[T]] = Gen.parameterized { prms =>
-    wrap(gs map { g => g(prms) getOrElse sys.error("failed generator") })
   }
-  type Inputs[A, T] = (T, Seq[T], Seq[A] => A)
 }
diff --git a/main/src/test/scala/sbt/internal/parser/AbstractSpec.scala b/main/src/test/scala/sbt/internal/parser/AbstractSpec.scala
index cb0377b0a..a11fe9f85 100644
--- a/main/src/test/scala/sbt/internal/parser/AbstractSpec.scala
+++ b/main/src/test/scala/sbt/internal/parser/AbstractSpec.scala
@@ -1,5 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt.internal.parser
 
-import org.specs2.mutable._
-
-trait AbstractSpec extends Specification with SplitExpression
\ No newline at end of file
+trait AbstractSpec extends verify.BasicTestSuite with SplitExpression
diff --git a/main/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala b/main/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala
index d3bc24510..e13e15eed 100644
--- a/main/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala
+++ b/main/src/test/scala/sbt/internal/parser/CheckIfParsedSpec.scala
@@ -1,34 +1,46 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
-abstract class CheckIfParsedSpec(implicit val splitter: SplitExpressions.SplitExpression = EvaluateConfigurations.splitExpressions) extends AbstractSpec {
+abstract class CheckIfParsedSpec(
+    implicit val splitter: SplitExpressions.SplitExpression =
+      EvaluateConfigurations.splitExpressions
+) extends AbstractSpec {
 
-  this.getClass.getName should {
-
-    "Parse sbt file " in {
-      foreach(files) {
-        case (content, description, nonEmptyImports, nonEmptyStatements) =>
-          println(s"""${getClass.getSimpleName}: "$description" """)
-          val (imports, statements) = split(content)
-          statements.nonEmpty must be_==(nonEmptyStatements).setMessage(s"""$description
-                                 |***${shouldContains(nonEmptyStatements)} statements***
-                                 |$content """.stripMargin)
-          imports.nonEmpty must be_==(nonEmptyImports).setMessage(s"""$description
-                               |***${shouldContains(nonEmptyImports)} imports***
-                               |$content """.stripMargin)
-      }
+  test(s"${this.getClass.getName} should parse sbt file") {
+    files foreach {
+      case (content, description, nonEmptyImports, nonEmptyStatements) =>
+        println(s"""${getClass.getSimpleName}: "$description" """)
+        val (imports, statements) = split(content)
+        assert(
+          nonEmptyStatements == statements.nonEmpty,
+          s"""$description
+             |***${shouldContains(nonEmptyStatements)} statements***
+             |$content """.stripMargin
+        )
+        assert(
+          nonEmptyImports == imports.nonEmpty,
+          s"""$description
+             |***${shouldContains(nonEmptyImports)} imports***
+             |$content """.stripMargin
+        )
     }
   }
 
-  private def shouldContains(b: Boolean) = s"""Should ${
-    if (b) {
+  private def shouldContains(b: Boolean): String =
+    s"""Should ${if (b) {
       "contain"
     } else {
       "not contain"
-    }
-  }"""
+    }}"""
 
-  protected val files: Seq[(String, String, Boolean, Boolean)]
+  protected def files: Seq[(String, String, Boolean, Boolean)]
 
 }
diff --git a/main/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala b/main/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala
index d4e6b9f90..06f348b3e 100644
--- a/main/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala
+++ b/main/src/test/scala/sbt/internal/parser/CommentedXmlSpec.scala
@@ -1,6 +1,13 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt.internal.parser
 
-class CommentedXmlSpec extends CheckIfParsedSpec {
+object CommentedXmlSpec extends CheckIfParsedSpec {
 
   override protected val files = Seq(
     (
@@ -13,7 +20,11 @@ class CommentedXmlSpec extends CheckIfParsedSpec {
          |
          |val tra = "</scm>"
          |
-       """.stripMargin, "Xml in string", false, true),
+       """.stripMargin,
+      "Xml in string",
+      false,
+      true
+    ),
     ("""
         |val scmpom = taskKey[xml.NodeBuffer]("Node buffer")
         |
@@ -62,6 +73,5 @@ class CommentedXmlSpec extends CheckIfParsedSpec {
     ("""
         |// a/>
       """.stripMargin, "Xml in comment2", false, false)
-
   )
 }
diff --git a/main/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala b/main/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala
index b054e73e2..2af64a80c 100644
--- a/main/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala
+++ b/main/src/test/scala/sbt/internal/parser/EmbeddedXmlSpec.scala
@@ -1,45 +1,49 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt.internal.parser
 
 import sbt.internal.util.MessageOnlyException
 
-class EmbeddedXmlSpec extends CheckIfParsedSpec {
+object EmbeddedXmlSpec extends CheckIfParsedSpec {
 
-  "File with xml content " should {
-
-    "Handle last xml part" in {
-      val errorLine = """<version>4.0<version>"""
-      val buildSbt = s"""|
-                         |
-                         |name := "play-html-compressor"
-                         |
-                         |scalaVersion := "2.11.1"
-                         |
-                         |val pom = <xml:group><scm>
-                         |<url>git@github.com:mhiva/play-html-compressor.git</url>
-                         |<connection>scm:git:git@github.com:mohiva/play-html-compressor.git</connection>
-                         |  </scm>
-                         |<developers>
-                         |    <developer>
-                         |      <id>akkie</id>
-                         |      <name>Christian Kaps</name>
-                         |      <url>http://mohiva.com</url>
-                         |    </developer>
-                         |  </developers></xml:group>
-                         |$errorLine
-                         |
-                         |""".stripMargin
-
-      split(buildSbt) must throwA[MessageOnlyException].like {
-        case exception =>
-          val index = buildSbt.lines.indexWhere(line => line.contains(errorLine)) + 1
-          val numberRegex = """(\d+)""".r
-          val message = exception.getMessage
-          val list = numberRegex.findAllIn(message).toList
-          list must contain(index.toString)
-      }
+  test("File with xml content  should Handle last xml part") {
+    val errorLine = """<version>4.0<version>"""
+    val buildSbt = s"""|
+                       |
+                       |name := "play-html-compressor"
+                       |
+                       |scalaVersion := "2.11.1"
+                       |
+                       |val pom = <xml:group><scm>
+                       |<url>git@github.com:mhiva/play-html-compressor.git</url>
+                       |<connection>scm:git:git@github.com:mohiva/play-html-compressor.git</connection>
+                       |  </scm>
+                       |<developers>
+                       |    <developer>
+                       |      <id>akkie</id>
+                       |      <name>Christian Kaps</name>
+                       |      <url>http://mohiva.com</url>
+                       |    </developer>
+                       |  </developers></xml:group>
+                       |$errorLine
+                       |
+                       |""".stripMargin
 
+    try {
+      split(buildSbt)
+    } catch {
+      case exception: MessageOnlyException =>
+        val index = buildSbt.linesIterator.indexWhere(line => line.contains(errorLine)) + 1
+        val numberRegex = """(\d+)""".r
+        val message = exception.getMessage
+        val list = numberRegex.findAllIn(message).toList
+        assert(list.contains(index.toString))
     }
-
   }
 
   protected val files = Seq(
@@ -129,7 +133,7 @@ class EmbeddedXmlSpec extends CheckIfParsedSpec {
         |	val pom = xml.XML.loadFile(pomFile)
         |	val tpe = pom \\ "type"
         |	if(!tpe.isEmpty)
-        |		error("Expected no <type> sections, got: " + tpe + " in \n\n" + pom)
+        |		sys.error("Expected no <type> sections, got: " + tpe + " in \n\n" + pom)
         |}
         |
         |
@@ -139,7 +143,11 @@ class EmbeddedXmlSpec extends CheckIfParsedSpec {
         |
         |
         |
-      """.stripMargin, "xml with blank line", false, true)
+      """.stripMargin,
+      "xml with blank line",
+      false,
+      true
+    )
   )
 
 }
diff --git a/main/src/test/scala/sbt/internal/parser/ErrorSpec.scala b/main/src/test/scala/sbt/internal/parser/ErrorSpec.scala
index 15751c094..693e1b72a 100644
--- a/main/src/test/scala/sbt/internal/parser/ErrorSpec.scala
+++ b/main/src/test/scala/sbt/internal/parser/ErrorSpec.scala
@@ -1,36 +1,41 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
 import java.io.File
-
-import org.specs2.ScalaCheck
 import sbt.internal.util.MessageOnlyException
-
 import scala.io.Source
 
-class ErrorSpec extends AbstractSpec with ScalaCheck {
+object ErrorSpec extends AbstractSpec {
   implicit val splitter: SplitExpressions.SplitExpression = EvaluateConfigurations.splitExpressions
 
-  "Parser " should {
-
-    "contains file name and line number" in {
-      val rootPath = getClass.getClassLoader.getResource("").getPath + "/error-format/"
-      println(s"Reading files from: $rootPath")
-      foreach(new File(rootPath).listFiles) { file =>
-        print(s"Processing ${file.getName}: ")
-        val buildSbt = Source.fromFile(file).getLines().mkString("\n")
-        SbtParser(file, buildSbt.lines.toSeq) must throwA[MessageOnlyException].like {
-          case exp =>
-            val message = exp.getMessage
-            println(s"${exp.getMessage}")
-            message must contain(file.getName)
-        }
-        containsLineNumber(buildSbt)
+  test("Parser should contains file name and line number") {
+    val rootPath = getClass.getResource("/error-format/").getPath
+    println(s"Reading files from: $rootPath")
+    new File(rootPath).listFiles foreach { file =>
+      print(s"Processing ${file.getName}: ")
+      val buildSbt = Source.fromFile(file).getLines().mkString("\n")
+      try {
+        SbtParser(file, buildSbt.linesIterator.toSeq)
+      } catch {
+        case exp: MessageOnlyException =>
+          val message = exp.getMessage
+          println(s"${exp.getMessage}")
+          assert(message.contains(file.getName))
       }
+      containsLineNumber(buildSbt)
     }
+  }
 
-    "handle wrong parsing " in {
+  test("it should handle wrong parsing") {
+    intercept[MessageOnlyException] {
       val buildSbt =
         """
           |libraryDependencies ++= Seq("a" % "b" % "2") map {
@@ -39,23 +44,31 @@ class ErrorSpec extends AbstractSpec with ScalaCheck {
           | } /* */ //
           |}
         """.stripMargin
-      MissingBracketHandler.findMissingText(buildSbt, buildSbt.length, 2, "fake.txt", new MessageOnlyException("fake")) must throwA[MessageOnlyException]
+      MissingBracketHandler.findMissingText(
+        buildSbt,
+        buildSbt.length,
+        2,
+        "fake.txt",
+        new MessageOnlyException("fake")
+      )
+      ()
     }
+  }
 
-    "handle xml error " in {
+  test("it should handle xml error") {
+    try {
       val buildSbt =
         """
           |val a = <a/><b/>
           |val s = '
         """.stripMargin
-      SbtParser(SbtParser.FAKE_FILE, buildSbt.lines.toSeq) must throwA[MessageOnlyException].like {
-        case exp =>
-          val message = exp.getMessage
-          println(s"${exp.getMessage}")
-          message must contain(SbtParser.FAKE_FILE.getName)
-      }
+      SbtParser(SbtParser.FAKE_FILE, buildSbt.linesIterator.toSeq)
+    } catch {
+      case exp: MessageOnlyException =>
+        val message = exp.getMessage
+        println(s"${exp.getMessage}")
+        assert(message.contains(SbtParser.FAKE_FILE.getName))
     }
-
   }
 
   private def containsLineNumber(buildSbt: String) = {
@@ -66,8 +79,7 @@ class ErrorSpec extends AbstractSpec with ScalaCheck {
       case exception: MessageOnlyException =>
         val error = exception.getMessage
         """(\d+)""".r.findFirstIn(error) match {
-          case Some(x) =>
-            true
+          case Some(_) => true
           case None =>
             println(s"Number not found in $error")
             false
diff --git a/main/src/test/scala/sbt/internal/parser/NewFormatSpec.scala b/main/src/test/scala/sbt/internal/parser/NewFormatSpec.scala
index 89a2749d7..b8253a55e 100644
--- a/main/src/test/scala/sbt/internal/parser/NewFormatSpec.scala
+++ b/main/src/test/scala/sbt/internal/parser/NewFormatSpec.scala
@@ -1,33 +1,32 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
 import java.io.File
 
-import org.junit.runner.RunWith
-import org.specs2.runner.JUnitRunner
-
 import scala.io.Source
 
-@RunWith(classOf[JUnitRunner])
-class NewFormatSpec extends AbstractSpec {
+object NewFormatSpec extends AbstractSpec {
   implicit val splitter: SplitExpressions.SplitExpression = EvaluateConfigurations.splitExpressions
 
-  "New Format " should {
-    "Handle lines " in {
-      val rootPath = getClass.getClassLoader.getResource("").getPath + "/new-format/"
-      println(s"Reading files from: $rootPath")
-      val allFiles = new File(rootPath).listFiles.toList
-      foreach(allFiles) {
-        path =>
-          println(s"$path")
-          val lines = Source.fromFile(path).getLines().toList
-          val (_, statements) = splitter(path, lines)
-          statements.nonEmpty must be_==(true).setMessage(s"""
-                               |***should contains statements***
-                               |$lines """.stripMargin)
-      }
+  test("New Format should handle lines") {
+    val rootPath = getClass.getResource("/new-format").getPath
+    println(s"Reading files from: $rootPath")
+    val allFiles = new File(rootPath).listFiles.toList
+    allFiles foreach { path =>
+      println(s"$path")
+      val lines = Source.fromFile(path).getLines().toList
+      val (_, statements) = splitter(path, lines)
+      assert(statements.nonEmpty, s"""
+           |***should contains statements***
+           |$lines """.stripMargin)
     }
   }
-
 }
diff --git a/main/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala b/main/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala
index cb7488290..61e26dc4c 100644
--- a/main/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala
+++ b/main/src/test/scala/sbt/internal/parser/SessionSettingsSpec.scala
@@ -1,68 +1,73 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
 import java.io.{ File, FilenameFilter }
 
-import org.specs2.matcher.MatchResult
-
-import scala.collection.GenTraversableOnce
 import scala.io.Source
 import SessionSettings.SessionSetting
 
 abstract class AbstractSessionSettingsSpec(folder: String) extends AbstractSpec {
-  protected val rootPath = getClass.getClassLoader.getResource("").getPath + folder
+  protected val rootPath = getClass.getResource("/" + folder).getPath
   println(s"Reading files from: $rootPath")
   protected val rootDir = new File(rootPath)
 
-  "SessionSettings " should {
-    "Be identical for empty map " in {
-      def unit(f: File) = Seq((Source.fromFile(f).getLines().toList, Seq()))
-      runTestOnFiles(unit)
-    }
-
-    "Replace statements " in {
-      runTestOnFiles(replace)
-    }
+  test("SessionSettings should be identical for empty map") {
+    def unit(f: File) = Seq((Source.fromFile(f).getLines().toList, Seq()))
+    runTestOnFiles(unit)
   }
 
-  private def runTestOnFiles(expectedResultAndMap: File => Seq[(List[String], Seq[SessionSetting])]): MatchResult[GenTraversableOnce[File]] = {
+  test("it should replace statements") {
+    runTestOnFiles(replace)
+  }
 
-    val allFiles = rootDir.listFiles(new FilenameFilter() {
-      def accept(dir: File, name: String) = name.endsWith(".sbt.txt")
-    }).toList
-    foreach(allFiles) {
-      file =>
-        val originalLines = Source.fromFile(file).getLines().toList
-        foreach(expectedResultAndMap(file)) {
-          case (expectedResultList, commands) =>
-            val resultList = SbtRefactorings.applySessionSettings((file, originalLines), commands)
-            val expected = SbtParser(file, expectedResultList)
-            val result = SbtParser(file, resultList._2)
-            result.settings must_== expected.settings
+  private def runTestOnFiles(
+      expectedResultAndMap: File => Seq[(List[String], Seq[SessionSetting])]
+  ): Unit = {
 
-        }
+    val allFiles = rootDir
+      .listFiles(new FilenameFilter() {
+        def accept(dir: File, name: String) = name.endsWith(".sbt.txt")
+      })
+      .toList
+    allFiles foreach { file =>
+      val originalLines = Source.fromFile(file).getLines().toList
+      expectedResultAndMap(file) foreach {
+        case (expectedResultList, commands) =>
+          val resultList = SbtRefactorings.applySessionSettings((file, originalLines), commands)
+          val expected = SbtParser(file, expectedResultList)
+          val result = SbtParser(file, resultList._2)
+          assert(result.settings == expected.settings)
+      }
     }
   }
 
   protected def replace(f: File) = {
-    val dirs = rootDir.listFiles(new FilenameFilter() {
-      def accept(dir: File, name: String) = {
-        val startsWith = f.getName + "_"
-        name.startsWith(startsWith)
-      }
-    }).toSeq
-    dirs.flatMap {
-      dir =>
-        val files = dir.listFiles(new FilenameFilter {
-          override def accept(dir: File, name: String) = name.endsWith(".set")
-        })
-        files.map { file =>
-          val seq = Source.fromFile(file).getLines().toSeq
-          val result = Source.fromFile(file.getAbsolutePath + ".result").getLines().toList
-          val sessionSettings = seq.map(line => (null, Seq(line)))
-          (result, sessionSettings)
+    val dirs = rootDir
+      .listFiles(new FilenameFilter() {
+        def accept(dir: File, name: String) = {
+          val startsWith = f.getName + "_"
+          name.startsWith(startsWith)
         }
+      })
+      .toSeq
+    dirs.flatMap { dir =>
+      val files = dir.listFiles(new FilenameFilter {
+        override def accept(dir: File, name: String) = name.endsWith(".set")
+      })
+      files.map { file =>
+        val seq = Source.fromFile(file).getLines().toSeq
+        val result = Source.fromFile(file.getAbsolutePath + ".result").getLines().toList
+        val sessionSettings = seq.map(line => (null, Seq(line)))
+        (result, sessionSettings)
+      }
     }
   }
 
@@ -70,4 +75,4 @@ abstract class AbstractSessionSettingsSpec(folder: String) extends AbstractSpec
 
 class SessionSettingsSpec extends AbstractSessionSettingsSpec("session-settings")
 
-class SessionSettingsQuickSpec extends AbstractSessionSettingsSpec("session-settings-quick")
\ No newline at end of file
+class SessionSettingsQuickSpec extends AbstractSessionSettingsSpec("session-settings-quick")
diff --git a/main/src/test/scala/sbt/internal/parser/SplitExpressions.scala b/main/src/test/scala/sbt/internal/parser/SplitExpressions.scala
index 75b31f312..fd8733a7a 100644
--- a/main/src/test/scala/sbt/internal/parser/SplitExpressions.scala
+++ b/main/src/test/scala/sbt/internal/parser/SplitExpressions.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
diff --git a/main/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala b/main/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala
index 1fe418a03..a8f652149 100644
--- a/main/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala
+++ b/main/src/test/scala/sbt/internal/parser/SplitExpressionsBehavior.scala
@@ -1,44 +1,54 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
 import java.io.File
 
-import org.specs2.mutable.SpecificationLike
+import sbt.internal.util.LineRange
 
 trait SplitExpression {
-  def split(s: String, file: File = new File("noFile"))(implicit splitter: SplitExpressions.SplitExpression) = splitter(file, s.split("\n").toSeq)
+  def split(s: String, file: File = new File("noFile"))(
+      implicit splitter: SplitExpressions.SplitExpression
+  ): (Seq[(String, Int)], Seq[(String, LineRange)]) = splitter(file, s.split("\n").toSeq)
 }
 
-trait SplitExpressionsBehavior extends SplitExpression {
-  this: SpecificationLike =>
+trait SplitExpressionsBehavior extends SplitExpression { this: verify.BasicTestSuite =>
 
-  def newExpressionsSplitter(implicit splitter: SplitExpressions.SplitExpression): Unit = {
+  def newExpressionsSplitter(implicit splitter: SplitExpressions.SplitExpression) = {
 
-    "parse a two settings without intervening blank line" in {
+    test("parse a two settings without intervening blank line") {
       val (imports, settings) = split("""version := "1.0"
 scalaVersion := "2.10.4"""")
 
-      imports.isEmpty should beTrue
-      settings.size === 2
+      assert(imports.isEmpty)
+      assert(settings.size == 2)
     }
 
-    "parse a setting and val without intervening blank line" in {
-      val (imports, settings) = split("""version := "1.0"
+    test("parse a setting and val without intervening blank line") {
+      val (imports, settings) =
+        split("""version := "1.0"
 lazy val root = (project in file(".")).enablePlugins­(PlayScala)""")
 
-      imports.isEmpty should beTrue
-      settings.size === 2
+      assert(imports.isEmpty)
+      assert(settings.size == 2)
     }
 
-    "parse a config containing two imports and a setting with no blank line" in {
+    test("parse a config containing two imports and a setting with no blank line") {
       val (imports, settingsAndDefs) = split(
         """import foo.Bar
               import foo.Bar
              version := "1.0"
-        """.stripMargin)
-      imports.size === 2
-      settingsAndDefs.size === 1
+        """.stripMargin
+      )
+      assert(imports.size == 2)
+      assert(settingsAndDefs.size == 1)
     }
 
   }
diff --git a/main/src/test/scala/sbt/internal/parser/SplitExpressionsTest.scala b/main/src/test/scala/sbt/internal/parser/SplitExpressionsTest.scala
index b3667c685..794a4edba 100644
--- a/main/src/test/scala/sbt/internal/parser/SplitExpressionsTest.scala
+++ b/main/src/test/scala/sbt/internal/parser/SplitExpressionsTest.scala
@@ -1,11 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 package parser
 
-import org.specs2.mutable.Specification
-
-class SplitExpressionsTest extends Specification with SplitExpressionsBehavior {
-
-  "EvaluateConfigurations" should newExpressionsSplitter(EvaluateConfigurations.splitExpressions)
-
+object SplitExpressionsTest extends verify.BasicTestSuite with SplitExpressionsBehavior {
+  newExpressionsSplitter(EvaluateConfigurations.splitExpressions)
 }
diff --git a/main/src/test/scala/sbt/internal/server/DefinitionTest.scala b/main/src/test/scala/sbt/internal/server/DefinitionTest.scala
new file mode 100644
index 000000000..f2c477e85
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/server/DefinitionTest.scala
@@ -0,0 +1,242 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import com.github.benmanes.caffeine.cache.Caffeine
+import sbt.internal.inc.Analysis
+
+object DefinitionTest extends verify.BasicTestSuite {
+  import Definition.textProcessor
+  test(
+    "text processor should find valid standard scala identifier when caret is set at the start of it"
+  ) {
+    assert(textProcessor.identifier("val identifier = 0", 4) == Some("identifier"))
+  }
+
+  test("it should not find valid standard scala identifier because it is '='") {
+    assert(textProcessor.identifier("val identifier = 0", 15) == None)
+  }
+
+  test("it should find valid standard scala identifier when caret is set in the middle of it") {
+    assert(textProcessor.identifier("val identifier = 0", 11) == Some("identifier"))
+  }
+
+  test("it should find valid standard scala identifier with comma") {
+    assert(
+      textProcessor.identifier("def foo(a: identifier, b: other) = ???", 13) == Some("identifier")
+    )
+  }
+
+  test("it should find valid standard short scala identifier when caret is set at the start of it") {
+    assert(textProcessor.identifier("val a = 0", 4) == Some("a"))
+  }
+
+  test("it should find valid standard short scala identifier when caret is set at the end of it") {
+    assert(textProcessor.identifier("def foo(f: Int) = Foo(f)", 19) == Some("Foo"))
+  }
+
+  test(
+    "it should find valid non-standard short scala identifier when caret is set at the start of it"
+  ) {
+    assert(textProcessor.identifier("val == = 0", 4) == Some("=="))
+  }
+
+  test(
+    "it should find valid non-standard short scala identifier when caret is set in the middle of it"
+  ) {
+    assert(textProcessor.identifier("val == = 0", 5) == Some("=="))
+  }
+
+  test(
+    "it should find valid non-standard short scala identifier when caret is set at the end of it"
+  ) {
+    assert(textProcessor.identifier("val == = 0", 6) == Some("=="))
+  }
+
+  test(
+    "it should choose longest valid standard scala identifier from scala keyword when caret is set at the start of it"
+  ) {
+    assert(
+      textProcessor.identifier("val k = 0", 0) == Some("va") || textProcessor
+        .identifier("val k = 0", 0) == Some("al")
+    )
+  }
+
+  test(
+    "it should choose longest valid standard scala identifier from scala keyword when caret is set in the middle of it"
+  ) {
+    assert(
+      textProcessor.identifier("val k = 0", 1) == Some("va") || textProcessor
+        .identifier("val k = 0", 1) == Some("al")
+    )
+  }
+
+  test("it should match symbol as class name") {
+    assert(textProcessor.potentialClsOrTraitOrObj("A")("com.acme.A") == "com.acme.A")
+  }
+
+  test("it should match symbol as object name") {
+    assert(textProcessor.potentialClsOrTraitOrObj("A")("com.acme.A$") == "com.acme.A$")
+  }
+
+  test("it should match symbol as inner class name") {
+    assert(textProcessor.potentialClsOrTraitOrObj("A")("com.acme.A$A") == "com.acme.A$A")
+  }
+
+  test("it should match symbol as inner object name") {
+    assert(textProcessor.potentialClsOrTraitOrObj("A")("com.acme.A$A$") == "com.acme.A$A$")
+  }
+
+  test("it should match symbol as default package class name") {
+    assert(textProcessor.potentialClsOrTraitOrObj("A")("A") == "A")
+  }
+
+  test("it should match symbol as default package object name") {
+    assert(textProcessor.potentialClsOrTraitOrObj("A")("A$") == "A$")
+  }
+
+  test("it should match object in line version 1") {
+    assert(textProcessor.classTraitObjectInLine("A")("   object A  ").contains(("object A", 3)))
+  }
+
+  test("it should match object in line version 2") {
+    assert(
+      textProcessor.classTraitObjectInLine("A")("   object    A  ").contains(("object    A", 3))
+    )
+  }
+
+  test("it should match object in line version 3") {
+    assert(textProcessor.classTraitObjectInLine("A")("object A {").contains(("object A", 0)))
+  }
+
+  test("it should not match object in line") {
+    assert(textProcessor.classTraitObjectInLine("B")("object A  ").isEmpty)
+  }
+
+  test("it should match class in line version 1") {
+    assert(textProcessor.classTraitObjectInLine("A")("   class A  ").contains(("class A", 3)))
+  }
+
+  test("it should match class in line version 2") {
+    assert(textProcessor.classTraitObjectInLine("A")("   class    A  ").contains(("class    A", 3)))
+  }
+
+  test("it should match class in line version 3") {
+    assert(textProcessor.classTraitObjectInLine("A")("class A {").contains(("class A", 0)))
+  }
+
+  test("it should match class in line version 4") {
+    assert(
+      textProcessor.classTraitObjectInLine("A")("   class    A[A]  ").contains(("class    A", 3))
+    )
+  }
+
+  test("it should match class in line version 5") {
+    assert(
+      textProcessor
+        .classTraitObjectInLine("A")("   class    A  [A] ")
+        .contains(
+          ("class    A", 3)
+        )
+    )
+  }
+
+  test("it should match class in line version 6") {
+    assert(textProcessor.classTraitObjectInLine("A")("class A[A[_]] {").contains(("class A", 0)))
+  }
+
+  test("it should not match class in line") {
+    assert(textProcessor.classTraitObjectInLine("B")("class A  ").isEmpty)
+  }
+
+  test("match trait in line version 1") {
+    assert(textProcessor.classTraitObjectInLine("A")("   trait A  ").contains(("trait A", 3)))
+  }
+
+  test("it should match trait in line version 2") {
+    assert(textProcessor.classTraitObjectInLine("A")("   trait    A  ").contains(("trait    A", 3)))
+  }
+
+  test("it should match trait in line version 3") {
+    assert(textProcessor.classTraitObjectInLine("A")("trait A {").contains(("trait A", 0)))
+  }
+
+  test("it should match trait in line version 4") {
+    assert(
+      textProcessor
+        .classTraitObjectInLine("A")("   trait    A[A]  ")
+        .contains(
+          ("trait    A", 3)
+        )
+    )
+  }
+
+  test("it should match trait in line version 5") {
+    assert(
+      textProcessor
+        .classTraitObjectInLine("A")("   trait    A  [A] ")
+        .contains(
+          ("trait    A", 3)
+        )
+    )
+  }
+
+  test("it should match trait in line version 6") {
+    assert(textProcessor.classTraitObjectInLine("A")("trait A[A[_]] {").contains(("trait A", 0)))
+  }
+
+  test("it should not match trait in line") {
+    assert(textProcessor.classTraitObjectInLine("B")("trait A  ").isEmpty)
+  }
+
+  test("definition should cache data in cache") {
+    val cache = Caffeine.newBuilder().build[String, Definition.Analyses]()
+    val cacheFile = "Test.scala"
+    val useBinary = true
+
+    Definition.updateCache(cache)(cacheFile, useBinary)
+
+    val actual = Definition.AnalysesAccess.getFrom(cache)
+
+    assert(actual.get.contains(("Test.scala" -> true -> None)))
+  }
+
+  test("it should replace cache data in cache") {
+    val cache = Caffeine.newBuilder().build[String, Definition.Analyses]()
+    val cacheFile = "Test.scala"
+    val useBinary = true
+    val falseUseBinary = false
+
+    Definition.updateCache(cache)(cacheFile, falseUseBinary)
+    Definition.updateCache(cache)(cacheFile, useBinary)
+
+    val actual = Definition.AnalysesAccess.getFrom(cache)
+
+    assert(actual.get.contains(("Test.scala" -> true -> None)))
+  }
+
+  test("it should cache more data in cache") {
+    val cache = Caffeine.newBuilder().build[String, Definition.Analyses]()
+    val cacheFile = "Test.scala"
+    val useBinary = true
+    val otherCacheFile = "OtherTest.scala"
+    val otherUseBinary = false
+
+    Definition.updateCache(cache)(otherCacheFile, otherUseBinary)
+    Definition.updateCache(cache)(cacheFile, useBinary)
+
+    val actual = Definition.AnalysesAccess.getFrom(cache)
+
+    assert(
+      actual.get.contains("Test.scala" -> true -> Option.empty[Analysis]) &&
+        actual.get.contains("OtherTest.scala" -> false -> Option.empty[Analysis])
+    )
+  }
+}
diff --git a/main/src/test/scala/sbt/internal/server/SettingQueryTest.scala b/main/src/test/scala/sbt/internal/server/SettingQueryTest.scala
new file mode 100644
index 000000000..d64488a70
--- /dev/null
+++ b/main/src/test/scala/sbt/internal/server/SettingQueryTest.scala
@@ -0,0 +1,288 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package server
+
+import java.io._
+import java.net._
+import java.nio.file._
+import java.util.concurrent._
+
+import scala.collection.mutable
+import scala.util.Properties.versionNumberString
+
+import xsbti.{ Logger => _, _ }
+import sbt.io.IO
+import sbt.internal.BuildStreams.{ Streams => _, _ }
+import sbt.internal.Load._
+import sbt.util._
+import sbt.BuildPaths._
+import sbt.Def.{ ScopeLocal, ScopedKey, Setting }
+import sbt.Keys._
+
+object SettingQueryTest extends verify.BasicTestSuite {
+  implicit class PathOps(val path: Path) extends AnyVal {
+    def /(other: String): Path = if (other == ".") path else path resolve other
+  }
+
+  val baseDir: Path = Files createTempDirectory "sbt-setting-query-test"
+  val globalDir: Path = Files createTempDirectory "sbt-setting-query-test-global-dir"
+  val bootDir: Path = Files createTempDirectory "sbt-setting-query-test-boot-dir"
+  val ivyHome: Path = Files createTempDirectory "sbt-setting-query-test-ivy-home"
+  val logFile: File = File.createTempFile("sbt", ".log")
+
+  val baseFile: File = baseDir.toFile
+  val baseUri: URI = IO directoryURI baseFile
+  IO assertAbsolute baseUri
+
+  val globalDirFile: File = globalDir.toFile
+
+  def ??? : Nothing = { Thread.dumpStack(); throw new NotImplementedError }
+
+  val noopLoader: ClassLoader = new URLClassLoader(Array(), null)
+
+  object NoGlobalLock extends GlobalLock {
+    def apply[T](lockFile: File, run: Callable[T]) = run.call()
+  }
+
+  lazy val buildStructure: BuildStructure = {
+    val projectSettings: Seq[Setting[_]] = Seq(scalaVersion := "2.12.1")
+
+    val appConfig: AppConfiguration = new AppConfiguration {
+      def baseDirectory(): File = baseFile
+      def arguments(): Array[String] = Array()
+      def provider(): AppProvider = new AppProvider {
+        def scalaProvider(): ScalaProvider = new ScalaProvider { scalaProvider =>
+          def launcher(): Launcher = new Launcher {
+            def getScala(version: String): ScalaProvider = getScala(version, "")
+            def getScala(version: String, reason: String): ScalaProvider =
+              getScala(version, reason, "org.scala-lang")
+            def getScala(version: String, reason: String, scalaOrg: String): ScalaProvider =
+              scalaProvider
+
+            def app(id: ApplicationID, version: String): AppProvider = ???
+
+            def topLoader(): ClassLoader = noopLoader
+            def globalLock(): GlobalLock = NoGlobalLock
+            def bootDirectory(): File = bootDir.toFile
+            def ivyRepositories(): Array[Repository] = Array()
+            def appRepositories(): Array[Repository] = Array()
+            def isOverrideRepositories: Boolean = false
+            def ivyHome(): File = SettingQueryTest.this.ivyHome.toFile
+            def checksums(): Array[String] = Array()
+          }
+          def version(): String = "2.12.1"
+
+          def loader(): ClassLoader = noopLoader
+          def jars(): Array[File] = Array(libraryJar, compilerJar)
+
+          def libraryJar(): File = new File("scala-library.jar")
+          def compilerJar(): File = new File("scala-compiler.jar")
+
+          def app(id: ApplicationID): AppProvider = ???
+        }
+
+        def id(): ApplicationID = sbt.ApplicationID(
+          "org.scala-sbt",
+          "sbt",
+          "0.13.13",
+          "sbt.xMain",
+          components = Seq(),
+          crossVersionedValue = CrossValue.Disabled,
+          extra = Seq()
+        )
+
+        def loader(): ClassLoader = noopLoader
+
+        def entryPoint(): Class[_] = ???
+        def mainClass(): Class[_ <: AppMain] = ???
+        def newMain(): AppMain = ???
+
+        def mainClasspath(): Array[File] = Array()
+
+        def components(): ComponentProvider = new ComponentProvider {
+          def componentLocation(id: String): File = ???
+          def component(componentID: String): Array[File] = ???
+          def defineComponent(componentID: String, components: Array[File]): Unit = ???
+          def addToComponent(componentID: String, components: Array[File]): Boolean = ???
+          def lockFile(): File = ???
+        }
+      }
+    }
+
+    val state: State =
+      StandardMain
+        .initialState(appConfig, initialDefinitions = Seq(), preCommands = Seq())
+        .put(globalBaseDirectory, globalDirFile)
+
+    val config0 = defaultPreGlobal(state, baseFile, globalDirFile, state.log)
+    val config = defaultWithGlobal(state, baseFile, config0, globalDirFile)
+
+    val buildUnit: BuildUnit = {
+      val loadedPlugins: LoadedPlugins =
+        noPlugins(
+          projectStandard(baseFile),
+          config.copy(pluginManagement = config.pluginManagement.forPlugin)
+        )
+
+      val project: Project = {
+        val project0 = Project("t", baseFile) settings projectSettings
+        val fileToLoadedSbtFileMap = new mutable.HashMap[File, LoadedSbtFile]
+        val autoPlugins = loadedPlugins.detected.deducePluginsFromProject(project0, state.log)
+        val injectSettings = config.injectSettings
+        resolveProject(
+          project0,
+          autoPlugins,
+          loadedPlugins,
+          injectSettings,
+          fileToLoadedSbtFileMap,
+          Nil,
+          state.log
+        )
+      }
+
+      val projects: Seq[Project] = Seq(project)
+      val builds: Seq[BuildDef] = BuildDef.defaultAggregated(project.id, Nil) :: Nil
+      val defs: LoadedDefinitions =
+        new LoadedDefinitions(baseFile, Nil, noopLoader, builds, projects, Nil)
+      new BuildUnit(baseUri, baseFile, defs, loadedPlugins)
+    }
+
+    val (partBuildUnit: PartBuildUnit, projectRefs: List[ProjectReference]) = loaded(buildUnit)
+    val partBuildUnits: Map[URI, PartBuildUnit] = Map(buildUnit.uri -> partBuildUnit)
+    val allProjectRefs: Map[URI, List[ProjectReference]] = Map(buildUnit.uri -> projectRefs)
+    checkAll(allProjectRefs, partBuildUnits)
+
+    val partBuild: PartBuild = new PartBuild(baseUri, partBuildUnits)
+    val loadedBuild: LoadedBuild = resolveProjects(partBuild)
+
+    val units: Map[URI, LoadedBuildUnit] = loadedBuild.units
+
+    val settings: Seq[Setting[_]] = finalTransforms(
+      buildConfigurations(loadedBuild, getRootProject(units), config.injectSettings)
+    )
+    val delegates: Scope => Seq[Scope] = defaultDelegates(loadedBuild)
+    val scopeLocal: ScopeLocal = EvaluateTask.injectStreams
+    val display: Show[ScopedKey[_]] = Project showLoadingKey loadedBuild
+
+    val (cMap, data) = Def.makeWithCompiledMap(settings)(delegates, scopeLocal, display)
+    val extra: KeyIndex => BuildUtil[_] = index => BuildUtil(baseUri, units, index, data)
+
+    val index: StructureIndex = structureIndex(data, settings, extra, units)
+    val streams: State => Streams = mkStreams(units, baseUri, data)
+
+    val structure: BuildStructure =
+      new BuildStructure(
+        units,
+        baseUri,
+        settings,
+        data,
+        index,
+        streams,
+        delegates,
+        scopeLocal,
+        cMap
+      )
+
+    structure
+  }
+
+  def query(setting: String): String = {
+    import sbt.protocol._
+    val req: SettingQuery = sbt.protocol.SettingQuery(setting)
+    val rsp: SettingQueryResponse = server.SettingQuery.handleSettingQuery(req, buildStructure)
+    val bytes: Array[Byte] = Serialization serializeEventMessage rsp
+    val payload: String = new String(bytes, java.nio.charset.StandardCharsets.UTF_8)
+    payload
+  }
+
+  def qok(x: String, t: String): String =
+    s"""{"type":"SettingQuerySuccess","value":$x,"contentType":"$t"}"""
+  def qko(msg: String): String =
+    s"""{"type":"SettingQueryFailure","message":"$msg"}"""
+
+  test("t/scalaVersion") {
+    assertEquals(qok("\"2.12.1\"", "java.lang.String"), query("t/scalaVersion"))
+  }
+
+  // test("t/pollInterval") {
+  //   assertEquals(qok("500", "Int"), query("t/pollInterval"))
+  // }
+
+  test("t/sourcesInBase") {
+    assertEquals(qok("true", "Boolean"), query("t/sourcesInBase"))
+  }
+
+  test("t/startYear") {
+    assertEquals(qok("null", "scala.Option[Int]"), query("t/startYear"))
+  }
+
+  test("t/scalaArtifacts") {
+    if (versionNumberString.startsWith("2.12"))
+      assertEquals(
+        qok(
+          """["scala-library","scala-compiler","scala-reflect","scala-actors","scalap"]""",
+          "scala.collection.Seq[java.lang.String]"
+        ),
+        query("t/scalaArtifacts"),
+      )
+    else
+      assertEquals(
+        qok(
+          """["scala-library","scala-compiler","scala-reflect","scala-actors","scalap"]""",
+          "scala.collection.immutable.Seq[java.lang.String]"
+        ),
+        query("t/scalaArtifacts"),
+      )
+  }
+
+  test("t/libraryDependencies") {
+    if (versionNumberString.startsWith("2.12"))
+      assertEquals(
+        qok(
+          """[{"organization":"org.scala-lang","name":"scala-library","revision":"2.12.1","isChanging":false,"isTransitive":true,"isForce":false,"explicitArtifacts":[],"inclusions":[],"exclusions":[],"extraAttributes":{},"crossVersion":{"type":"Disabled"}}]""",
+          "scala.collection.Seq[sbt.librarymanagement.ModuleID]"
+        ),
+        query("t/libraryDependencies"),
+      )
+    else
+      assertEquals(
+        qok(
+          """[{"organization":"org.scala-lang","name":"scala-library","revision":"2.12.1","isChanging":false,"isTransitive":true,"isForce":false,"explicitArtifacts":[],"inclusions":[],"exclusions":[],"extraAttributes":{},"crossVersion":{"type":"Disabled"}}]""",
+          "scala.collection.immutable.Seq[sbt.librarymanagement.ModuleID]"
+        ),
+        query("t/libraryDependencies"),
+      )
+  }
+
+  test("scalaVersion") {
+    assertEquals(
+      qko("Not a valid project ID: scalaVersion\\nscalaVersion\\n            ^"),
+      query("scalaVersion"),
+    )
+  }
+
+  test("t/scalacOptions") {
+    assertEquals(
+      qko(
+        s"""Key ProjectRef(uri(\\"$baseUri\\"), \\"t\\") / Compile / scalacOptions is a task, can only query settings"""
+      ),
+      query("t/scalacOptions"),
+    )
+  }
+
+  test("t/fooo") {
+    assertEquals(
+      qko(
+        "Expected ':' (if selecting a configuration)\\nNot a valid key: fooo (similar: fork)\\nt/fooo\\n      ^"
+      ),
+      query("t/fooo"),
+    )
+  }
+}
diff --git a/main/src/test/scala/testpkg/CompletionSpec.scala b/main/src/test/scala/testpkg/CompletionSpec.scala
new file mode 100644
index 000000000..686001859
--- /dev/null
+++ b/main/src/test/scala/testpkg/CompletionSpec.scala
@@ -0,0 +1,83 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import java.net.URI
+
+import sbt.{ Result => _, _ }
+import sbt.Def._
+import sbt.internal.TestBuild
+import sbt.internal.TestBuild._
+import sbt.internal.util.AttributeKey
+import sbt.librarymanagement.Configuration
+import hedgehog._
+import hedgehog.runner._
+import _root_.sbt.internal.util.complete.Parser
+
+object CompletionSpec extends Properties {
+  override def tests: List[Test] =
+    List(
+      property("can complete any build", TestBuild.uriGen.forAll.map { uri =>
+        complete(buildURI = uri, line = "{", expected = "{" + uri.toString + "}")
+      }),
+      property("can complete any project", TestBuild.nonEmptyId.forAll.map { id =>
+        complete(projectID = id, line = id.head.toString, expected = id)
+      }),
+      property(
+        "can complete any configuration",
+        TestBuild.nonEmptyId.forAll.map { name =>
+          val cap = name.capitalize
+          complete(configName = name, line = cap.head.toString, expected = cap)
+        }
+      ),
+      // property("can complete any attribute", TestBuild.kebabIdGen.forAll.map { name =>
+      //   complete(attributeName = name, line = name.head.toString, expected = name)
+      // })
+    )
+
+  private def complete(
+      buildURI: URI = new URI("file", "///path/", null),
+      projectID: String = "p",
+      configName: String = "compile",
+      attributeName: String = "a",
+      line: String,
+      expected: String,
+  ): Result = {
+    val attributeKey = AttributeKey[String](attributeName)
+    val scope = Scope(
+      Select(BuildRef(buildURI)),
+      Select(ConfigKey(configName)),
+      Select(attributeKey),
+      Zero
+    )
+    val config = Configuration.of(configName.capitalize, configName)
+    val project = Proj(projectID, Nil, Seq(config))
+    val projects = Vector(project)
+    val build = Build(buildURI, projects)
+    val builds = Vector(build)
+    val task = Taskk(attributeKey, Nil)
+    val tasks = Vector(task)
+    val env = Env(builds, tasks)
+    val settings = env.tasks.map { t =>
+      Def.setting(ScopedKey(scope, t.key), Def.value("value"))
+    }
+    val structure = TestBuild.structure(env, settings, build.allProjects.head._1)
+    // val scopedKey = ScopedKey(scope, attributeKey)
+    // val string = displayMasked(scopedKey, ScopeMask())
+    val parser = makeParser(structure)
+    val cs = Parser.completions(parser, line, 10)
+
+    Result
+      .assert(
+        cs.get.exists(c => (line + c.append) == expected || (line + c.append) == expected + "/")
+      )
+      .log(s"line: $line")
+      .log(s"completions: ${cs.get.map(_.append)}")
+      .log(s"structure: $structure")
+  }
+}
diff --git a/notes/0.13.11.markdown b/notes/0.13.11.markdown
index 3b9d369a8..64fe831df 100644
--- a/notes/0.13.11.markdown
+++ b/notes/0.13.11.markdown
@@ -1,14 +1,14 @@
 
   [@eed3si9n]: https://github.com/eed3si9n
   [@jsuereth]: https://github.com/jsuereth
-  [@dwijnand]: http://github.com/dwijnand
-  [@Duhemm]: http://github.com/Duhemm
+  [@dwijnand]: https://github.com/dwijnand
+  [@Duhemm]: https://github.com/Duhemm
   [@gkossakowski]: https://github.com/gkossakowski
   [@adriaanm]: https://github.com/adriaanm
   [@jrudolph]: https://github.com/jrudolph
   [@stuhood]: https://github.com/stuhood
   [@pdalpra]: https://github.com/pdalpra
-  [@fkorotkov]: http://github.com/fkorotkov
+  [@fkorotkov]: https://github.com/fkorotkov
   [@hgiddens]: https://github.com/hgiddens
   [@DavidPerezIngeniero]: https://github.com/DavidPerezIngeniero
   [@romanowski]: https://github.com/romanowski
@@ -188,7 +188,7 @@ When `trackInternalDependencies` is set to `TrackLevel.TrackIfMissing`, sbt will
         ))
       )
 
-The `exportToInternal` setting allows the dependee subprojects to opt out of the internal tracking, which might be useful if you want to track most subprojects except for a few. The intersection of the `trackInternalDependencies` and `exportToInternal` settings will be used to determine the actual track level. Here's an example to opt-out one project:
+The `exportToInternal` setting allows the dependent subprojects to opt out of the internal tracking, which might be useful if you want to track most subprojects except for a few. The intersection of the `trackInternalDependencies` and `exportToInternal` settings will be used to determine the actual track level. Here's an example to opt-out one project:
 
     lazy val dontTrackMe = (project in file("dontTrackMe")).
       settings(
diff --git a/notes/0.13.12.markdown b/notes/0.13.12.markdown
new file mode 100644
index 000000000..777e969c4
--- /dev/null
+++ b/notes/0.13.12.markdown
@@ -0,0 +1,80 @@
+
+### Fixes with compatibility implications
+
+- By default the Scala toolchain artifacts are now transitively resolved using the provided `scalaVersion` and
+  `scalaOrganization`. Previously a user specified `scalaOrganization` would not have affected transitive
+  dependencies on, eg. `scala-reflect`. An Ivy-level mechanism is used for this purpose, and as a consequence
+  the overriding happens early in the resolution process which might improve resolution times, and as a side
+  benefit fixes [#2286][2286]. The old behavior can be restored by adding
+  `ivyScala := { ivyScala.value map {_.copy(overrideScalaVersion = sbtPlugin.value)} }`
+  to your build. [#2286][2286]/[#2634][2634] by [@milessabin][milessabin]
+- The Build trait is deprecated in favor of the `.sbt` format [#2530][2530] by [@dwijnand][@dwijnand]
+
+### Improvements
+
+- When `RecompileOnMacroDef` is enabled, sbt will now print out a info level log indicating that some sources are being recompiled because it's used from a source that contains a macro definition. Can be disabled with `incOptions := incOptions.value.withLogRecompileOnMacro(false)` [#2637][2637]/[#2659][2659] by [@eed3si9n][@eed3si9n]/[@dwijnand][@dwijnand]
+- Adds Windows script support and native file extensions on Unix platforms. [#2603][2603] by [@ekrich][@ekrich]
+- Improves loading time of large builds. [#2630][2630] by [@eed3si9n][@eed3si9n]
+- Adds the ability to call `dependsOn` for the current project inside a `.sbt` file. [#2653][2653] by [@anatolydwnld][@anatolydwnld]
+
+### Bug fixes
+
+- Fixes a 0.13.11 regression: dependency resolution hitting Maven Central even with repository overrides. [#2519][2519]/[#2569][2569] by [@eed3si9n][@eed3si9n]
+- Fixes a 0.13.11 regression in incremental compiler: `IndexOutOfBoundsException` in ExtractAPI [#2497][2497]/[#2557][2557] by [@smarter][@smarter]
+- Fixes merged dependency descriptors dropping configuration specification. [#2002][2002]/[#1500][1500] by [@eed3si9n][@eed3si9n]
+- Fixes merged dependency descriptors creating non-existing artifacts. [#2431][2431]/[#2500][2500] by [@Duhemm][@Duhemm]
+- Fixes incremental compilation misses when macro expansion references another source. [#2560][2560]/[#2563][2563] by [@eed3si9n][@eed3si9n]
+- Fixes incremental compilation of package objects transitively in name hashing. [#2432][2432]/[#2326][2326] by [@gkossakowski][@gkossakowski]
+- Fixes incremental compilation relying on filename of package objects. [#2438][2438] by [@Duhemm][@Duhemm]
+- Provides a workaround flag `incOptions := incOptions.value.withIncludeSynthToNameHashing(true)` for name hashing not including synthetic methods. This will not be enabled by default in sbt 0.13. It can also enabled by passing `sbt.inc.include_synth=true` to JVM. [#2537][2537] by [@eed3si9n][@eed3si9n]
+- Fixes tab completion for tasks defined in AutoPlugin's buildSettings [#2460][2460]/[#2469][2469] by [@Duhemm][@Duhemm]
+- Fixes configuration merging during cached resolution. [#2435][2435]/[#2513][2513] by [@Duhemm][@Duhemm]
+
+  [2637]: https://github.com/sbt/sbt/pull/2637
+  [2286]: https://github.com/sbt/sbt/issues/2286
+  [2634]: https://github.com/sbt/sbt/pull/2634
+  [2530]: https://github.com/sbt/sbt/pull/2530
+  [2460]: https://github.com/sbt/sbt/issues/2460
+  [2469]: https://github.com/sbt/sbt/pull/2469
+  [2432]: https://github.com/sbt/sbt/pull/2432
+  [2326]: https://github.com/sbt/sbt/issues/2326
+  [2438]: https://github.com/sbt/sbt/pull/2438
+  [2431]: https://github.com/sbt/sbt/issues/2431
+  [2500]: https://github.com/sbt/sbt/pull/2500
+  [2435]: https://github.com/sbt/sbt/issues/2435
+  [2513]: https://github.com/sbt/sbt/pull/2513
+  [2560]: https://github.com/sbt/sbt/issues/2560
+  [2563]: https://github.com/sbt/sbt/pull/2563
+  [2519]: https://github.com/sbt/sbt/issues/2519
+  [2569]: https://github.com/sbt/sbt/pull/2569
+  [2497]: https://github.com/sbt/sbt/issues/2497
+  [2557]: https://github.com/sbt/sbt/pull/2557
+  [2603]: https://github.com/sbt/sbt/pull/2603
+  [2630]: https://github.com/sbt/sbt/pull/2630
+  [2653]: https://github.com/sbt/sbt/pull/2653
+  [2642]: https://github.com/sbt/sbt/pull/2642
+  [2002]: https://github.com/sbt/sbt/issues/2002
+  [1500]: https://github.com/sbt/sbt/issues/1500
+  [2537]: https://github.com/sbt/sbt/issues/2537
+  [2659]: https://github.com/sbt/sbt/pull/2659
+
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@jsuereth]: https://github.com/jsuereth
+  [@dwijnand]: https://github.com/dwijnand
+  [@Duhemm]: https://github.com/Duhemm
+  [@gkossakowski]: https://github.com/gkossakowski
+  [@adriaanm]: https://github.com/adriaanm
+  [@jrudolph]: https://github.com/jrudolph
+  [@stuhood]: https://github.com/stuhood
+  [@pdalpra]: https://github.com/pdalpra
+  [@fkorotkov]: https://github.com/fkorotkov
+  [@hgiddens]: https://github.com/hgiddens
+  [@DavidPerezIngeniero]: https://github.com/DavidPerezIngeniero
+  [@romanowski]: https://github.com/romanowski
+  [@timcharper]: https://github.com/timcharper
+  [@smarter]: https://github.com/smarter
+  [@retronym]: https://github.com/retronym
+  [milessabin]: https://github.com/milessabin
+  [@ekrich]: https://github.com/ekrich
+  [@smarter]: https://github.com/smarter
+  [@anatolydwnld]: https://github.com/anatolydwnld
diff --git a/notes/0.13.12/native-script-support.md b/notes/0.13.12/native-script-support.md
deleted file mode 100644
index 67e4fda65..000000000
--- a/notes/0.13.12/native-script-support.md
+++ /dev/null
@@ -1,9 +0,0 @@
-  [@ekrich]: https://github.com/ekrich
-
-### Fixes with compatibility implications
-
-### Improvements
-
-- Add Windows script support and native file extensions on Unix platforms. By [@ekrich][@ekrich]
-
-### Bug fixes
\ No newline at end of file
diff --git a/notes/0.13.13.markdown b/notes/0.13.13.markdown
new file mode 100644
index 000000000..a49ddb60d
--- /dev/null
+++ b/notes/0.13.13.markdown
@@ -0,0 +1,168 @@
+
+### Fixes with compatibility implications
+
+- Deprecates the old sbt 0.12 DSL, to be removed in sbt 1.0. See below for more details.
+- The `.value` method is deprecated for input tasks. Calling `.value` on an input key returns an `InputTask[A]`,
+  which is completely unintuitive and often results in a bug. In most cases `.evaluated` should be called,
+  which returns `A` by evaluating the task.
+  Just in case `InputTask[A]` is needed, `.inputTaskValue` method is now provided. [#2709][2709] by [@eed3si9n][@eed3si9n]
+- sbt 0.13.13 renames the early command `--<command>` that was added in 0.13.1 to `early(<command>)`. This fixes the regression [#1041][1041]. For backward compatibility `--error`, `--warn`, `--info`, and `--debug` will continue to function during the 0.13 series, but it is strongly encouraged to migrate to the single hyphen options: `-error`, `-warn`, `-info`, and `-debug`. [#2742][2742] by [@eed3si9n][@eed3si9n]
+- Improve `show` when key returns a `Seq` by showing the elements one per line. Disable with `-Dsbt.disable.show.seq=true`. [#2755][2755] by [@eed3si9n][@eed3si9n]
+- Recycles classloaders to be anti-hostile to JIT. Disable with `-Dsbt.disable.interface.classloader.cache=true`. [#2754][2754] by [@retronym][@retronym]
+
+### Improvements
+
+- Adds `new` command and `templateResolverInfos`. See below for more details.
+- Auto plugins can add synthetic subprojects. See below for more details.
+- Supports wildcard exclusions in POMs [#1431][1431]/[sbt/ivy#22][sbt-ivy-22]/[#2731][2731] by [@jtgrabowski][@jtgrabowski]
+- Adds the ability to call `aggregateProjects(..)` for the current project inside a build sbt file. [#2682][2682] by [@xuwei-k][@xuwei-k]
+- Adds `.jvmopts` support to the launcher script. [sbt/sbt-launcher-package#111][111] by [@fommil][@fommil]
+- Adds `.java-version` support to the Windows launcher script. [sbt/sbt-launcher-package#111][111] by [@fommil][@fommil]
+- The startup log level is dropped to `-error` in script mode using `scalas`. [#840][840]/[#2746][2746] by [@eed3si9n][@eed3si9n]
+- Adds `CrossVersion.patch` which sits in between `CrossVersion.binary` and `CrossVersion.full` in that it strips off any
+  trailing `-bin-...` suffix which is used to distinguish variant but binary compatible Scala toolchain builds. Most things
+  which are currently `CrossVersion.full` (eg. Scala compiler plugins, esp. macro-paradise) would be more appropriately
+  depended on as `CrossVersion.patch` from this release on.
+
+### Bug fixes
+
+- Fixes a regression in sbt 0.13.12 that wrongly reports build-level keys to be ambiguous. [#2707][2707]/[#2708][2708] by [@Duhemm][@Duhemm]
+- Fixes a regression in sbt 0.13.12 that was misfiring Scala version enforcement when an alternative `scalaOrganization` is set. [#2703][2703] by [@milessabin][@milessabin]
+- Fixes `Tags.ForkedTestGroup`. [#2677][2677]/[#2681][2681] by [@pauldraper][@pauldraper]
+- Fixes forked tests being reported as successful when the test harness fails. [#2442][2442]/[#2722][2722]/[#2730][2730] by [@eed3si9n][@eed3si9n]/[@dwijnand][@dwijnand]
+- Fixes incorrect installation path on Windows. [sbt/sbt-launcher-package#110][110] by [@dwijnand][@dwijnand]
+
+### new command and templateResolverInfos
+
+sbt 0.13.13 adds a `new` command, which helps create new build definitions.
+The `new` command is extensible via a mechanism called the template resolver.
+A template resolver pattern matches on the passed in arguments after `new`,
+and if it's a match it will apply the template.
+
+As a reference implementation, template resolver for [Giter8][g8] is provided. For instance:
+
+    sbt new eed3si9n/hello.g8
+
+will run [eed3si9n/hello.g8][] using Giter8.
+
+[#2705][2705] by [@eed3si9n][@eed3si9n]
+
+### Synthetic subprojects
+
+sbt 0.13.13 adds support for `AutoPlugin`s to define subprojects programmatically,
+by overriding the `extraProjects` method:
+
+    import sbt._, Keys._
+
+    object ExtraProjectsPlugin extends AutoPlugin {
+      override def extraProjects: Seq[Project] =
+        List("foo", "bar", "baz") map generateProject
+
+      def generateProject(id: String): Project =
+        Project(id, file(id)).
+          settings(
+            name := id
+          )
+    }
+
+In addition, subprojects may be derived from an existing subproject
+by overriding `derivedProjects`:
+
+    import sbt._, Keys._
+
+    object DerivedProjectsPlugin extends AutoPlugin {
+      // Enable this plugin by default
+      override def requires: Plugins = sbt.plugins.CorePlugin
+      override def trigger = allRequirements
+
+      override def derivedProjects(proj: ProjectDefinition[_]): Seq[Project] =
+        // Make sure to exclude project extras to avoid recursive generation
+        if (proj.projectOrigin != ProjectOrigin.DerivedProject) {
+          val id = proj.id + "1"
+          Seq(
+            Project(id, file(id)).
+              enablePlugins(DatabasePlugin)
+          )
+        }
+        else Nil
+    }
+
+[#2532][2532]/[#2717][2717]/[#2738][2738] by [@eed3si9n][@eed3si9n]
+
+### Deprecate old sbt 0.12 DSL
+
+The no-longer-documented operators `<<=`, `<+=`, and `<++=` and tuple enrichments are deprecated,
+and will be removed in sbt 1.0.
+
+Generally,
+
+    task3 <<= (task1, task2) map { (t1, t2) => println(t1 + t2); t1 + t2 }
+
+should migrate to
+
+    task3 := {
+      println(task1.value + task2.value)
+      task1.value + task2.value
+    }
+
+Except for source generators, which requires task values:
+
+    sourceGenerators in Compile <+= buildInfo
+
+This becomes:
+
+    sourceGenerators in Compile += buildInfo.taskValue
+
+Another exception is input task:
+
+    run <<= docsRunSetting
+
+This becomes:
+
+    run := docsRunSetting.evaluated
+
+See [Migrating from sbt 0.12.x](https://www.scala-sbt.org/0.13/docs/Migrating-from-sbt-012x.html) for more details.
+
+[#2716][2716]/[#2763][2763]/[#2764][2764] by [@eed3si9n][@eed3si9n] and [@dwijnand][@dwijnand]
+
+  [g8]: http://www.foundweekends.org/giter8/
+  [eed3si9n/hello.g8]: https://github.com/eed3si9n/hello.g8
+
+  [840]: https://github.com/sbt/sbt/issues/840
+  [1041]: https://github.com/sbt/sbt/issues/1041
+  [1431]: https://github.com/sbt/sbt/issues/1431
+  [2442]: https://github.com/sbt/sbt/issues/2442
+  [2532]: https://github.com/sbt/sbt/issues/2532
+  [2677]: https://github.com/sbt/sbt/issues/2677
+  [2681]: https://github.com/sbt/sbt/pull/2681
+  [2705]: https://github.com/sbt/sbt/pull/2705
+  [2682]: https://github.com/sbt/sbt/pull/2682
+  [2703]: https://github.com/sbt/sbt/pull/2703
+  [2707]: https://github.com/sbt/sbt/issues/2707
+  [2708]: https://github.com/sbt/sbt/issues/2708
+  [2709]: https://github.com/sbt/sbt/pull/2709
+  [2716]: https://github.com/sbt/sbt/pull/2716
+  [2717]: https://github.com/sbt/sbt/pull/2717
+  [2722]: https://github.com/sbt/sbt/issues/2722
+  [2730]: https://github.com/sbt/sbt/pull/2730
+  [2731]: https://github.com/sbt/sbt/pull/2731
+  [2738]: https://github.com/sbt/sbt/issues/2738
+  [2742]: https://github.com/sbt/sbt/pull/2742
+  [2746]: https://github.com/sbt/sbt/pull/2746
+  [2754]: https://github.com/sbt/sbt/pull/2754
+  [2755]: https://github.com/sbt/sbt/pull/2755
+  [2763]: https://github.com/sbt/sbt/issues/2763
+  [2764]: https://github.com/sbt/sbt/pull/2764
+  [110]: https://github.com/sbt/sbt-launcher-package/pull/110
+  [111]: https://github.com/sbt/sbt-launcher-package/pull/111
+  [sbt-ivy-22]: https://github.com/sbt/ivy/pull/22
+
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dwijnand]: https://github.com/dwijnand
+  [@Duhemm]: https://github.com/Duhemm
+  [@xuwei-k]: https://github.com/xuwei-k
+  [@jtgrabowski]: https://github.com/jtgrabowski
+  [@fommil]: https://github.com/fommil
+  [@milessabin]: https://github.com/milessabin
+  [@pauldraper]: https://github.com/pauldraper
+  [@retronym]: https://github.com/retronym
diff --git a/notes/0.13.14.markdown b/notes/0.13.14.markdown
new file mode 100644
index 000000000..d0249d9a8
--- /dev/null
+++ b/notes/0.13.14.markdown
@@ -0,0 +1,100 @@
+### Fixes with compatibility implications
+
+- sbt 0.13.14 removes the Maven version range when possible. See below.
+
+### Improvements
+
+- Adds preliminary compatibility with JDK 9. Using this requires 0.13.14+ launcher. [#2951][2951]/[143][143] by [@retronym][@retronym]
+- Adds "local-preloaded" repository for offline installation. See below.
+- Notifies and enables users to stay in sbt's shell on the warm JVM by hitting `[ENTER]` while sbt is running. [#2987][2987]/[#2996][2996] by [@dwijnand][@dwijnand]
+- Adds an `Append` instance to support `sourceGenerators += Def.task { ... }`, instead of needing `.taskValue`. [#2943][2943] by [@eed3si9n][@eed3si9n]
+- Writes out the sbt.version in project/build.properties if it is missing. [#754][]/[#3025][] by [@dwijnand][]
+- XML generated by JUnitXmlTestsListener now correctly flags ignored, skipped and pending tests. [#2198][2198]/[#2854][2854] by [@ashleymercer][@ashleymercer]
+- When sbt detects that the project is compiled with dotty, it now automatically
+  sets `scalaCompilerBridgeSource` correctly, this reduces the boilerplate needed
+  to make a dotty project. Note that dotty support in sbt is still considered
+  experimental and not officially supported, see [dotty.epfl.ch][dotty] for
+  more information. [#2902][2902] by [@smarter][@smarter]
+- Updates sbt new's reference implementation to Giter8 0.7.2.
+
+### Bug fixes
+
+- Fixes .triggeredBy/.storeAs/etc not working when using `:=` and `.value` macros. [#1444][1444]/[#2908][2908] by [@dwijnand][@dwijnand]
+- Fixes Ctrl-C not working on Windows by bumping up JLine. [#1855][1855] by [@eed3si9n][@eed3si9n]
+- Fixes regressions in sbt 0.13.11 - 0.13.13 that processed build-level keys incorrectly. [#2851][2851]/[#2460][2460] by [@eed3si9n][@eed3si9n]
+- Fixes a regression in sbt 0.13.12 that was misfiring Scala version enforcement when configuration does not extend `Compile`. [#2827][2827]/[#2786][2786] by [@eed3si9n][@eed3si9n]
+- Fixes Scala binary version checking misfiring on configurations that do not extend `Compile`. [#2828][2828]/[#1466][1466] by [@eed3si9n][@eed3si9n]
+- Fixes script mode ignoring quotation. [#2551][2551] by [@ekrich][@ekrich]
+- Fixes IllegalStateException that Ivy gets into sometimes. [#2827][2827]/[#2015][2015] by [@eed3si9n][@eed3si9n]
+- Fixes null sourceFile causing NPE. [#2766][2766] by [@avdv][@avdv]
+- Fixes version parsing in validation. [#3011][3011] by [@eed3si9n][@eed3si9n]
+
+### Maven version range improvement
+
+Previously, when the dependency resolver (Ivy) encountered a Maven version range such as `[1.3.0,)`
+it would go out to the Internet to find the latest version.
+This would result to a surprising behavior where the eventual version keeps changing over time
+*even when there's a version of the library that satisfies the range condition*.
+
+Starting sbt 0.13.14, some Maven version ranges would be replaced with its lower bound
+so that when a satisfactory version is found in the dependency graph it will be used.
+You can disable this behavior using the JVM flag `-Dsbt.modversionrange=false`.
+
+[#2954][2954] by [@eed3si9n][@eed3si9n]
+
+### Offline installation
+
+sbt 0.13.14 adds two new repositories called "local-preloaded-ivy"
+and "local-preloaded" that point to `~/.sbt/preloaded/`.
+The purpose for the repositories is to preload them with
+sbt artifacts so the installation of sbt will not require access to the Internet.
+
+This also improves the startup time of sbt when you first run it
+since the resolution happens off of a local-preloaded repository.
+
+[#2993][2993]/[#145][145] by [@eed3si9n][@eed3si9n]
+
+### Notes
+
+No changes should be necessary to your project definition and all plugins published for sbt 0.13.{x|x<14} should still work.
+
+See [Migrating from sbt 0.12.x](https://www.scala-sbt.org/0.13/docs/Migrating-from-sbt-012x.html) for details on the old operator deprecation.
+
+Special thanks to the contributors for making this release a success. According to `git shortlog -sn --no-merges v0.13.13..0.13`, compared to 0.13.13, there were 42 (non-merge) commits, by ten contributors: Dale Wijnand, Eugene Yokota,  Guillaume Martres, Jason Zaugg, Petro Verkhogliad, Eric Richardson, Claudio Bley, Haochi Chen, Paul Draper, Ashley Mercer. Thank you!
+
+  [143]: https://github.com/sbt/sbt-launcher-package/pull/143
+  [145]: https://github.com/sbt/sbt-launcher-package/pull/145
+  [754]: https://github.com/sbt/sbt/issues/754
+  [2766]: https://github.com/sbt/sbt/issues/2766
+  [1855]: https://github.com/sbt/sbt/issues/1855
+  [1466]: https://github.com/sbt/sbt/issues/1466
+  [2786]: https://github.com/sbt/sbt/issues/2786
+  [2827]: https://github.com/sbt/sbt/pull/2827
+  [2828]: https://github.com/sbt/sbt/pull/2828
+  [2551]: https://github.com/sbt/sbt/issues/2551
+  [2987]: https://github.com/sbt/sbt/issues/2987
+  [2996]: https://github.com/sbt/sbt/pull/2996
+  [2851]: https://github.com/sbt/sbt/issues/2851
+  [2460]: https://github.com/sbt/sbt/issues/2460
+  [2951]: https://github.com/sbt/sbt/pull/2951
+  [2954]: https://github.com/sbt/sbt/issues/2954
+  [2015]: https://github.com/sbt/sbt/issues/2015
+  [2827]: https://github.com/sbt/sbt/pull/2827
+  [2198]: https://github.com/sbt/sbt/issues/2198
+  [2854]: https://github.com/sbt/sbt/pull/2854
+  [1444]: https://github.com/sbt/sbt/issues/1444
+  [2908]: https://github.com/sbt/sbt/pull/2908
+  [2902]: https://github.com/sbt/sbt/pull/2902
+  [2993]: https://github.com/sbt/sbt/pull/2993
+  [2943]: https://github.com/sbt/sbt/pull/2943
+  [3011]: https://github.com/sbt/sbt/issues/3011
+  [3025]: https://github.com/sbt/sbt/issues/3025
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dwijnand]: https://github.com/dwijnand
+  [@Duhemm]: https://github.com/Duhemm
+  [@avdv]: https://github.com/avdv
+  [@ekrich]: https://github.com/ekrich
+  [@retronym]: https://github.com/retronym
+  [@ashleymercer]: https://github.com/ashleymercer
+  [dotty]: http://dotty.epfl.ch/
+  [@smarter]: https://github.com/smarter
diff --git a/notes/0.13.14/junit_xml_imp.md b/notes/0.13.14/junit_xml_imp.md
deleted file mode 100644
index 06a0da2e7..000000000
--- a/notes/0.13.14/junit_xml_imp.md
+++ /dev/null
@@ -1,7 +0,0 @@
-### Improvements
-
-- XML generated by JUnitXmlTestsListener now correctly flags ignored, skipped and pending tests. [#2854][2854]/[#2198][2198] by [@ashleymercer][@ashleymercer]
-
-  [2854]: https://github.com/sbt/sbt/pull/2854
-  [2198]: https://github.com/sbt/sbt/issues/2198
-  [@ashleymercer]: https://github.com/ashleymercer
diff --git a/notes/0.13.16.markdown b/notes/0.13.16.markdown
new file mode 100644
index 000000000..f4308622d
--- /dev/null
+++ b/notes/0.13.16.markdown
@@ -0,0 +1,96 @@
+### Fixes with compatibility implications
+
+- Removes the "hit \[ENTER\] to switch to interactive mode" feature. See below.
+
+### Improvements
+
+- Improves the new startup messages. See below.
+- Ports sbt-cross-building's `^` and `^^` commands for plugin cross building. See below.
+
+### Bug fixes
+
+- Fixes the new startup messages. See below.
+- Fixes ScalaTest nested suite test names being reported as "(It is not a test)". [#3154][3154] by [@jameskoch][@jameskoch]
+
+### Improvements and bug fixes to the new startup messages
+
+The two new startup messages introduced in sbt 0.13.15 are:
+
+- when writing out `sbt.version`, for build reproducability, and
+- when informing the user about sbt's shell, for the performance improvement
+
+When writing out `sbt.version` the messaging now:
+
+- correctly uses a logger rather than println
+- honours the log level set, for instance by `--error`
+- never executes when sbt "new" is being run
+
+When informing the user about sbt's shell the messaging now:
+
+- is a 1 line message, rather than 3
+- is at info level, rather than warn level
+- can be suppressed with `suppressSbtShellNotification := true`
+- only triggers when `compile` is being run
+- never shows when sbt `new` is being run
+
+[#3091][3091]/[#3097][3097]/[#3147][3147] by [@dwijnand][@dwijnand]
+
+### Remove the "hit \[ENTER\] to switch to interactive mode" feature
+
+In sbt 0.13.15, in addition to notifying the user about the existence of sbt's shell, a feature was added to
+allow the user to switch to sbt's shell - a more pro-active approach to just displaying a message.
+
+Unfortunately sbt is often unintentionally invoked in shell scripts in "interactive mode" when no interaction is
+expected by, for example, invoking `sbt package` instead of `sbt package < /dev/null`. In that case hitting
+\[ENTER\] would silently trigger sbt to run its shell, easily wrecking the script. In addition to that I was
+unhappy with the implementation as it created a tight coupling between sbt's command processing abstraction to
+sbt's shell command.
+
+If you want to stay in sbt's shell after running a task like `package` then invoke sbt like so:
+
+    sbt package shell
+
+[#3091][3091]/[#3153][3153] by [@dwijnand][@dwijnand]
+
+### sbt-cross-building
+
+[@jrudolph][@jrudolph]'s sbt-cross-building is a plugin author's plugin.
+It adds cross command `^` and sbtVersion switch command `^^`, similar to `+` and `++`,
+but for switching between multiple sbt versions across major versions.
+sbt 0.13.16 merges these commands into sbt because the feature it provides is useful as we migrate plugins to sbt 1.0.
+
+To switch the `sbtVersion in pluginCrossBuild` from the shell use:
+
+```
+^^ 1.0.0-M5
+```
+
+Your plugin will now build with sbt 1.0.0-M5 (and its Scala version 2.12.2).
+
+If you need to make changes specific to a sbt version, you can now include them into `src/main/scala-sbt-0.13`,
+and `src/main/scala-sbt-1.0.0-M5`, where the binary sbt version number is used as postfix.
+
+To run a command across multiple sbt versions, set:
+
+```scala
+crossSbtVersions := Vector("0.13.15", "1.0.0-M5")
+```
+
+Then, run:
+
+```
+^ compile
+```
+
+[#3133][3133] by [@eed3si9n][@eed3si9n]
+
+  [3091]: https://github.com/sbt/sbt/issues/3091
+  [3097]: https://github.com/sbt/sbt/issues/3097
+  [3147]: https://github.com/sbt/sbt/pull/3147
+  [3133]: https://github.com/sbt/sbt/pull/3133
+  [3153]: https://github.com/sbt/sbt/pull/3153
+  [3154]: https://github.com/sbt/sbt/pull/3154
+  [@jrudolph]: https://github.com/jrudolph
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dwijnand]: https://github.com/dwijnand
+  [@jameskoch]: https://github.com/jameskoch
diff --git a/notes/0.13.7.markdown b/notes/0.13.7.markdown
index 7a1cdc0a3..2cddb7576 100644
--- a/notes/0.13.7.markdown
+++ b/notes/0.13.7.markdown
@@ -1,5 +1,5 @@
 
-  [Cached-Resolution]: http://www.scala-sbt.org/0.13/docs/Cached-Resolution.html
+  [Cached-Resolution]: https://www.scala-sbt.org/0.13/docs/Cached-Resolution.html
   [@cunei]: https://github.com/cunei
   [@eed3si9n]: https://github.com/eed3si9n
   [@gkossakowski]: https://github.com/gkossakowski
diff --git a/notes/0.13.8.markdown b/notes/0.13.8.markdown
index 4b31a0486..3f77b4f09 100644
--- a/notes/0.13.8.markdown
+++ b/notes/0.13.8.markdown
@@ -6,14 +6,14 @@
   [@aerskine]: https://github.com/aerskine
   [@ajozwik]: https://github.com/ajozwik
   [@dwickern]: https://github.com/dwickern
-  [@dwijnand]: http://github.com/dwijnand
+  [@dwijnand]: https://github.com/dwijnand
   [@Duhemm]: https://github.com/Duhemm
   [@kretes]: https://github.com/kretes
   [@indrajitr]: https://github.com/indrajitr
   [@j-keck]: https://github.com/j-keck
   [@xuwei-k]: https://github.com/xuwei-k
   [SI-9027]: https://issues.scala-lang.org/browse/SI-9027
-  [Custom-Settings0]: http://www.scala-sbt.org/0.13/tutorial/Custom-Settings.html
+  [Custom-Settings0]: https://www.scala-sbt.org/0.13/tutorial/Custom-Settings.html
   [321]: https://github.com/sbt/sbt/issues/321
   [647]: https://github.com/sbt/sbt/issues/647
   [679]: https://github.com/sbt/sbt/issues/679
@@ -68,7 +68,7 @@
 - Discovered main classes will be sorted. [#1180][1180] by [@kretes][@kretes]
 - Implemented a new mechanism of forking javac, whereby errors are captured.  Also more likely to run in-process. [#1702][1702] by [@jsuereth][@jsuereth]
 - `evicted` will display all evictions (including the ones not suspected of binary incompatibility). [#1615][1615] by [@eed3si9n][@eed3si9n]
-- Better abstration to track new kinds of dependencies for incremental compiler. [#1340][1340] by [@Duhemm][@Duhemm]
+- Better abstraction to track new kinds of dependencies for incremental compiler. [#1340][1340] by [@Duhemm][@Duhemm]
 - Source dependency uses `--depth 1` for git clone. [#1787][1787] by [@xuwei-k][@xuwei-k]
 - Facilitate nicer ways of declaring project settings. See below. [#1902][1902] by [@dwijnand][@dwijnand]
 
@@ -90,7 +90,7 @@
 - Fixes sporadic ConcurrentModificationException from JUnitXmlTestsListener. [#1881][1881] by [@aerskine][@aerskine]
 - Fixes handling of ANSI CSI codes. [#1885][1885] by [@jsuereth][@jsuereth]
 - Exempt org.scala-lang:scala-actors-migration and org.scala-lang:scala-pickling from scala binary version checks. [#1818][1818]/[#1899][1899] by [@dwijnand][@dwijnand]
-- Fixes cached resolution handling of internal depdendencies. [#1711][1711] by [@eed3si9n][@eed3si9n]
+- Fixes cached resolution handling of internal dependencies. [#1711][1711] by [@eed3si9n][@eed3si9n]
 - Fixes cached resolution being too verbose. [#1752][1752] by [@eed3si9n][@eed3si9n]
 - Fixes cached resolution not evicting modules transitively. [#1760][1760] by [@eed3si9n][@eed3si9n]
 
diff --git a/notes/0.13.9.markdown b/notes/0.13.9.markdown
index e82387097..dab2405fb 100644
--- a/notes/0.13.9.markdown
+++ b/notes/0.13.9.markdown
@@ -3,14 +3,14 @@
   [@eed3si9n]: https://github.com/eed3si9n
   [@gkossakowski]: https://github.com/gkossakowski
   [@jsuereth]: https://github.com/jsuereth
-  [@dwijnand]: http://github.com/dwijnand
+  [@dwijnand]: https://github.com/dwijnand
   [@ajsquared]: https://github.com/ajsquared
   [@jroper]: https://github.com/jroper
   [@kamilkloch]: https://github.com/kamilkloch
   [@DavidPerezIngeniero]: https://github.com/DavidPerezIngeniero
   [@PanAeon]: https://github.com/PanAeon
-  [@asflierl]: http://github.com/asflierl
-  [@matthewfarwell]: http://github.com/matthewfarwell
+  [@asflierl]: https://github.com/asflierl
+  [@matthewfarwell]: https://github.com/matthewfarwell
   [SI9027]: https://issues.scala-lang.org/browse/SI-9027
   [1950]: https://github.com/sbt/sbt/pull/1950
   [1987]: https://github.com/sbt/sbt/pull/1987
@@ -71,7 +71,7 @@
 - Adds help message for `inspect actual`. [#1651][1651]/[#1990][1990] by [@dwijnand][@dwijnand]
 - Supports excluding tests in `testOnly`/`testQuick` with `-`, for example `-MySpec`.
   [#1970][1970] by [@matthewfarwell][@matthewfarwell]
-- Adds more diagnostic info for underfined settings.
+- Adds more diagnostic info for undefined settings.
   [#2008][2008]/[#2009][2009] by [@DavidPerezIngeniero][@DavidPerezIngeniero]
 - Adds an `Extracted.runInputTask` helper to assist with imperatively executing input tasks. [#2006][2006] by [@jroper][@jroper]
 - Renames `distinct` method on `PathFinder` to `distinctName`. [#1973][1973] by [@eed3si9n][@eed3si9n]
@@ -130,7 +130,7 @@ and stale JSON files will be cleaned up after few days.
 
 sbt 0.13.9 also fixes a correctness issue that was found in the earlier releases.
 Under some circumstances, libraries that shouldn't have been evicted was being evicted.
-This occured when library `A1` depended on `B2`, but a newer `A2` dropped the dependency,
+This occurred when library `A1` depended on `B2`, but a newer `A2` dropped the dependency,
 and `A2` and `B1` are also is in the graph. This is fixed by sorting the graph prior to eviction.
 
 [#2030][2030]/[#1721][1721]/[#2014][2014]/[#2046][2046]/[#2097][2097]/[#2129][2129] by [@eed3si9n][@eed3si9n]
@@ -141,7 +141,7 @@ and `A2` and `B1` are also is in the graph. This is fixed by sorting the graph p
 when it creates classloaders to call Scala Compilers.
 sbt 0.13.9 will call GC on a set interval (default: 60s).
 It will also call GC right before cross building.
-This behavior can diabled using by setting false to `forcegc`
+This behavior can disabled using by setting false to `forcegc`
 setting or `sbt.task.forcegc` flag.
 
 [#1773][1773] by [@eed3si9n][@eed3si9n]
@@ -158,7 +158,7 @@ This problem surfaced as:
 - Version range not working for artifacts hosted on Bintray. [#2005][2005]
 - Potentially other `SNAPSHOT` related issues.
 
-sbt 0.13.9 fixes this by relaxing the Maven compatiblity check, so it will read `maven-metadata.xml`. [#2075][2075] by [@eed3si9n][@eed3si9n]
+sbt 0.13.9 fixes this by relaxing the Maven compatibility check, so it will read `maven-metadata.xml`. [#2075][2075] by [@eed3si9n][@eed3si9n]
 
 ### Contributors
 
diff --git a/notes/1.0.0-M4.markdown b/notes/1.0.0-M4.markdown
deleted file mode 100644
index 3d2e7c0c4..000000000
--- a/notes/1.0.0-M4.markdown
+++ /dev/null
@@ -1,51 +0,0 @@
-  [@eed3si9n]: https://github.com/eed3si9n
-  [@gkossakowski]: https://github.com/gkossakowski
-  [@dwijnand]: http://github.com/dwijnand
-  [@Duhemm]: https://github.com/Duhemm
-  [@jsuereth]: https://github.com/jsuereth
-  [86]: https://github.com/sbt/zinc/pull/86
-  [2577]: https://github.com/sbt/sbt/pull/2577
-  [2575]: https://github.com/sbt/sbt/pull/2575
-  [2543]: https://github.com/sbt/sbt/pull/2543
-  [2524]: https://github.com/sbt/sbt/pull/2524
-
-This is the first milestone (beta) release of sbt 1.0.
-There's no binary compatibility with sbt 0.13 or other future versions.
-
-The biggest change in sbt 1.0 from 0.13 is internal code reorganization to modules
-(io, util, librarymanagement, zinc, and sbt), but hopefully this shouldn't affect you much.
-In addition, classes and objects related to internal implementations are moved to `sbt.internal`.
-This package indicates that we won't keep binary compatibility for them.
-
-Here are some more relevant changes:
-
-- Build definition is based on Scala 2.11.8 [#2577][2577]
-- Build.scala style builds are gone. Use multi-project `build.sbt`. [#2524][2524]
-- `Project(...)` constructor is restricted down to two parameters. Use `project` instead. [#2543][2543]
-- `sbt.Plugin` is also gone. Use auto plugins. [#2575][2575]
-- The incremental compiler, called Zinc, uses class-based name hashing. [zinc#86][86] by [@gkossakowski][@gkossakowski]
-- Zinc drops support for Scala 2.8.x and 2.9.x.
-
-### Additional import required
-
-Implicit conversions are moved to `sbt.syntax`. Add the following imports to auto plugins
-or `project/*.scala`.
-
-    import sbt._, syntax._, Keys._
-
-### Travis CI instruction
-
-Travis CI uses unofficial sbt-extra launcher, so you might need to do the following to use 1.0.0-M4:
-
-    language: scala
-
-    scala:
-       - 2.11.8
-
-    before_install:
-      - mkdir launcher
-      - curl https://repo1.maven.org/maven2/org/scala-sbt/launcher/1.0.0/launcher-1.0.0.jar > launcher/sbt-launch.jar
-      - curl https://raw.githubusercontent.com/sbt/sbt/v1.0.0-M4/src/main/conscript/xsbt/launchconfig > launcher/launchconfig
-
-    script:
-       - java -Xms2048M -Xmx2048M -Xss6M -XX:MaxPermSize=512M -jar launcher/sbt-launch.jar @launcher/launchconfig ++$TRAVIS_SCALA_VERSION test
diff --git a/notes/1.0.0.markdown b/notes/1.0.0.markdown
new file mode 100644
index 000000000..6c0c648a9
--- /dev/null
+++ b/notes/1.0.0.markdown
@@ -0,0 +1,323 @@
+### Features, fixes, changes with compatibility implications
+
+See [Migrating from sbt 0.13.x][Migrating-from-sbt-013x] also.
+
+- sbt 1.0 uses **Scala 2.12** for build definitions and plugins. This also requires JDK 8.
+- Many of the case classes are replaced with pseudo case classes generated using Contraband. Migrate `.copy(foo = xxx)` to `withFoo(xxx)`.
+  For example, `UpdateConfiguration`, `RetrieveConfiguration`, `PublishConfiguration` are refactored to use builder pattern.
+- Zinc 1 drops support for Scala 2.9 and earlier. Scala 2.10 must use 2.10.2 and above. Scala 2.11 must use 2.11.2 and above. (latest patch releases are recommended)
+- `config("xyz")` must be directly assigned to a *capitalized* `val`, like `val Xyz = config("xyz")`. This captures the lhs identifier into the configuration so we can use it from the shell later.
+- Changes `publishTo` and `otherResolvers` from SettingKeys to TaskKeys. [#2059][2059]/[#2662][2662] by [@dwijnand][@dwijnand]
+- `Path.relativizeFile(baseFile, file)` is renamed to `IO.relativizeFile(baseFile, file)`.
+- `PathFinder`'s `.***` method is renamed to `.allPaths` method.
+- `PathFinder.x_!(mapper)` is moved to `def pair` on `PathFinder`.
+- A number of the methods on `sbt.Path` (such as `relativeTo` and `rebase` and `flat`) are now no longer in the
+    default namespace by virtue of being mixed into the sbt package object. Use `sbt.io.Path` to access them
+    again.
+- sbt 1.0 renames `Global` as scope component to `Zero` to disambiguate from `GlobalScope`. [@eed3si9n][@eed3si9n]
+- sbt 1.0 uses `ConfigRef` in places where `String` was used to reference configuration, such as `update.value.configuration(...)`. Pass in `Configuration`, which implicitly converts to `ConfigRef`.
+- Changes `sourceArtifactTypes` and `docArtifactTypes` from `Set[String]` to `Seq[String]` settings.
+- Renames early command feature from `--<command>` to `early(<command>)`.
+- Drops sbt 0.12 style hyphen-separated key names (use `publishLocal` instead of `publish-local`).
+- Log options `-error`, `-warn`, `-info`, `-debug` are added as shorthand for `"early(error)"` etc.
+- `sbt.Process` and `sbt.ProcessExtra` are dropped. Use `scala.sys.process` instead.
+- `incOptions.value.withNameHashing(...)` option is removed because name hashing is always on.
+- `TestResult.Value` is now called `TestResult`.
+- The scripted plugin is cross-versioned now, so you must use `%%` when depending on it.
+
+**Dropped deprecations**:
+
+- sbt 0.12 style `Build` trait that was deprecated in sbt 0.13.12, is removed. Please [migrate to build.sbt](Migrating-from-sbt-013x.html#Migrating+from+the+Build+trait). Auto plugins and `Build` trait do not work well together, and its feature is now largely subsumed by multi-project build.sbt.
+- sbt 0.12 style `Project(...)` constructor is restricted down to two parameters. This is because `settings` parameter does not work well with Auto Plugins. Use `project` instead.
+- sbt 0.12 style key dependency operators `<<=`, `<+=`, `<++=` are removed. Please [migrate to :=, +=, and ++=](Migrating-from-sbt-013x.html#Migrating+simple+expressions). These operators have been sources of confusion for many users, and have long been removed from 0.13 docs, and have been formally deprecated since sbt 0.13.13.
+- Non-auto `sbt.Plugin` trait is dropped. Please migrate to AutoPlugin. Auto plugins are easier to configure, and work better with each other.
+- Removes the `settingsSets` method from `Project` (along with `add/setSbtFiles`).
+- Drops deprecated `InputTask` `apply` method and `inputTask` DSL method. Use `Def.inputTask` and `Def.spaceDelimited().parsed`.
+- Drops deprecated `ProjectReference` implicit lifts. Use `RootProject(<uri>)`, `RootProject(<file>)` or `LocalProject(<string>)`.
+- Drops deprecated `seq(..)` DSL method. Use `Seq` or pass in the settings without wrapping.
+- Drops deprecated `File`/`Seq[File]` setting enrichments. Use `.value` and `Def.setting`.
+- Drops deprecated `SubProcess` `apply` overload. Use `SubProcess(ForkOptions(runJVMOptions = ..))`.
+- Drops `toError(opt: Option[String]): Unit` (equivalent to `opt foreach sys.error`); if used to wrap
+    `ScalaRun#run` then the replacement is `scalaRun.run(...).failed foreach (sys error _.getMessage)`
+
+### Features
+
+- New incremental compiler called Zinc 1. Details below.
+- The interactive shell adds network API. Details below.
+- Library management API and parallel artifact download. See below.
+- sbt 1.0's logging supports event logging. See below.
+- Scala Center contributed static validation of `build.sbt`. See below
+- Ports sbt-cross-building's `^` and `^^` commands for plugin cross building. See below.
+
+### Fixes
+
+- Fixes test content log not showing up. [#3198][3198]/[util#80][util80] by [@eed3si9n][@eed3si9n]
+- Fixes confusing log about "Unable to parse". [lm#98][lm98] by [@jvican][@jvican]
+- Fixes `console` task. [zinc#295][zinc295] by [@dwijnand][@dwijnand]
+- Fixes spurious recompilations when unrelated constructor changes. [zinc#288][zinc288] by [@smarter][@smarter]
+- Fixes restligeist macro for old operators. [#3218][3218] by [@eed3si9n][@eed3si9n]
+- Fixes task caching of `update` task. [#3233][3233] by [@eed3si9n][@eed3si9n]
+- Fixes ncurses-JLine issue by updating to JLine 2.14.4. [util#81][util81] by [@Rogach][@Rogach]
+
+### Improvements
+
+- Scala Center contributed a Java-friendly Zinc API. This was a overhaul of the Zinc internal API for a good Scala integration with other build tools. [zinc#304][zinc304] by [@jvican][@jvican]
+- Scala Center contributed a binary format for Zinc's internal storage. See below
+- The startup log level is dropped to `-error` in script mode using `scalas`. [#840][840] by [@eed3si9n][@eed3si9n]
+- Replace cross building support with sbt-doge. This allows builds with projects that have multiple different combinations of cross scala versions to be cross built correctly.  The behaviour of ++ is changed so that it only updates the Scala version of projects that support that Scala version, but the Scala version can be post fixed with ! to force it to change for all projects. A -v argument has been added that prints verbose information about which projects are having their settings changed along with their cross scala versions. [#2613][2613] by [@jroper][@jroper]
+- `ivyLoggingLevel` is dropped to `UpdateLogging.Quiet` when CI environment is detected. [@eed3si9n][@eed3si9n]
+- Add logging of the name of the different `build.sbt` (matching `*.sbt`) files used. [#1911][1911] by [@valydia][@valydia]
+- Add the ability to call `aggregate` for the current project inside a build sbt file. By [@xuwei-k][@xuwei-k]
+- Add new global setting `asciiGraphWidth` that controls the maximum width of the ASCII graphs printed by commands like `inspect tree`. Default value corresponds to the previously hardcoded value of 40 characters. By [@RomanIakovlev][@RomanIakovlev].
+- Revamped documentation for [Scopes](www.scala-sbt.org/0.13/docs/Scopes.html), and added [Scope Delegation](www.scala-sbt.org/0.13/docs/Scope-Delegation.html). [@eed3si9n][@eed3si9n]
+- Adds support for cross-versioned exclusions. [#1518][1518]/[lm#88][lm88] by [@jvican][@jvican]
+- Adds new offline mode to the Ivy-based library management. [lm#92][lm92] by [@jvican][@jvican]
+- A number of features related to dependency locking. See below.
+- Improved eviction warning presentation. See below.
+- A better main class detection. [zinc#287][zinc287] by [@smarter][@smarter]
+- For faster startup, sbt will use Java refection to discover `autoImport` . [#3115][3115] by [@jvican][@jvican]
+- For faster startup, reuse the same global instance for parsing. [#3115][3115] by [@jvican][@jvican]
+- Adds `InteractionService` from sbt-core-next to keep compatibility with sbt 0.13. [#3182][3182] by [@eed3si9n][@eed3si9n]
+- Adds new `WatchService` that abstracts `PollingWatchService` and Java NIO. [io#47][io47] by [@Duhemm][@Duhemm] on behalf of The Scala Center.
+- Adds variants of `IO.copyFile` and `IO.copyDirectory` that accept `sbt.io.CopyOptions()`. See below for details.
+- `Path.directory` and `Path.contentOf` are donated from sbt-native-packager [io#38][io38] by [@muuki88][@muuki88]
+- ApiDiff feature used to debug Zinc uses Scala implementation borrowed from Dotty. [zinc#346][zinc346] by [@Krever][@Krever]
+- In Zinc internal, make ExtractAPI use perRunCaches. [zinc#347][zinc347] by [@gheine][@gheine]
+
+#### Internals
+
+- Adopted Scalafmt for formatting the source code using neo-scalafmt.
+- Scala Center contributed a redesign of the scripted test framework that has batch mode execution. Scripted now reuses the same sbt instance to run sbt tests, which reduces the CI build times by 50% [#3151][3151] by [@jvican][@jvican]
+- sbt 1.0.0-M6 is built using sbt 1.0.0-M5. [#3184][3184] by [@dwijnand][@dwijnand]
+
+### Details of major changes
+
+### Zinc 1: Class-based name hashing
+
+A major improvement brought into Zinc 1.0 by Grzegorz Kossakowski (commissioned by Lightbend) is class-based name hashing, which will speed up the incremental compilation of Scala in large projects.
+
+Zinc 1.0's name hashing tracks your code dependendencies at the class level, instead of at the source file level. The GitHub issue [sbt/sbt#1104](https://github.com/sbt/sbt/issues/1104) lists some comparisons of adding a method to an existing class in some projects:
+
+```
+ScalaTest   AndHaveWord class:          Before 49s, After 4s (12x)
+Specs2      OptionResultMatcher class:  Before 48s, After 1s (48x)
+scala/scala Platform class:             Before 59s, After 15s (3.9x)
+scala/scala MatchCodeGen class:         Before 48s, After 17s (2.8x)
+```
+
+This depends on some factors such as how your classes are organized, but you can see 3x ~ 40x improvements. The reason for the speedup is because it compiles fewer source files than before by untangling the classes from source files. In the example adding a method to scala/scala's Platform class, sbt 0.13's name hashing used to compile 72 sources, but the new Zinc compiles 6 sources.
+
+#### Zinc API changes
+
+- Java classes under the `xsbti.compile` package such as `IncOptions` hides the constructor. Use the factory method `xsbti.compile.Foo.of(...)`.
+- Renames `ivyScala: IvyScala` key to `scalaModuleInfo: ScalaModuleInfo`.
+- `xsbti.Reporter#log(...)` takes `xsbti.Problem` as the parameter. Call `log(problem.position, problem.message, problem.severity)` to delegate to the older `log(...)`.
+- `xsbi.Maybe`, `xsbti.F0`, and `sxbti.F1` are changed to corresponding Java 8 classes `java.util.Optional`, `java.util.Supplier` and `java.util.Function`.
+- Removes unused "resident" option. [zinc#345][zinc345] by [@lukeindykiewicz][@lukeindykiewicz]
+
+#### sbt server: JSON API for tooling integration
+
+sbt 1.0 includes server feature, which allows IDEs and other tools to query the build for settings, and invoke commands via a JSON API. Similar to the way that the interactive shell in sbt 0.13 is implemented with `shell` command, "server" is also just `shell` command that listens to both human input and network input. As a user, there should be minimal impact because of the server.
+
+In March 2016, we [rebooted](http://eed3si9n.com/sbt-server-reboot) the "server" feature to make it as small as possible. We worked in collaboration with JetBrains' @jastice who works on IntelliJ's sbt interface to narrow down the feature list. sbt 1.0 will not have all the things we originally wanted, but in the long term, we hope to see better integration between IDE and sbt ecosystem using this system. For example, IDEs will be able to issue the compile task and retrieve compiler warning as JSON events:
+
+```
+{"type":"xsbti.Problem","message":{"category":"","severity":"Warn","message":"a pure expression does nothing in statement position; you may be omitting necessary parentheses","position":{"line":2,"lineContent":"  1","offset":29,"pointer":2,"pointerSpace":"  ","sourcePath":"/tmp/hello/Hello.scala","sourceFile":"file:/tmp/hello/Hello.scala"}},"level":"warn"}
+```
+
+Another related feature that was added is the `bgRun` task which, for example, enables a server process to be run in the background while you run tests against it.
+
+#### Event logging
+
+sbt 1.0 introduces event logging implemented using Log4J 2 and sjson-new.
+In addition to the regular String-based logging, you can now send case classes and Contraband-generated pseudo case classes to the logger:
+
+    def registerStringCodec[A: ShowLines: TypeTag]: Unit = ...
+    final def debugEvent[A: JsonFormat: TypeTag](event: => A): Unit = logEvent(Level.Debug, event)
+    final def infoEvent[A: JsonFormat: TypeTag](event: => A): Unit = logEvent(Level.Info, event)
+    final def warnEvent[A: JsonFormat: TypeTag](event: => A): Unit = logEvent(Level.Warn, event)
+    final def errorEvent[A: JsonFormat: TypeTag](event: => A): Unit = logEvent(Level.Error, event)
+
+Various events such as `[success]` message are sent internally via event logging.
+We are hoping that this mechanism can be used in conjunction with server so plugins and compilers can publish JSON events.
+
+Since the logger uses Log4J 2 internally, we now provide SLF4J binding.
+
+#### Static validation of build.sbt
+
+sbt 1.0 prohibits `.value` calls inside the bodies of if expressions and anonymous functions in a task, `@sbtUnchecked` annotation can be used to override the check.
+
+The static validation also catches if you forget to call `.value` in a body of a task.
+
+[#3216][3216] and [#3225][3225] by [@jvican][@jvican]
+
+#### Eviction warning presentation
+
+sbt 1.0 improves the eviction warning presetation.
+
+Before:
+
+    [warn] There may be incompatibilities among your library dependencies.
+    [warn] Here are some of the libraries that were evicted:
+    [warn]  * com.google.code.findbugs:jsr305:2.0.1 -> 3.0.0
+    [warn] Run 'evicted' to see detailed eviction warnings
+
+After:
+
+    [warn] Found version conflict(s) in library dependencies; some are suspected to be binary incompatible:
+    [warn]
+    [warn]      * com.typesafe.akka:akka-actor_2.12:2.5.0 is selected over 2.4.17
+    [warn]          +- de.heikoseeberger:akka-log4j_2.12:1.4.0            (depends on 2.5.0)
+    [warn]          +- com.typesafe.akka:akka-parsing_2.12:10.0.6         (depends on 2.4.17)
+    [warn]          +- com.typesafe.akka:akka-stream_2.12:2.4.17 ()       (depends on 2.4.17)
+    [warn]
+    [warn] Run 'evicted' to see detailed eviction warnings
+
+[#3202][3202] by [@eed3si9n][@eed3si9n]
+
+#### sbt-cross-building
+
+[@jrudolph][@jrudolph]'s sbt-cross-building is a plugin author's plugin.
+It adds cross command `^` and sbtVersion switch command `^^`, similar to `+` and `++`,
+but for switching between multiple sbt versions across major versions.
+sbt 0.13.16 merges these commands into sbt because the feature it provides is useful as we migrate plugins to sbt 1.0.
+
+To switch the `sbtVersion in pluginCrossBuild` from the shell use:
+
+```
+^^ 1.0.0-M5
+```
+
+Your plugin will now build with sbt 1.0.0-M5 (and its Scala version 2.12.2).
+
+If you need to make changes specific to a sbt version, you can now include them into `src/main/scala-sbt-0.13`,
+and `src/main/scala-sbt-1.0.0-M5`, where the binary sbt version number is used as postfix.
+
+To run a command across multiple sbt versions, set:
+
+```scala
+crossSbtVersions := Vector("0.13.15", "1.0.0-M5")
+```
+
+Then, run:
+
+```
+^ compile
+```
+
+[#3133][3133] by [@eed3si9n][@eed3si9n] (forward ported from 0.13.16-M1)
+
+#### CopyOptions
+
+sbt IO 1.0 add variant of `IO.copyFile` and `IO.copyDirectory` that accept `sbt.io.CopyOptions()`.
+`CopyOptions()` is an example of pseudo case class similar to the builder pattern.
+
+```scala
+import sbt.io.{ IO, CopyOptions }
+
+IO.copyDirectory(source, target)
+
+// The above is same as the following
+IO.copyDirectory(source, target, CopyOptions()
+  .withOverwrite(false)
+  .withPreserveLastModified(true)
+  .withPreserveExecutable(true))
+```
+
+[io#53][io53] by [@dwijnand][@dwijnand]
+
+#### Library management API and parallel artifact download
+
+sbt 1.0 adds Library management API co-authored by Eugene Yokota ([@eed3si9n][@eed3si9n]) from Lightbend and Martin Duhem ([@Duhemm][@Duhemm]) from Scala Center.
+This API aims to abstract Apache Ivy as well as alternative dependency resolution engines Ivy, cached resolution, and Coursier.
+
+Parallel artifact download for Ivy engine was contributed by Jorge ([@jvican][@jvican]) from Scala Center.
+It also introduces Gigahorse OkHttp as the Network API, and it uses Square OkHttp for artifact download as well.
+
+[lm#124][lm124] by [@eed3si9n][@eed3si9n]/[@Duhemm][@Duhemm],
+[lm#90][lm90] by [@jvican][@jvican]/[@jsuereth][@jsuereth]
+and [lm#104][lm104] by [@eed3si9n][@eed3si9n].
+
+#### Binary format for Zinc's internal storage
+
+Jorge ([@jvican][@jvican]) from Scala Center contributed a binary format for Zinc's internal storage using Google Procol Buffer.
+The new format provides us with three main advantages:
+
+1. Backwards and forwards binary compatibility at the analysis format level.
+2. Faster (1.5 ~ 2x) serialization/deserialization of the analysis file.
+3. Provides a better way to make the analysis file machine-independent.
+
+[zinc#351][zinc351] by [@jvican][@jvican]
+
+#### Dependency locking
+
+Dependency locking feature is still in progress, but Jorge ([@jvican][@jvican]) from Scala Center has added a number of related features
+that would should work together to allow dependency locking.
+
+- Frozen mode to the Ivy-based library management, which makes sure that the resolution is always intransitive. [lm#100][lm100]
+- Adds support to specify a resolver for dependencies. [lm#97][lm97]
+- Adds "managed checksums", which tells Ivy to skip the checksum process. [lm#111][lm111]
+
+#### Contributors
+
+Too many people to thank here. See [Credits][Credits]
+
+  [Credits]: https://www.scala-sbt.org/1.x/docs/Credits.html
+  [Migrating-from-sbt-013x]: https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dwijnand]: https://github.com/dwijnand
+  [@jvican]: https://github.com/jvican
+  [@Duhemm]: https://github.com/Duhemm
+  [@jsuereth]: https://github.com/jsuereth
+  [@gkossakowski]: https://github.com/gkossakowski
+  [sbt-1-0-roadmap]: https://developer.lightbend.com/blog/2017-04-18-sbt-1-0-roadmap-and-beta1/
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@jroper]: https://github.com/jroper
+  [@valydia]: https://github.com/valydia
+  [@RomanIakovlev]: https://github.com/RomanIakovlev
+  [@smarter]: https://github.com/smarter
+  [@jrudolph]: https://github.com/jrudolph
+  [@muuki88]: https://github.com/muuki88
+  [@Rogach]: https://github.com/Rogach
+  [@Krever]: https://github.com/Krever
+  [@lukeindykiewicz]: https://github.com/lukeindykiewicz
+  [@gheine]: https://github.com/gheine
+  [840]: https://github.com/sbt/sbt/issues/840
+  [2613]: https://github.com/sbt/sbt/pull/2613
+  [1911]: https://github.com/sbt/sbt/issues/1911
+  [2059]: https://github.com/sbt/sbt/issues/2059
+  [2662]: https://github.com/sbt/sbt/pull/2662
+  [3133]: https://github.com/sbt/sbt/pull/3133
+  [util80]: https://github.com/sbt/util/pull/80
+  [3198]: https://github.com/sbt/sbt/issues/3198
+  [lm88]: https://github.com/sbt/librarymanagement/pull/88
+  [1518]: https://github.com/sbt/sbt/issues/1518
+  [lm90]: https://github.com/sbt/librarymanagement/pull/90
+  [lm92]: https://github.com/sbt/librarymanagement/pull/92
+  [lm98]: https://github.com/sbt/librarymanagement/pull/98
+  [lm100]: https://github.com/sbt/librarymanagement/pull/100
+  [lm111]: https://github.com/sbt/librarymanagement/pull/111
+  [lm104]: https://github.com/sbt/librarymanagement/pull/104
+  [lm97]: https://github.com/sbt/librarymanagement/pull/97
+  [lm124]: https://github.com/sbt/librarymanagement/pull/124
+  [3202]: https://github.com/sbt/sbt/pull/3202
+  [zinc295]: https://github.com/sbt/zinc/pull/295
+  [zinc287]: https://github.com/sbt/zinc/pull/287
+  [zinc288]: https://github.com/sbt/zinc/pull/288
+  [zinc304]: https://github.com/sbt/zinc/pull/304
+  [zinc346]: https://github.com/sbt/zinc/pull/346
+  [zinc345]: https://github.com/sbt/zinc/pull/345
+  [zinc347]: https://github.com/sbt/zinc/pull/347
+  [zinc351]: https://github.com/sbt/zinc/pull/351
+  [3115]: https://github.com/sbt/sbt/pull/3115
+  [3182]: https://github.com/sbt/sbt/pull/3182
+  [3151]: https://github.com/sbt/sbt/pull/3151
+  [3184]: https://github.com/sbt/sbt/pull/3184
+  [3216]: https://github.com/sbt/sbt/pull/3216
+  [3218]: https://github.com/sbt/sbt/pull/3218
+  [3225]: https://github.com/sbt/sbt/pull/3225
+  [3233]: https://github.com/sbt/sbt/pull/3233
+  [io47]: https://github.com/sbt/io/pull/47
+  [io53]: https://github.com/sbt/io/pull/53
+  [io38]: https://github.com/sbt/io/pull/38
+  [util81]: https://github.com/sbt/util/pull/81
diff --git a/notes/1.0.0/aggregate-build-sbt.md b/notes/1.0.0/aggregate-build-sbt.md
deleted file mode 100644
index ef459e2e9..000000000
--- a/notes/1.0.0/aggregate-build-sbt.md
+++ /dev/null
@@ -1,5 +0,0 @@
-  [@xuwei-k]: https://github.com/xuwei-k
-
-### Improvements
-
-- Add the ability to call aggregate for the current project inside a build sbt file. By [@xuwei-k][@xuwei-k]
diff --git a/notes/1.0.0/fix-task-sequential.markdown b/notes/1.0.0/fix-task-sequential.markdown
new file mode 100644
index 000000000..314bd4077
--- /dev/null
+++ b/notes/1.0.0/fix-task-sequential.markdown
@@ -0,0 +1,5 @@
+### Improvements
+
+- Implement `sequential[B](tasks: Seq[Initialize[Task[B]]])` method. by [@3tty0n][@3tty0n]
+
+    [@3tty0n]: https://github.com/3tty0n
diff --git a/notes/1.0.0/quieter-log.md b/notes/1.0.0/quieter-log.md
deleted file mode 100644
index b6bb7855f..000000000
--- a/notes/1.0.0/quieter-log.md
+++ /dev/null
@@ -1,5 +0,0 @@
-### Improvements
-
-- `ivyLoggingLevel` is dropped to `UpdateLogging.Quiet` when CI environment is detected. [@eed3si9n][@eed3si9n]
-
-  [@eed3si9n]: https://github.com/eed3si9n
diff --git a/notes/1.0.0/sbt-doge.markdown b/notes/1.0.0/sbt-doge.markdown
deleted file mode 100644
index 060f72699..000000000
--- a/notes/1.0.0/sbt-doge.markdown
+++ /dev/null
@@ -1,10 +0,0 @@
-[@jroper]: https://github.com/jroper
-[2613]: https://github.com/sbt/sbt/pull/2613
-
-### Fixes with compatibility implications
-
-### Improvements
-
-- Replace cross building support with sbt-doge. This allows builds with projects that have multiple different combinations of cross scala versions to be cross built correctly.  The behaviour of ++ is changed so that it only updates the Scala version of projects that support that Scala version, but the Scala version can be post fixed with ! to force it to change for all projects. A -v argument has been added that prints verbose information about which projects are having their settings changed along with their cross scala versions. [#2613][2613] by [@jroper][@jroper].
-
-### Bug fixes
diff --git a/notes/1.0.0/silent-scalas.md b/notes/1.0.0/silent-scalas.md
deleted file mode 100644
index 52a9a8137..000000000
--- a/notes/1.0.0/silent-scalas.md
+++ /dev/null
@@ -1,6 +0,0 @@
-### Improvements
-
-- The startup log level is dropped to `-error` in script mode using `scalas`. [#840][840] by [@eed3si9n][@eed3si9n]
-
-  [@eed3si9n]: https://github.com/eed3si9n
-  [840]: https://github.com/sbt/sbt/issues/840
diff --git a/notes/1.0.1.markdown b/notes/1.0.1.markdown
new file mode 100644
index 000000000..2a3ed2207
--- /dev/null
+++ b/notes/1.0.1.markdown
@@ -0,0 +1,49 @@
+This is a hotfix release for sbt 1.0.x series.
+
+### Improvements
+
+- Various improves around watch source feature. See below.
+
+### Bug fixes
+
+- Fixes command support for cross building `+` command. The `+` added to sbt 1.0 traverses over the subprojects, respecting `crossScalaVersions`; however, it no longer accepted commands as arguments. This brings back the support for it. [#3446][3446] by [@jroper][@jroper]
+- Fixes `addSbtPlugin` to use the correct version of sbt during cross building. [#3442][3442] by [@dwijnand][@dwijnand]
+- Fixes `run in Compile` task not including `Runtime` configuration, by reimplementing `run` in terms of `bgRun`. [#3477][3477] by [@eed3si9n][@eed3si9n]
+- Shows `actual` as a potential option of `inspect` [#3335][3335] by [@Duhemm][@Duhemm]
+- Includes base directory to watched sources. [#3439][3439] by [@Duhemm][@Duhemm]
+- Adds an attempt to workaround intermittent `NullPointerException` around logging. [util#121][util121] by [@eed3si9n][@eed3si9n]
+- Reverts a bad forward porting. [#3481][3481] by [@eed3si9n][@eed3si9n]
+
+### WatchSource
+
+The watch source feature went through a major change from sbt 0.13 to sbt 1.0 using NIO; however, it did not have clear migration path, so we are rectifying that in sbt 1.0.1.
+
+First, `sbt.WatchSource` is a new alias for `sbt.internal.io.Source`. Hopefully this is easy enough to remember because the key is named `watchSources`. Next, `def apply(base: File)` and `def apply(base: File, includeFilter: FileFilter, excludeFilter: FileFilter)` constructors were added to the companion object of `sbt.WatchSource`.
+
+For backward compatibility, sbt 1.0.1 adds `+=` support (`Append` instance) from `File` to `Seq[WatchSource]`.
+
+So, if you have a directory you want to watch:
+
+    watchSources += WatchSource(sourceDirectory.value)
+
+If you have a list of files:
+
+    watchSources ++= (sourceDirectory.value ** "*.scala").get
+
+[#3438][3438] by [@Duhemm][@Duhemm]; [#3478][3478] and [io#74][io74] by [@eed3si9n][@eed3si9n]
+
+  [3335]: https://github.com/sbt/sbt/pull/3335
+  [3438]: https://github.com/sbt/sbt/pull/3438
+  [3478]: https://github.com/sbt/sbt/pull/3478
+  [3439]: https://github.com/sbt/sbt/pull/3439
+  [io74]: https://github.com/sbt/io/pull/74
+  [3442]: https://github.com/sbt/sbt/pull/3442
+  [3446]: https://github.com/sbt/sbt/pull/3446
+  [3477]: https://github.com/sbt/sbt/pull/3477
+  [3481]: https://github.com/sbt/sbt/pull/3481
+  [util121]: https://github.com/sbt/util/pull/121
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dwijnand]: https://github.com/dwijnand
+  [@jvican]: https://github.com/jvican
+  [@Duhemm]: https://github.com/Duhemm
+  [@jroper]: https://github.com/jroper
diff --git a/notes/1.0.2.markdown b/notes/1.0.2.markdown
new file mode 100644
index 000000000..95b8de1f5
--- /dev/null
+++ b/notes/1.0.2.markdown
@@ -0,0 +1,43 @@
+This is a hotfix release for sbt 1.0.x series.
+
+### Bug fixes
+
+- Fixes terminal echo issue. [#3507][3507] by [@kczulko][@kczulko]
+- Fixes `deliver` task, and adds `makeIvyXml` as a more sensibly named task. [#3487][3487] by [@cunei][@cunei]
+- Replaces the deprecated use of `OkUrlFactory`, and fixes connection leaks. [lm#164][lm164] by [@dpratt][@dpratt]
+- Refixes false positive in DSL checker for setting keys. [#3513][3513] by [@dwijnand][@dwijnand]
+- Fixes `run` and `bgRun` not picking up changes to directories in the classpath. [#3517][3517] by [@dwijnand][@dwijnand]
+- Fixes `++` so it won't change the value of `crossScalaVersion`. [#3495][3495]/[#3526][3526] by [@dwijnand][@dwijnand]
+- Fixes sbt server missing some messages. [#3523][3523] by [@guillaumebort][@guillaumebort]
+- Refixes `consoleProject`. [zinc#386][zinc386] by [@dwijnand][@dwijnand]
+- Adds JVM flag `sbt.gigahorse` to enable/disable the internal use of Gigahorse to workaround NPE in `JavaNetAuthenticator` when used in conjunction with `repositories` override. [lm#167][lm167] by [@cunei][@cunei]
+- Adds JVM flag `sbt.server.autostart` to enable/disable the automatic starting of sbt server with the sbt shell. This also adds new `startServer` command to manually start the server. by [@eed3si9n][@eed3si9n]
+
+### Internal
+
+- Fixes unused import warnings. [#3533][3533] by [@razvan-panda][@razvan-panda]
+
+### Contributors
+
+A huge thank you to everyone who's helped improve sbt and Zinc 1 by using them, reporting bugs, improving our documentation, porting plugins, and submitting and reviewing pull requests.
+
+This release was brought to you by 19 contributors, according to `git shortlog -sn --no-merges v1.0.1..v1.0.2` on sbt, zinc, librarymanagement, and website: Dale Wijnand, Eugene Yokota, Kenji Yoshida (xuwei-k), Antonio Cunei, David Pratt, Karol Cz (kczulko), Amanj Sherwany, Emanuele Blanco, Eric Peters, Guillaume Bort, James Roper, Joost de Vries, Marko Elezovic, Martynas Mickevičius, Michael Stringer, Răzvan Flavius Panda, Peter Vlugter, Philippus Baalman, and Wiesław Popielarski. Thank you!
+
+  [@dwijnand]: https://github.com/dwijnand
+  [@cunei]: https://github.com/cunei
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dpratt]: https://github.com/dpratt
+  [@kczulko]: https://github.com/kczulko
+  [@razvan-panda]: https://github.com/razvan-panda
+  [@guillaumebort]: https://github.com/guillaumebort
+  [3487]: https://github.com/sbt/sbt/pull/3487
+  [lm164]: https://github.com/sbt/librarymanagement/pull/164
+  [3495]: https://github.com/sbt/sbt/issues/3495
+  [3526]: https://github.com/sbt/sbt/pull/3526
+  [3513]: https://github.com/sbt/sbt/pull/3513
+  [3517]: https://github.com/sbt/sbt/pull/3517
+  [3507]: https://github.com/sbt/sbt/pull/3507
+  [3533]: https://github.com/sbt/sbt/pull/3533
+  [3523]: https://github.com/sbt/sbt/pull/3523
+  [zinc386]: https://github.com/sbt/zinc/pull/386
+  [lm167]: https://github.com/sbt/librarymanagement/pull/167
diff --git a/notes/1.0.3.markdown b/notes/1.0.3.markdown
new file mode 100644
index 000000000..06624a85a
--- /dev/null
+++ b/notes/1.0.3.markdown
@@ -0,0 +1,61 @@
+This is a hotfix release for sbt 1.0.x series.
+
+### Bug fixes
+
+- Fixes `~` recompiling in loop (when a source generator or sbt-buildinfo is present). [#3501][3501]/[#3634][3634] by [@dwijnand][@dwijnand]
+- Fixes undercompilation on inheritance on same source. [zinc#424][zinc424] by [@eed3si9n][@eed3si9n]
+- Fixes the compilation of package-protected objects. [zinc#431][zinc431] by [@jvican][@jvican]
+- Workaround for Java returning `null` for `getGenericParameterTypes`. [zinc#446][zinc446] by [@jvican][@jvican]
+- Fixes test detection regression. sbt 1.0.3 filters out nested objects/classes from the list, restoring compatibility with 0.13. [#3669][3669] by [@cunei][@cunei]
+- Uses Scala 2.12.4 for the build definition. This includes fix for runtime reflection of empty package members under Java 9. [#3587][3587] by [@eed3si9n][@eed3si9n]
+- Fixes extra `/` in Ivy style patterns. [lm#170][lm170] by [@laughedelic][@laughedelic]
+- Fixes "destination file exist" error message by including the file name. [lm171][lm171] by [@leonardehrenfried][@leonardehrenfried]
+- Fixes JDK 9 warning "Illegal reflective access" in library management module and Ivy. [lm173][lm173] by [@dwijnand][@dwijnand]
+
+### Improvements
+
+- Adds `sbt.watch.mode` system property to allow switching back to old polling behaviour for watch. See below for more details.
+
+#### Alternative watch mode
+
+sbt 1.0.0 introduced a new mechanism for watching for source changes based on the NIO `WatchService` in Java 1.7. On
+some platforms (namely macOS) this has led to long delays before changes are picked up. An alternative `WatchService`
+for these platforms is planned for sbt 1.1.0 ([#3527][3527]), in the meantime an option to select which watch service
+has been added.
+
+The new `sbt.watch.mode` JVM flag has been added with the following supported values:
+
+- `polling`: (default for macOS) poll the filesystem for changes (mechanism used in sbt 0.13).
+- `nio` (default for other platforms): use the NIO based `WatchService`.
+
+If you are experiencing long delays on a non-macOS machine then try adding `-Dsbt.watch.mode=polling` to your sbt
+options.
+
+[#3597][3597] by [@stringbean][@stringbean]
+
+### Contributors
+
+A huge thank you to everyone who's helped improve sbt and Zinc 1 by using them, reporting bugs, improving our documentation, porting builds, porting plugins, and submitting and reviewing pull requests.
+
+This release was brought to you by 15 contributors, according to `git shortlog -sn --no-merges v1.0.2..v1.0.3` on sbt, zinc, librarymanagement, util, io, and website: Eugene Yokota, Dale Wijnand, Michael Stringer, Jorge Vicente Cantero (jvican), Alexey Alekhin, Antonio Cunei, Andrey Artemov, Jeffrey Olchovy, Kenji Yoshida (xuwei-k), Dominik Winter, Long Jinwei, Arnout Engelen, Justin Kaeser, Leonard Ehrenfried, Sakib Hadžiavdić. Thank you!
+
+  [@dwijnand]: https://github.com/dwijnand
+  [@cunei]: https://github.com/cunei
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@jvican]: https://github.com/jvican
+  [@stringbean]: https://github.com/stringbean
+  [@laughedelic]: https://github.com/laughedelic
+  [@leonardehrenfried]: https://github.com/leonardehrenfried
+  [3669]: https://github.com/sbt/sbt/pull/3669
+  [3583]: https://github.com/sbt/sbt/issues/3583
+  [3587]: https://github.com/sbt/sbt/issues/3587
+  [3527]: https://github.com/sbt/sbt/issues/3527
+  [3597]: https://github.com/sbt/sbt/pull/3597
+  [3501]: https://github.com/sbt/sbt/issues/3501
+  [3634]: https://github.com/sbt/sbt/pull/3634
+  [lm170]: https://github.com/sbt/librarymanagement/pull/170
+  [lm171]: https://github.com/sbt/librarymanagement/pull/171
+  [lm173]: https://github.com/sbt/librarymanagement/pull/173
+  [zinc424]: https://github.com/sbt/zinc/pull/424
+  [zinc431]: https://github.com/sbt/zinc/pull/431
+  [zinc446]: https://github.com/sbt/zinc/pull/446
diff --git a/notes/1.0.3/help-sbt-new.md b/notes/1.0.3/help-sbt-new.md
new file mode 100644
index 000000000..4ef46fa9b
--- /dev/null
+++ b/notes/1.0.3/help-sbt-new.md
@@ -0,0 +1,13 @@
+[@panaeon]: https://github.com/panaeon
+
+[#2932]: https://github.com/sbt/sbt/issues/2939
+
+### Bug fixes
+
+- Make sure that when `sbt help <command>` is executed from the command line it behaves similar to `sbt "help <command>"`.
+- Add basic example and link to gitter8 templates page to `sbt new` help message.
+
+### Note:
+Unfortunately `sbt help shell` will print default general help message and drop to the sbt shell instead of displaying sbt shell help. 
+Also now `help` command will consume commands after it so `;help smth; other cmd` will not work.
+
diff --git a/notes/1.0.4.markdown b/notes/1.0.4.markdown
new file mode 100644
index 000000000..280abf7e0
--- /dev/null
+++ b/notes/1.0.4.markdown
@@ -0,0 +1,51 @@
+This is a hotfix release for sbt 1.0.x series.
+
+### Bug fixes
+
+- Fixes undercompilation of value classes when the underlying type changes. [zinc#444][zinc444] by [@smarter][@smarter]
+- Fixes `ArrayIndexOutOfBoundsException` on Ivy when running on Java 9. [ivy#27][ivy27] by [@xuwei-k][@xuwei-k]
+- Fixes Java 9 warning by upgrading to launcher 1.0.2. [ivy#26][ivy26]/[launcher#45][launcher45] by [@dwijnand][@dwijnand]
+- Fixes `run` outputing debug level logs. [#3655][3655]/[#3717][3717] by [@cunei][@cunei]
+- Fixes performance regression caused by classpath hashing. [zinc#452][zinc452] by [@jvican][@jvican]
+- Fixes performance regression of `testQuick`. [#3680][3680]/[#3720][3720] by [@OlegYch][@OlegYch]
+- Disables Ivy log4j caller location calculation for performance regression reported in [#3711][3711]. [util#132][util132] by [@leonardehrenfried][@leonardehrenfried]
+- Works around Scala compiler's `templateStats()` not being thread-safe. [#3743][3743] by [@cunei][@cunei]
+- Fixes "Attempting to overwrite" error message. [lm#174][lm174] by [@dwijnand][@dwijnand]
+- Fixes incorrect eviction warning message. [lm#179][lm179] by [@xuwei-k][@xuwei-k]
+- Registers Ivy protocol only for `http:` and `https:` to be more plugin friendly. [lm183][lm183] by [@tpunder][@tpunder]
+
+### Enhancement
+
+- Adds Scala 2.13.0-M2 support. [zinc#453][zinc453] by [@eed3si9n][@eed3si9n] and [@jan0sch][@jan0sch]
+
+### Internal
+
+- Improves Zinc scripted testing. [zinc440][zinc#440] by [@jvican][@jvican]
+
+  [@dwijnand]: https://github.com/dwijnand
+  [@cunei]: https://github.com/cunei
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@jvican]: https://github.com/jvican
+  [@OlegYch]: https://github.com/OlegYch
+  [@leonardehrenfried]: https://github.com/leonardehrenfried
+  [@xuwei-k]: https://github.com/xuwei-k
+  [@tpunder]: https://github.com/tpunder
+  [@smarter]: https://github.com/smarter
+  [@jan0sch]: https://github.com/jan0sch
+  [3655]: https://github.com/sbt/sbt/issues/3655
+  [3717]: https://github.com/sbt/sbt/pull/3717
+  [ivy26]: https://github.com/sbt/ivy/pull/26
+  [ivy27]: https://github.com/sbt/ivy/pull/27
+  [launcher45]: https://github.com/sbt/launcher/pull/45
+  [3680]: https://github.com/sbt/sbt/issues/3680
+  [3720]: https://github.com/sbt/sbt/pull/3720
+  [3743]: https://github.com/sbt/sbt/pull/3743
+  [3711]: https://github.com/sbt/sbt/issues/3711
+  [util132]: https://github.com/sbt/util/pull/132
+  [lm174]: https://github.com/sbt/librarymanagement/pull/174
+  [lm179]: https://github.com/sbt/librarymanagement/pull/179
+  [lm183]: https://github.com/sbt/librarymanagement/pull/183
+  [zinc452]: https://github.com/sbt/zinc/pull/452
+  [zinc444]: https://github.com/sbt/zinc/pull/444
+  [zinc453]: https://github.com/sbt/zinc/pull/453
+  [zinc440]: https://github.com/sbt/zinc/pull/440
diff --git a/notes/1.1.0.markdown b/notes/1.1.0.markdown
new file mode 100644
index 000000000..723c20c27
--- /dev/null
+++ b/notes/1.1.0.markdown
@@ -0,0 +1,190 @@
+### Changes since RC-2
+
+- Provides workaround for `File#lastModified()` losing millisecond-precision by using native code when possible. [io#92](https://github.com/sbt/io/pull/92)/[io#106](https://github.com/sbt/io/pull/106) by [@cunei][@cunei]
+- Fixes `IO.relativize` not working with relative path. [io#108](https://github.com/sbt/io/pull/108) by [@dwijnand][@dwijnand]
+- Fixes `ClasspathFilter` that was causing `Class.forName` to not work in `run`. [zinc#473](https://github.com/sbt/zinc/pull/473) / [#3736](https://github.com/sbt/sbt/issues/3736) / [#3733](https://github.com/sbt/sbt/issues/3733) / [#3647](https://github.com/sbt/sbt/issues/3647) / [#3608](https://github.com/sbt/sbt/issues/3608) by [@ravwojdyla][@ravwojdyla]
+- Fixes JNA version mixup. [#3837](https://github.com/sbt/sbt/pull/3837) by [@eed3si9n][@eed3si9n]
+- Fixes warning message when multiple instances are detected. [#3828](https://github.com/sbt/sbt/pull/3828) by [@eed3si9n][@eed3si9n]
+
+### Changes since RC-1
+
+- Fixes Java compilation causing `NullPointerException` by making PositionImpl thread-safe. [zinc#465](https://github.com/sbt/zinc/pull/465) by [@eed3si9n][@eed3si9n]
+- Restores Scala 2.13.0-M1 support. #461 by [@dwijnand][@dwijnand]
+- Fixes `PollingWatchService` by preventing concurrent modification of `keysWithEvents` map. [io#90](https://github.com/sbt/io/pull/90) by [@mechkg][@mechkg], which fixes `~` related issues [#3687](https://github.com/sbt/sbt/issues/3687), [#3695](https://github.com/sbt/sbt/issues/3695), and [#3775](https://github.com/sbt/sbt/issues/3775).
+- Fixed server spewing out debug level logs. [#3791](https://github.com/sbt/sbt/pull/3791) by [@eed3si9n][@eed3si9n]
+- Fixes the encoding of Unix-like file path to use `file:///`. [#3805](https://github.com/sbt/sbt/pull/3805) by [@eed3si9n][@eed3si9n]
+- Fixes Log4J2 initialization error during startup. [#3814](https://github.com/sbt/sbt/pull/3814) by [@dwijnand][@dwijnand]
+
+### Features, fixes, changes with compatibility implications
+
+- sbt server feature is reworked in sbt 1.1.0. See below.
+- Changes `version` setting default to `0.1.0-SNAPSHOT` for compatibility with Semantic Versioning. [#3577][3577] by [@laughedelic][@laughedelic]
+
+### Features
+
+- Unifies sbt shell and build.sbt syntax. See below.
+
+### Fixes
+
+- Fixes over-compilation bug with Java 9. [zinc#450][zinc450] by [@retronym][@retronym]
+- Fixes handling of deeply nested Java classes. [zinc#423][zinc423] by [@romanowski][@romanowski]
+- Fixes JavaDoc not printing all errors. [zinc#415][zinc415] by [@raboof][@raboof]
+- Preserves JAR order in `ScalaInstance.otherJars`. [zinc#411][zinc411] by [@dwijnand][@dwijnand]
+- Fixes used name when it contains NL. [zinc#449][zinc449] by [@jilen][@jilen]
+- Fixes handling of `ThisProject`. [#3609][3609] by [@dwijnand][@dwijnand]
+- Escapes imports from sbt files, so if user creates a backquoted definition then task evalution will not fail. [#3635][3635] by [@panaeon][@panaeon]
+- Removes reference to version 0.14.0 from a warning message. [#3693][3693] by [@saniyatech][@saniyatech]
+- Fixes screpl throwing "Not a valid key: console-quick". [#3762][3762] by [@xuwei-k][@xuwei-k]
+
+### Improvements
+
+- Filters scripted tests based on optional `project/build.properties`. See below.
+- Adds `Project#withId` to change a project's id. [#3601][3601] by [@dwijnand][@dwijnand]
+- Adds `reboot dev` command, which deletes the current artifact from the boot directory. This is useful when working with development versions of sbt. [#3659][3659] by [@eed3si9n][@eed3si9n]
+- Adds a check for a change in sbt version before `reload`. [#1055][1055]/[#3673][3673] by [@RomanIakovlev][@RomanIakovlev]
+- Adds a new setting `insideCI`, which indicates that sbt is likely running in an Continuous Integration environment. [#3672][3672] by [@RomanIakovlev][@RomanIakovlev]
+- Adds `nameOption` to `Command` trait. [#3671][3671] by [@miklos-martin][@miklos-martin]
+- Adds POSIX persmission operations in IO, such as `IO.chmod(..)`. [io#76][io76] by [@eed3si9n][@eed3si9n]
+- Treat sbt 1 modules using Semantic Versioning in the eviction warning. [lm#188][lm188] by [@eed3si9n][@eed3si9n]
+- Uses kind-projector in the code. [#3650][3650] by [@dwijnand][@dwijnand]
+- Make `displayOnly` etc methods strict in `Completions`. [#3763][3763] by [@xuwei-k][@xuwei-k]
+
+### Unified slash syntax for sbt shell and build.sbt
+
+This adds unified slash syntax for both sbt shell and the build.sbt DSL.
+Instead of the current `<project-id>/config:intask::key`, this adds
+`<project-id>/<config-ident>/intask/key` where `<config-ident>` is the Scala identifier
+notation for the configurations like `Compile` and `Test`. (The old shell syntax will continue to function)
+
+These examples work both from the shell and in build.sbt.
+
+    Global / cancelable
+    ThisBuild / scalaVersion
+    Test / test
+    root / Compile / compile / scalacOptions
+    ProjectRef(uri("file:/xxx/helloworld/"),"root")/Compile/scalacOptions
+    Zero / Zero / name
+
+The inspect command now outputs something that can be copy-pasted:
+
+    > inspect compile
+    [info] Task: sbt.inc.Analysis
+    [info] Description:
+    [info]  Compiles sources.
+    [info] Provided by:
+    [info]  ProjectRef(uri("file:/xxx/helloworld/"),"root")/Compile/compile
+    [info] Defined at:
+    [info]  (sbt.Defaults) Defaults.scala:326
+    [info] Dependencies:
+    [info]  Compile/manipulateBytecode
+    [info]  Compile/incCompileSetup
+    ....
+
+[#1812][1812]/[#3434][3434]/[#3617][3617]/[#3620][3620] by [@eed3si9n][@eed3si9n] and [@dwijnand][@dwijnand]
+
+### sbt server
+
+sbt server feature was reworked to use Language Server Protocol 3.0 (LSP) as the wire protocol, a protocol created by Microsoft for Visual Studio Code.
+
+To discover a running server, sbt 1.1.0 creates a port file at `./project/target/active.json` relative to a build:
+
+```
+{"uri":"local:///Users/foo/.sbt/1.0/server/0845deda85cb41abcdef/sock"}
+```
+
+`local:` indicates a UNIX domain socket. Here's how we can say hello to the server using `nc`. (`^M` can be sent `Ctrl-V` then `Return`):
+
+```
+$ nc -U /Users/foo/.sbt/1.0/server/0845deda85cb41abcdef/sock
+Content-Length: 99^M
+^M
+{ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "initializationOptions": { } } }^M
+```
+
+sbt server adds network access to sbt's shell command so, in addition to accepting input from the terminal, server also to accepts input from the network. Here's how we can call `compile`:
+
+```
+Content-Length: 93^M
+^M
+{ "jsonrpc": "2.0", "id": 2, "method": "sbt/exec", "params": { "commandLine": "compile" } }^M
+```
+
+The running sbt session should now queue `compile`, and return back with compiler warnings and errors, if any:
+
+```
+Content-Length: 296
+Content-Type: application/vscode-jsonrpc; charset=utf-8
+
+{"jsonrpc":"2.0","method":"textDocument/publishDiagnostics","params":{"uri":"file:/Users/foo/work/hellotest/Hello.scala","diagnostics":[{"range":{"start":{"line":2,"character":26},"end":{"line":2,"character":27}},"severity":1,"source":"sbt","message":"object X is not a member of package foo"}]}}
+```
+
+[#3524][3524]/[#3556][3556] by [@eed3si9n][@eed3si9n]
+
+### VS Code extension
+
+The primary use case we have in mind for the sbt server is tooling integration such as editors and IDEs. As a proof of concept, we created a Visual Studio Code extension called [Scala (sbt)][vscode-sbt-scala].
+
+Currently this extension is able to:
+
+- Run `compile` at the root project when `*.scala` files are saved. [#3524][3524] by [@eed3si9n][@eed3si9n]
+- Display compiler errors.
+- Display log messages. [#3740][3740] by [@laughedelic][@laughedelic]
+- Jump to class definitions. [#3660][3660] by [@wpopielarski][@wpopielarski]
+
+### Filtering scripted tests using `project/build.properties`
+
+For all scripted tests in which `project/build.properties` exist, the value of the `sbt.version` property is read. If its binary version is different from `sbtBinaryVersion in pluginCrossBuild` the test will be skipped and a message indicating this will be logged.
+
+This allows you to define scripted tests that track the minimum supported sbt versions, e.g. 0.13.9 and 1.0.0-RC2. [#3564][3564]/[#3566][3566] by [@jonas][@jonas]
+
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dwijnand]: https://github.com/dwijnand
+  [@cunei]: https://github.com/cunei
+  [@jvican]: https://github.com/jvican
+  [@Duhemm]: https://github.com/Duhemm
+  [@jonas]: https://github.com/jonas
+  [@laughedelic]: https://github.com/laughedelic
+  [@panaeon]: https://github.com/panaeon
+  [@RomanIakovlev]: https://github.com/RomanIakovlev
+  [@miklos-martin]: https://github.com/miklos-martin
+  [@saniyatech]: https://github.com/saniyatech
+  [@xuwei-k]: https://github.com/xuwei-k
+  [@wpopielarski]: https://github.com/wpopielarski
+  [@retronym]: https://github.com/retronym
+  [@romanowski]: https://github.com/romanowski
+  [@raboof]: https://github.com/raboof
+  [@jilen]: https://github.com/jilen
+  [@mechkg]: https://github.com/mechkg
+  [@ravwojdyla]: https://github.com/ravwojdyla
+  [vscode-sbt-scala]: https://marketplace.visualstudio.com/items?itemName=lightbend.vscode-sbt-scala
+  [1812]: https://github.com/sbt/sbt/issues/1812
+  [3524]: https://github.com/sbt/sbt/pull/3524
+  [3556]: https://github.com/sbt/sbt/pull/3556
+  [3564]: https://github.com/sbt/sbt/issues/3564
+  [3566]: https://github.com/sbt/sbt/pull/3566
+  [3577]: https://github.com/sbt/sbt/pull/3577
+  [3434]: https://github.com/sbt/sbt/pull/3434
+  [3601]: https://github.com/sbt/sbt/pull/3601
+  [3609]: https://github.com/sbt/sbt/pull/3609
+  [3617]: https://github.com/sbt/sbt/pull/3617
+  [3620]: https://github.com/sbt/sbt/pull/3620
+  [3464]: https://github.com/sbt/sbt/issues/3464
+  [3635]: https://github.com/sbt/sbt/pull/3635
+  [3659]: https://github.com/sbt/sbt/pull/3659
+  [3650]: https://github.com/sbt/sbt/pull/3650
+  [3673]: https://github.com/sbt/sbt/pull/3673
+  [1055]: https://github.com/sbt/sbt/issues/1055
+  [3672]: https://github.com/sbt/sbt/pull/3672
+  [3671]: https://github.com/sbt/sbt/pull/3671
+  [3693]: https://github.com/sbt/sbt/issues/3693
+  [3763]: https://github.com/sbt/sbt/pull/3763
+  [3762]: https://github.com/sbt/sbt/pull/3762
+  [3740]: https://github.com/sbt/sbt/pull/3740
+  [3660]: https://github.com/sbt/sbt/pull/3660
+  [io76]: https://github.com/sbt/io/pull/76
+  [lm188]: https://github.com/sbt/librarymanagement/pull/188
+  [zinc450]: https://github.com/sbt/zinc/pull/450
+  [zinc423]: https://github.com/sbt/zinc/pull/423
+  [zinc415]: https://github.com/sbt/zinc/issues/415
+  [zinc411]: https://github.com/sbt/zinc/pull/411
+  [zinc449]: https://github.com/sbt/zinc/pull/449
diff --git a/notes/1.1.1.markdown b/notes/1.1.1.markdown
new file mode 100644
index 000000000..3bd7276cd
--- /dev/null
+++ b/notes/1.1.1.markdown
@@ -0,0 +1,45 @@
+### Fixes
+
+- Fixes "Modified names for (class) is empty" error. [zinc#292][zinc292] / [zinc#484][zinc484] by [@jvican][@jvican]
+- Fixes tab completion in `console` while running in batch mode as `sbt console`. [#3841][3841]/[#3876][3876] by [@eed3si9n][@eed3si9n]
+- Fixes file timestamp retrieval of missing files on Windows. [#3871][3871] / [io#120][io120] by [@cunei][@cunei]
+- Aligns the errors thrown by file timestamp implementations. Fixes [#3894][3894] / [io#121][io121] by [@j-keck][@j-keck]
+- Adds file timestamps native support for FreeBSD. [#3894][3894] / [io#124][io124] by [@cunei][@cunei]
+- Fixes JDK 10 version string parsing. [launcher#209][launcher209] by [@2m][@2m]
+
+### Improvements
+
+- Deprecates `Extracted#append` in favour of `appendWithSession` or `appendWithoutSession`.  [#3865][3865] by [@dwijnand][@dwijnand]
+- Adds a new global `Boolean` setting called `autoStartServer`. See below.
+- Upgrades Scala versions used for sbt cross building `^^`. [#3923][3923] by [@dwijnand][@dwijnand]
+- Many documentation maintenance changes by [@xuwei-k][@xuwei-k]
+
+### autoStartServer setting
+
+sbt 1.1.1 adds a new global `Boolean` setting called `autoStartServer`, which is set to `true` by default.
+When set to `true`, sbt shell will automatically start sbt server. Otherwise, it will not start the server until `startServer` command is issued. This could be used to opt out of server for security reasons.
+
+[#3922][3922] by [@swaldman][@swaldman]
+
+  [@eed3si9n]: https://github.com/eed3si9n
+  [@dwijnand]: https://github.com/dwijnand
+  [@cunei]: https://github.com/cunei
+  [@jvican]: https://github.com/jvican
+  [@Duhemm]: https://github.com/Duhemm
+  [@j-keck]: https://github.com/j-keck
+  [@swaldman]: https://github.com/swaldman
+  [@xuwei-k]: https://github.com/xuwei-k
+  [@2m]: https://github.com/2m
+  [3871]: https://github.com/sbt/sbt/issues/3871
+  [io120]: https://github.com/sbt/io/pull/120
+  [3894]: https://github.com/sbt/sbt/issues/3894
+  [io121]: https://github.com/sbt/io/pull/121
+  [io124]: https://github.com/sbt/io/pull/124
+  [zinc292]: https://github.com/sbt/zinc/issues/292
+  [zinc484]: https://github.com/sbt/zinc/pull/484
+  [3865]: https://github.com/sbt/sbt/pull/3865
+  [3841]: https://github.com/sbt/sbt/issues/3841
+  [3876]: https://github.com/sbt/sbt/pull/3876
+  [3923]: https://github.com/sbt/sbt/pull/3923
+  [3922]: https://github.com/sbt/sbt/pull/3922
+  [launcher209]: https://github.com/sbt/sbt-launcher-package/pull/209
diff --git a/notes/1.1.2/in_configurations_scope_filter_factories.md b/notes/1.1.2/in_configurations_scope_filter_factories.md
new file mode 100644
index 000000000..3effa6ac7
--- /dev/null
+++ b/notes/1.1.2/in_configurations_scope_filter_factories.md
@@ -0,0 +1,10 @@
+### Improvements
+
+- Adds factory methods for Configuration axis scope filters
+
+### More ways to create ScopeFilter for Configuration axis
+
+To create configuration axis `ScopeFilter` one has to provide actual configurations
+to filter by. However it's not always possible to get hold of one. For example
+`Classpaths.interSort` returns configuration names.
+For cases like that there are now `inConfigurationsByKeys` and `inConfigurationsByRefs` to create `ScopeFilter`'s
diff --git a/notes/1.1.4/improving_loading_settings_messaging.md b/notes/1.1.4/improving_loading_settings_messaging.md
new file mode 100644
index 000000000..683846bbb
--- /dev/null
+++ b/notes/1.1.4/improving_loading_settings_messaging.md
@@ -0,0 +1,22 @@
+### Improvements
+
+Now when loading a project that has multiple build.sbt files the logger shows the path as well.
+Before it was:
+
+```bash
+[info] Loading settings from build.sbt ...
+[info] Loading settings from build.sbt ...
+[info] Loading settings from build.sbt ...
+[info] Loading settings from build.sbt ...
+```
+
+Now it's:
+
+```bash
+[info] Loading settings from /home/user/Work/personal/someProject/build.sbt ...
+[info] Loading settings from /home/user/Work/personal/someProject/subProject1/build.sbt ...
+[info] Loading settings from /home/user/Work/personal/someProject/subProject2/build.sbt ...
+[info] Loading settings from /home/user/Work/personal/someProject/subProject3/build.sbt ...
+```
+
+This should solve the issue: https://github.com/sbt/sbt/issues/3607
\ No newline at end of file
diff --git a/notes/1.1.5/dotty-plugin.md b/notes/1.1.5/dotty-plugin.md
new file mode 100644
index 000000000..6250c30dd
--- /dev/null
+++ b/notes/1.1.5/dotty-plugin.md
@@ -0,0 +1,9 @@
+[@liufengyun]: https://github.com/liufengyun
+
+[4073]: https://github.com/sbt/sbt/issues/4073
+[4084]: https://github.com/sbt/sbt/pull/4084
+
+
+### Improvements
+
+- Detect dotty plugins which have descriptor file named `plugin.properties` instead of `scalac-plugin.xml`.  [#4073][4073]/[#4084][4084] by [@liufengyun][@liufengyun]
diff --git a/notes/1.2.0/add-plugin.md b/notes/1.2.0/add-plugin.md
new file mode 100644
index 000000000..913b3309b
--- /dev/null
+++ b/notes/1.2.0/add-plugin.md
@@ -0,0 +1,14 @@
+Adds `--addPluginSbtFile=<file>` command, which adds the given .sbt file to the plugin build.
+Using this mechanism editors or IDEs can start a build with required plugin.
+
+```
+$ cat /tmp/extra.sbt
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.7")
+
+$ sbt --addPluginSbtFile=/tmp/extra.sbt
+...
+sbt:helloworld> plugins
+In file:/xxxx/hellotest/
+  ...
+  sbtassembly.AssemblyPlugin: enabled in root
+```
diff --git a/notes/1.2.0/add-project-id-to-watching-message.md b/notes/1.2.0/add-project-id-to-watching-message.md
new file mode 100644
index 000000000..7c6a1bf57
--- /dev/null
+++ b/notes/1.2.0/add-project-id-to-watching-message.md
@@ -0,0 +1,12 @@
+[@dwijnand]: https://github.com/dwijnand
+
+[#2038]: https://github.com/sbt/sbt/issues/2038
+[#3813]: https://github.com/sbt/sbt/pull/3813
+
+### Fixes with compatibility implications
+
+### Improvements
+
+- Add the current project's id to `~`'s watching message.  [#2038][]/[#3813][] by [@dwijnand][]
+
+### Bug fixes
diff --git a/notes/1.2.0/cross-strict-aggregation.md b/notes/1.2.0/cross-strict-aggregation.md
new file mode 100644
index 000000000..170207536
--- /dev/null
+++ b/notes/1.2.0/cross-strict-aggregation.md
@@ -0,0 +1,8 @@
+[@ruippeixotog]: https://github.com/ruippeixotog
+
+[#3698]: https://github.com/sbt/sbt/issues/3698
+[#3995]: https://github.com/sbt/sbt/pull/3995
+
+### Improvements
+
+- Make `++ <scala-version> <command>` run `<command>` only on compatible subprojects. [#3698][]/[#3995][] by [@ruippeixotog][]
diff --git a/notes/1.2.0/fix-sbt012x-link.md b/notes/1.2.0/fix-sbt012x-link.md
new file mode 100644
index 000000000..3e368f8cb
--- /dev/null
+++ b/notes/1.2.0/fix-sbt012x-link.md
@@ -0,0 +1,4 @@
+### Bug fixes
+
+* Fixes link to SBT upgrade migration page
+
diff --git a/notes/1.2.0/global-eviction-warnin-options.md b/notes/1.2.0/global-eviction-warnin-options.md
new file mode 100644
index 000000000..981bc2477
--- /dev/null
+++ b/notes/1.2.0/global-eviction-warnin-options.md
@@ -0,0 +1,3 @@
+### Improvements
+
+- Add the eviction warning options to global, so that one can change the options for all sub projects at a time.
diff --git a/notes/1.2.0/inspect-alias.md b/notes/1.2.0/inspect-alias.md
new file mode 100644
index 000000000..1840791f1
--- /dev/null
+++ b/notes/1.2.0/inspect-alias.md
@@ -0,0 +1,7 @@
+[@ruippeixotog]: https://github.com/gpoirier
+
+[#2881]: https://github.com/sbt/sbt/issues/2881
+
+### Improvements
+
+- Adding minimal support for commands in inspect. There's also a special case for aliases.
diff --git a/notes/1.2.0/introduce-CompositeProject.md b/notes/1.2.0/introduce-CompositeProject.md
new file mode 100644
index 000000000..759d75a71
--- /dev/null
+++ b/notes/1.2.0/introduce-CompositeProject.md
@@ -0,0 +1,9 @@
+
+[#3042]: https://github.com/sbt/sbt/issues/3042
+[#4056]: https://github.com/sbt/sbt/pull/4056
+
+### Introduce CompositeProject
+
+### Improvements
+
+- Support for: `lazy val foo = someCompositeProject` (e.g.`CrossProject`)  [#3042][]/[#4056][]
diff --git a/notes/1.2.0/introduce-projectToLocalProject.md b/notes/1.2.0/introduce-projectToLocalProject.md
new file mode 100644
index 000000000..8f856d3e8
--- /dev/null
+++ b/notes/1.2.0/introduce-projectToLocalProject.md
@@ -0,0 +1,12 @@
+[@dwijnand]: https://github.com/dwijnand
+
+[#3757]: https://github.com/sbt/sbt/issues/3757
+[#3836]: https://github.com/sbt/sbt/pull/3836
+
+### Fixes with compatibility implications
+
+### Improvements
+
+- Introduces `projectToLocalProject` to replace `projectToRef`.  [#3757][]/[#3836][] by [@dwijnand][]
+
+### Bug fixes
diff --git a/notes/1.2.0/offline.md b/notes/1.2.0/offline.md
new file mode 100644
index 000000000..6a0a9e68b
--- /dev/null
+++ b/notes/1.2.0/offline.md
@@ -0,0 +1,2 @@
+- `-Dsbt.offline=true` now can set offline mode.
+
diff --git a/notes/1.2.0/scripted-change.md b/notes/1.2.0/scripted-change.md
new file mode 100644
index 000000000..63715ecab
--- /dev/null
+++ b/notes/1.2.0/scripted-change.md
@@ -0,0 +1,27 @@
+
+### Fixes with compatibility implications
+
+- In sbt 1.2, `ScriptedPlugin` is no longer triggered automatically. This allows easier use of the plugin in a multi-project build. We recommend migration to `SbtPlugin`.  [#3514][3514]/[#3875][3875] by [@eed3si9n][@eed3si9n]
+- `scriptedBufferLog` and `scriptedLaunchOpts` settings are changed so they are scoped globally.
+
+### Features
+
+- Adds `SbtPlugin`. See below.
+
+### Bug fixes
+
+
+### SbtPlugin
+
+`SbtPlugin` is a new plugin that represents sbt plugin projects.
+
+    lazy val fooPlugin = (project in file("plugin"))
+      .enablePlugins(SbtPlugin)
+
+This sets `sbtPlugin` setting to `true`, and brings in the new non-triggered `ScriptedPlugin`.
+
+[#3875][3875] by [@eed3si9n][@eed3si9n]
+
+  [@eed3si9n]: https://github.com/eed3si9n
+  [3514]: https://github.com/sbt/sbt/issues/3514
+  [3875]: https://github.com/sbt/sbt/pull/3875
diff --git a/notes/1.2.0/unknown-config-warning.md b/notes/1.2.0/unknown-config-warning.md
new file mode 100644
index 000000000..645cbedf9
--- /dev/null
+++ b/notes/1.2.0/unknown-config-warning.md
@@ -0,0 +1,8 @@
+[@steinybot]: https://github.com/steinybot
+
+[#4065]: https://github.com/sbt/sbt/issues/4065
+[#4231]: https://github.com/sbt/sbt/pull/4231
+
+### Improvements
+
+- Add a warning for unknown project configurations.  [#4065][]/[#4231][] by [@steinybot][]
diff --git a/notes/1.3.0/enable-multiple-source-file-in-mappings.md b/notes/1.3.0/enable-multiple-source-file-in-mappings.md
new file mode 100644
index 000000000..8a085472b
--- /dev/null
+++ b/notes/1.3.0/enable-multiple-source-file-in-mappings.md
@@ -0,0 +1,9 @@
+[@muuki88]: https://github.com/muuki88
+[@gutefrageIT]: https://twitter.com/gutefrageIT
+
+[#1972]: https://github.com/sbt/sbt/issues/1972
+[#4329]: https://github.com/sbt/sbt/pull/4329
+
+### Bug Fixes
+
+- Enable packaging of the same file more than once  [#1972][]/[#4329][] by [@muuki88][] (sponsored by [@gutefrageIT][])
diff --git a/notes/1.3.0/set-swovalpath-with-absolutepath.md b/notes/1.3.0/set-swovalpath-with-absolutepath.md
new file mode 100644
index 000000000..7aac9d05c
--- /dev/null
+++ b/notes/1.3.0/set-swovalpath-with-absolutepath.md
@@ -0,0 +1,8 @@
+[@yamachu]: https://github.com/yamachu
+
+[#5047]: https://github.com/sbt/sbt/issues/5047
+[#5048]: https://github.com/sbt/sbt/pull/5048
+
+### Bug Fixes
+
+- Enable file watching when setting relative path to sbt.global.base [#5047][5047]/[#5048][5048] by [@yamachu][@yamachu]
diff --git a/notes/about.markdown b/notes/about.markdown
index aedb2df72..2cd2b85b5 100644
--- a/notes/about.markdown
+++ b/notes/about.markdown
@@ -1 +1 @@
-[sbt](http://www.scala-sbt.org/) is the interactive build tool.
+[sbt](https://www.scala-sbt.org/) is the interactive build tool.
diff --git a/notes/1.0.0/publishTo-otherResolvers-become-tasks.markdown b/notes/sample.md
similarity index 62%
rename from notes/1.0.0/publishTo-otherResolvers-become-tasks.markdown
rename to notes/sample.md
index 54bcb00cc..101e0df4c 100644
--- a/notes/1.0.0/publishTo-otherResolvers-become-tasks.markdown
+++ b/notes/sample.md
@@ -7,6 +7,6 @@
 
 ### Improvements
 
-- Changes publishTo & otherResolvers from SettingKey's to TaskKey's. [#2059][2059]/[#2662][2662] by [@dwijnand][@dwijnand]
+- Changes `publishTo` and `otherResolvers` from SettingKeys to TaskKeys. [#2059][2059]/[#2662][2662] by [@dwijnand][@dwijnand]
 
 ### Bug fixes
diff --git a/project/ContrabandConfig.scala b/project/ContrabandConfig.scala
new file mode 100644
index 000000000..b13824355
--- /dev/null
+++ b/project/ContrabandConfig.scala
@@ -0,0 +1,47 @@
+import sbt.contraband.ast._
+import sbt.contraband.CodecCodeGen
+
+object ContrabandConfig {
+
+  /** Extract the only type parameter from a TpeRef */
+  def oneArg(tpe: Type): Type = {
+    val pat = s"""${tpe.removeTypeParameters.name}[<\\[](.+?)[>\\]]""".r
+    val pat(arg0) = tpe.name
+    NamedType(arg0 split '.' toList)
+  }
+
+  /** Extract the two type parameters from a TpeRef */
+  def twoArgs(tpe: Type): List[Type] = {
+    val pat = s"""${tpe.removeTypeParameters.name}[<\\[](.+?), (.+?)[>\\]]""".r
+    val pat(arg0, arg1) = tpe.name
+    NamedType(arg0 split '.' toList) :: NamedType(arg1 split '.' toList) :: Nil
+  }
+
+  /** Codecs that were manually written. */
+  val myCodecs: PartialFunction[String, Type => List[String]] = {
+    // TODO: These are handled by BasicJsonProtocol, and sbt-contraband should handle them by default, imo
+    case "Option" | "Set" | "scala.Vector" => { tpe =>
+      getFormats(oneArg(tpe))
+    }
+    case "Map" | "Tuple2" | "scala.Tuple2" => { tpe =>
+      twoArgs(tpe).flatMap(getFormats)
+    }
+    case "Int" | "Long" => { _ =>
+      Nil
+    }
+    case "sbt.testing.Status" => { _ =>
+      "sbt.internal.testing.StatusFormats" :: Nil
+    }
+    case "scalajson.ast.unsafe.JValue" | "sjsonnew.shaded.scalajson.ast.unsafe.JValue" => { _ =>
+      "sbt.internal.util.codec.JValueFormats" :: Nil
+    }
+  }
+
+  /** Returns the list of formats required to encode the given `TpeRef`. */
+  val getFormats: Type => List[String] =
+    CodecCodeGen.extensibleFormatsForType {
+      case tpe: Type if myCodecs isDefinedAt tpe.removeTypeParameters.name =>
+        myCodecs(tpe.removeTypeParameters.name)(tpe)
+      case other => CodecCodeGen.formatsForType(other)
+    }
+}
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 5c0e9e9ef..cdd2451e5 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -1,55 +1,120 @@
 import sbt._
 import Keys._
+import sbt.contraband.ContrabandPlugin.autoImport._
 
 object Dependencies {
-  lazy val scala282 = "2.8.2"
-  lazy val scala292 = "2.9.2"
-  lazy val scala293 = "2.9.3"
-  lazy val scala210 = "2.10.6"
-  lazy val scala211 = "2.11.8"
+  // WARNING: Please Scala update versions in PluginCross.scala too
+  val scala212 = "2.12.13"
+  val scala213 = "2.13.3"
+  val checkPluginCross = settingKey[Unit]("Make sure scalaVersion match up")
+  val baseScalaVersion = scala212
+  def nightlyVersion: Option[String] =
+    sys.env.get("BUILD_VERSION") orElse sys.props.get("sbt.build.version")
 
   // sbt modules
-  val ioVersion = "1.0.0-M6"
-  val utilVersion = "0.1.0-M14"
-  val librarymanagementVersion = "0.1.0-X1"
-  val zincVersion = "1.0.0-X3"
-  lazy val sbtIO = "org.scala-sbt" %% "io" % ioVersion
-  lazy val utilCollection = "org.scala-sbt" %% "util-collection" % utilVersion
-  lazy val utilLogging = "org.scala-sbt" %% "util-logging" % utilVersion
-  lazy val utilTesting = "org.scala-sbt" %% "util-testing" % utilVersion
-  lazy val utilControl = "org.scala-sbt" %% "util-control" % utilVersion
-  lazy val utilCompletion = "org.scala-sbt" %% "util-completion" % utilVersion
-  lazy val utilApplyMacro = "org.scala-sbt" %% "util-apply-macro" % utilVersion
-  lazy val utilRelation = "org.scala-sbt" %% "util-relation" % utilVersion
-  lazy val utilLogic = "org.scala-sbt" %% "util-logic" % utilVersion
-  lazy val utilCache = "org.scala-sbt" %% "util-cache" % utilVersion
-  lazy val utilTracking = "org.scala-sbt" %% "util-tracking" % utilVersion
-  lazy val utilScripted = "org.scala-sbt" %% "util-scripted" % utilVersion
-  lazy val libraryManagement = "org.scala-sbt" %% "librarymanagement" % librarymanagementVersion
-  lazy val launcherInterface = "org.scala-sbt" % "launcher-interface" % "1.0.0"
-  lazy val rawLauncher = "org.scala-sbt" % "launcher" % "1.0.0"
-  lazy val testInterface = "org.scala-sbt" % "test-interface" % "1.0"
+  private val ioVersion = nightlyVersion.getOrElse("1.5.0-M1")
+  private val lmVersion =
+    sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.5.0-M9")
+  val zincVersion = nightlyVersion.getOrElse("1.5.0-M5")
 
-  lazy val zinc = "org.scala-sbt" %% "zinc" % zincVersion
-  lazy val zincCompile = "org.scala-sbt" %% "zinc-compile" % zincVersion
-  lazy val compilerInterface = "org.scala-sbt" % "compiler-interface" % zincVersion
-  lazy val compilerBrdige = "org.scala-sbt" %% "compiler-bridge" % zincVersion
-  lazy val compilerClasspath = "org.scala-sbt" %% "zinc-classpath" % zincVersion
-  lazy val compilerApiInfo = "org.scala-sbt" %% "zinc-apiinfo" % zincVersion
-  lazy val compilerIvyIntegration = "org.scala-sbt" %% "zinc-ivy-integration" % zincVersion
-  lazy val sjsonNewScalaJson = "com.eed3si9n" %% "sjson-new-scalajson" % "0.4.2"
+  private val sbtIO = "org.scala-sbt" %% "io" % ioVersion
 
-  lazy val scalaCheck = "org.scalacheck" %% "scalacheck" % "1.11.4"
-  lazy val specs2 = "org.specs2" %% "specs2" % "2.3.11"
-  lazy val junit = "junit" % "junit" % "4.11"
+  private val libraryManagementCore = "org.scala-sbt" %% "librarymanagement-core" % lmVersion
+  private val libraryManagementIvy = "org.scala-sbt" %% "librarymanagement-ivy" % lmVersion
 
-  private def scala211Module(name: String, moduleVersion: String) =
-    Def.setting {
-      scalaVersion.value match {
-        case sv if (sv startsWith "2.9.") || (sv startsWith "2.10.") => Nil
-        case _ => ("org.scala-lang.modules" %% name % moduleVersion) :: Nil
-      }
+  val launcherVersion = "1.3.0-M3"
+  val launcherInterface = "org.scala-sbt" % "launcher-interface" % launcherVersion
+  val rawLauncher = "org.scala-sbt" % "launcher" % launcherVersion
+  val testInterface = "org.scala-sbt" % "test-interface" % "1.0"
+  val ipcSocket = "org.scala-sbt.ipcsocket" % "ipcsocket" % "1.3.0"
+
+  private val compilerInterface = "org.scala-sbt" % "compiler-interface" % zincVersion
+  private val compilerClasspath = "org.scala-sbt" %% "zinc-classpath" % zincVersion
+  private val compilerApiInfo = "org.scala-sbt" %% "zinc-apiinfo" % zincVersion
+  private val compilerBridge = "org.scala-sbt" %% "compiler-bridge" % zincVersion
+  private val zinc = "org.scala-sbt" %% "zinc" % zincVersion
+  private val zincCompile = "org.scala-sbt" %% "zinc-compile" % zincVersion
+  private val zincCompileCore = "org.scala-sbt" %% "zinc-compile-core" % zincVersion
+
+  def getSbtModulePath(key: String) = {
+    val localProps = new java.util.Properties()
+    IO.load(localProps, file("project/local.properties"))
+    val path = Option(localProps.getProperty(key)).orElse(sys.props.get(key))
+    path.foreach(f => println(s"Using $key=$f"))
+    path
+  }
+
+  lazy val sbtIoPath = getSbtModulePath("sbtio.path")
+  lazy val sbtUtilPath = getSbtModulePath("sbtutil.path")
+  lazy val sbtLmPath = getSbtModulePath("sbtlm.path")
+  lazy val sbtZincPath = getSbtModulePath("sbtzinc.path")
+
+  def addSbtModule(
+      path: Option[String],
+      projectName: String,
+      moduleId: ModuleID,
+      c: Option[Configuration] = None
+  ) = (p: Project) => {
+    val m = moduleId.withConfigurations(c.map(_.name))
+    path match {
+      case Some(f) =>
+        p.dependsOn(ClasspathDependency(ProjectRef(file(f), projectName), c.map(_.name)))
+      case None => p.settings(libraryDependencies += m, dependencyOverrides += m)
     }
-  lazy val scalaXml = scala211Module("scala-xml", "1.0.1")
-  lazy val scalaParsers = scala211Module("scala-parser-combinators", "1.0.1")
+  }
+
+  def addSbtIO = addSbtModule(sbtIoPath, "io", sbtIO)
+
+  def addSbtLmCore = addSbtModule(sbtLmPath, "lmCore", libraryManagementCore)
+  def addSbtLmIvy = addSbtModule(sbtLmPath, "lmIvy", libraryManagementIvy)
+  def addSbtLmIvyTest = addSbtModule(sbtLmPath, "lmIvy", libraryManagementIvy, Some(Test))
+
+  def addSbtCompilerInterface = addSbtModule(sbtZincPath, "compilerInterfaceJVM", compilerInterface)
+  def addSbtCompilerClasspath = addSbtModule(sbtZincPath, "zincClasspathJVM2_12", compilerClasspath)
+  def addSbtCompilerApiInfo = addSbtModule(sbtZincPath, "zincApiInfoJVM2_12", compilerApiInfo)
+  def addSbtCompilerBridge = addSbtModule(sbtZincPath, "compilerBridgeJVM2_12", compilerBridge)
+  def addSbtZinc = addSbtModule(sbtZincPath, "zincJVM2_12", zinc)
+  def addSbtZincCompile = addSbtModule(sbtZincPath, "zincCompileJVM2_12", zincCompile)
+  def addSbtZincCompileCore = addSbtModule(sbtZincPath, "zincCompileCoreJVM2_12", zincCompileCore)
+
+  val lmCoursierShaded = "io.get-coursier" %% "lm-coursier-shaded" % "2.0.8"
+
+  def sjsonNew(n: String) =
+    Def.setting("com.eed3si9n" %% n % "0.9.1") // contrabandSjsonNewVersion.value
+  val sjsonNewScalaJson = sjsonNew("sjson-new-scalajson")
+  val sjsonNewMurmurhash = sjsonNew("sjson-new-murmurhash")
+
+  // JLine 3 version must be coordinated together with JAnsi version
+  // and the JLine 2 fork version, which uses the same JAnsi
+  val jline = "org.scala-sbt.jline" % "jline" % "2.14.7-sbt-a1b0ffbb8f64bb820f4f84a0c07a0c0964507493"
+  val jline3Version = "3.19.0"
+  val jline3Terminal = "org.jline" % "jline-terminal" % jline3Version
+  val jline3Jansi = "org.jline" % "jline-terminal-jansi" % jline3Version
+  val jline3JNA = "org.jline" % "jline-terminal-jna" % jline3Version
+  val jline3Reader = "org.jline" % "jline-reader" % jline3Version
+  val jline3Builtins = "org.jline" % "jline-builtins" % jline3Version
+  val jansi = "org.fusesource.jansi" % "jansi" % "2.1.0"
+  val scalatest = "org.scalatest" %% "scalatest" % "3.0.8"
+  val scalacheck = "org.scalacheck" %% "scalacheck" % "1.14.0"
+  val junit = "junit" % "junit" % "4.13.1"
+  val scalaVerify = "com.eed3si9n.verify" %% "verify" % "1.0.0"
+  val templateResolverApi = "org.scala-sbt" % "template-resolver" % "0.1"
+
+  val scalaXml = "org.scala-lang.modules" %% "scala-xml" % "1.3.0"
+  val scalaParsers = "org.scala-lang.modules" %% "scala-parser-combinators" % "1.1.2"
+  val scalaReflect = Def.setting("org.scala-lang" % "scala-reflect" % scalaVersion.value)
+  val scalaPar = "org.scala-lang.modules" %% "scala-parallel-collections" % "1.0.0"
+
+  // specify all of log4j modules to prevent misalignment
+  def log4jModule = (n: String) => "org.apache.logging.log4j" % n % "2.11.2"
+  val log4jApi = log4jModule("log4j-api")
+  val log4jCore = log4jModule("log4j-core")
+  val log4jSlf4jImpl = log4jModule("log4j-slf4j-impl")
+  val log4jModules = Vector(log4jApi, log4jCore, log4jSlf4jImpl)
+
+  val caffeine = "com.github.ben-manes.caffeine" % "caffeine" % "2.8.5"
+
+  val hedgehog = "qa.hedgehog" %% "hedgehog-sbt" % "0.6.1"
+  val disruptor = "com.lmax" % "disruptor" % "3.4.2"
+  val kindProjector = ("org.typelevel" % "kind-projector" % "0.11.3").cross(CrossVersion.full)
 }
diff --git a/project/Docs.scala b/project/Docs.scala
index 7fcfb8541..0e79269c1 100644
--- a/project/Docs.scala
+++ b/project/Docs.scala
@@ -1,50 +1,56 @@
 import sbt._
-import Keys._
+/*
 import StatusPlugin.autoImport._
-import com.typesafe.sbt.{ SbtGhPages, SbtGit, SbtSite, site => sbtsite }
-import SbtSite.{ site, SiteKeys }
-import SbtGhPages.{ ghpages, GhPagesKeys => ghkeys }
-import SbtGit.{ git, GitKeys }
-import sbtsite.SphinxSupport
-import SiteKeys.{ makeSite, siteMappings }
-import Sxr.sxr
-import SiteMap.Entry
+import com.typesafe.sbt.site.SitePlugin.autoImport._
+import com.typesafe.sbt.site.SiteScaladocPlugin.autoImport._
+import com.typesafe.sbt.sbtghpages.GhpagesPlugin.autoImport._
+import com.typesafe.sbt.SbtGit, SbtGit.{ git, GitKeys }
+import Sxr.{ sxr, SxrConf }
+ */
 
 object Docs {
+  def settings: Seq[Setting[_]] = Nil
+
+  /*
   val siteExcludes = Set(".buildinfo", "objects.inv")
   def siteInclude(f: File) = !siteExcludes.contains(f.getName)
 
-  def settings: Seq[Setting[_]] =
-    site.settings ++
-      site.includeScaladoc("api") ++
-      siteIncludeSxr("sxr") ++
-      ghPagesSettings
-
-  def ghPagesSettings = ghpages.settings ++ Seq(
-    git.remoteRepo := "git@github.com:sbt/sbt.github.com.git",
-    localRepoDirectory,
-    ghkeys.synchLocal <<= synchLocalImpl,
-    GitKeys.gitBranch in ghkeys.updatedRepository := Some("master")
+  def settings: Seq[Setting[_]] = Def settings (
+    siteSubdirName in SiteScaladoc := "api",
+    siteIncludeSxr("sxr"),
+    ghPagesSettings
   )
 
-  def localRepoDirectory = ghkeys.repository := {
-    // distinguish between building to update the site or not so that CI jobs 
+  def ghPagesSettings = Def settings (
+    git.remoteRepo := "git@github.com:sbt/sbt.github.com.git",
+    localRepoDirectory,
+    ghpagesSynchLocal := synchLocalImpl.value,
+    ghpagesBranch := "master"
+  )
+
+  def localRepoDirectory = ghpagesRepository := {
+    // distinguish between building to update the site or not so that CI jobs
     //  that don't commit+publish don't leave uncommitted changes in the working directory
     val status = if (isSnapshot.value) "snapshot" else "public"
     Path.userHome / ".sbt" / "ghpages" / status / organization.value / name.value
   }
 
-  def siteIncludeSxr(prefix: String) = Seq(
-    mappings in sxr <<= sxr.map(dir => Path.allSubpaths(dir).toSeq)
-  ) ++ site.addMappingsToSiteDir(mappings in sxr, prefix)
+  def siteIncludeSxr(prefix: String) = Def settings (
+    mappings in sxr := Path.allSubpaths(sxr.value).toSeq,
+    siteSubdirName in SxrConf := prefix,
+    addMappingsToSiteDir(mappings in sxr, siteSubdirName in SxrConf)
+  )
 
-  def synchLocalImpl = (ghkeys.privateMappings, ghkeys.updatedRepository, version, streams) map {
-    (mappings, repo, v, s) =>
-      val versioned = repo / v
-      IO.delete(versioned / "sxr")
-      IO.delete(versioned / "api")
-      val toCopy = for ((file, target) <- mappings if siteInclude(file)) yield (file, versioned / target)
-      IO.copy(toCopy)
-      repo
+  def synchLocalImpl = Def task {
+    val repo = ghpagesUpdatedRepository.value
+    val versioned = repo / version.value
+    IO.delete(versioned / "sxr")
+    IO.delete(versioned / "api")
+    val mappings = ghpagesPrivateMappings.value
+    val toCopy = for ((file, target) <- mappings if siteInclude(file))
+      yield (file, versioned / target)
+    IO.copy(toCopy)
+    repo
   }
+ */
 }
diff --git a/project/Formatting.scala b/project/Formatting.scala
deleted file mode 100644
index 082e9bfda..000000000
--- a/project/Formatting.scala
+++ /dev/null
@@ -1,37 +0,0 @@
-import sbt._
-import sbt.Keys._
-import com.typesafe.sbt.SbtScalariform._
-import ScalariformKeys.{ format => scalariformFormat, preferences => scalariformPreferences }
-
-object Formatting {
-  lazy val BuildConfig = config("build") extend Compile
-  lazy val BuildSbtConfig = config("buildsbt") extend Compile
-
-  val scalariformCheck = taskKey[Unit]("Checks that the existing code is formatted, via git diff")
-
-  lazy val settings: Seq[Setting[_]] = Seq() ++ scalariformSettings ++ prefs
-  lazy val prefs: Seq[Setting[_]] = {
-    import scalariform.formatter.preferences._
-    Seq(
-      scalariformPreferences ~= (_.setPreference(AlignSingleLineCaseStatements, true))
-    )
-  }
-  lazy val sbtFilesSettings: Seq[Setting[_]] = Seq() ++ scalariformSettings ++ prefs ++
-    inConfig(BuildConfig)(configScalariformSettings) ++
-    inConfig(BuildSbtConfig)(configScalariformSettings) ++
-    Seq(
-      scalaSource in BuildConfig := baseDirectory.value / "project",
-      scalaSource in BuildSbtConfig := baseDirectory.value / "project",
-      includeFilter in (BuildConfig, scalariformFormat) := ("*.scala": FileFilter),
-      includeFilter in (BuildSbtConfig, scalariformFormat) := ("*.sbt": FileFilter),
-      scalariformFormat in Compile := {
-        val x = (scalariformFormat in BuildSbtConfig).value
-        val y = (scalariformFormat in BuildConfig).value
-        (scalariformFormat in Compile).value
-      },
-      scalariformCheck := {
-        val diff = "git diff".!!
-        if (diff.nonEmpty) sys.error("Working directory is dirty!\n" + diff)
-      }
-    )
-}
diff --git a/project/HouseRulesPlugin.scala b/project/HouseRulesPlugin.scala
new file mode 100644
index 000000000..42d1c2e6d
--- /dev/null
+++ b/project/HouseRulesPlugin.scala
@@ -0,0 +1,48 @@
+import sbt._
+import Keys._
+
+object HouseRulesPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override def projectSettings: Seq[Def.Setting[_]] = baseSettings
+
+  lazy val baseSettings: Seq[Def.Setting[_]] = Seq(
+    scalacOptions ++= Seq("-encoding", "utf8"),
+    scalacOptions ++= Seq("-deprecation", "-feature", "-unchecked", "-Xlint"),
+    scalacOptions += "-language:higherKinds",
+    scalacOptions += "-language:implicitConversions",
+    scalacOptions ++= "-Xfuture".ifScala213OrMinus.value.toList,
+    scalacOptions += "-Xlint",
+    scalacOptions ++= "-Xfatal-warnings"
+      .ifScala(v => {
+        sys.props.get("sbt.build.fatal") match {
+          case Some(_) => java.lang.Boolean.getBoolean("sbt.build.fatal")
+          case _       => v == 12
+        }
+      })
+      .value
+      .toList,
+    scalacOptions ++= "-Yinline-warnings".ifScala211OrMinus.value.toList,
+    scalacOptions ++= "-Yno-adapted-args".ifScala212OrMinus.value.toList,
+    scalacOptions += "-Ywarn-dead-code",
+    scalacOptions += "-Ywarn-numeric-widen",
+    scalacOptions += "-Ywarn-value-discard",
+    scalacOptions ++= "-Ywarn-unused-import".ifScala(v => 11 <= v && v <= 12).value.toList
+  ) ++ Seq(Compile, Test).flatMap(
+    c => scalacOptions in (c, console) --= Seq("-Ywarn-unused-import", "-Xlint")
+  )
+
+  private def scalaPartV = Def setting (CrossVersion partialVersion scalaVersion.value)
+
+  private implicit final class AnyWithIfScala[A](val __x: A) {
+    def ifScala(p: Long => Boolean) =
+      Def setting (scalaPartV.value collect { case (2, y) if p(y) => __x })
+    def ifScalaLte(v: Long) = ifScala(_ <= v)
+    def ifScalaGte(v: Long) = ifScala(_ >= v)
+    def ifScala211OrMinus = ifScalaLte(11)
+    def ifScala211OrPlus = ifScalaGte(11)
+    def ifScala212OrMinus = ifScalaLte(12)
+    def ifScala213OrMinus = ifScalaLte(13)
+  }
+}
diff --git a/project/NightlyPlugin.scala b/project/NightlyPlugin.scala
index 5ab480cf2..38979f0f9 100644
--- a/project/NightlyPlugin.scala
+++ b/project/NightlyPlugin.scala
@@ -3,43 +3,31 @@ import Keys._
 import Dependencies._
 
 object NightlyPlugin extends AutoPlugin {
-  import autoImport._
-
   override def trigger = allRequirements
   override def requires = plugins.JvmPlugin
-  object autoImport {
-    lazy val includeTestDependencies = SettingKey[Boolean]("includeTestDependencies", "Doesn't declare test dependencies.")
 
-    def testDependencies = libraryDependencies <++= includeTestDependencies { incl =>
-      if (incl) Seq(
-        scalaCheck % Test,
-        specs2 % Test,
-        junit % Test
-      )
+  object autoImport {
+    val includeTestDependencies = settingKey[Boolean]("Doesn't declare test dependencies.")
+
+    def testDependencies = libraryDependencies ++= (
+      if (includeTestDependencies.value)
+        Seq(
+          scalacheck % Test,
+          junit % Test,
+          scalatest % Test,
+          scalaVerify % Test,
+          hedgehog % Test
+        )
       else Seq()
-    }
+    )
   }
+  import autoImport._
 
   override def buildSettings: Seq[Setting[_]] = Seq(
-    // Avoid 2.12.x nightlies
-    // Avoid 2.9.x precompiled
-    // Avoid 2.8.x precompiled
-    includeTestDependencies := {
-      val v = scalaVersion.value
-      v.startsWith("2.10.") || v.startsWith("2.11.")
-    }
+    includeTestDependencies := true
   )
 
   override def projectSettings: Seq[Setting[_]] = Seq(
-    crossVersion in update := {
-      scalaVersion.value match {
-        case sv if sv startsWith "2.8." => crossVersion.value
-        case sv if sv startsWith "2.9." => crossVersion.value
-        case sv if sv startsWith "2.10." => crossVersion.value
-        case sv if sv startsWith "2.11." => CrossVersion.full
-        case sv if sv startsWith "2.12." => CrossVersion.full
-      }
-    },
-    resolvers += Resolver.typesafeIvyRepo("releases")
+    resolvers += Resolver.typesafeIvyRepo("releases").withName("typesafe-alt-project-releases")
   )
 }
diff --git a/project/PublishBinPlugin.scala b/project/PublishBinPlugin.scala
index e999a94fe..804f6461a 100644
--- a/project/PublishBinPlugin.scala
+++ b/project/PublishBinPlugin.scala
@@ -1,22 +1,67 @@
-import sbt._, Keys._
+package sbt
+
+import java.nio.charset.StandardCharsets.UTF_8
+import java.nio.file.{ FileAlreadyExistsException, Files }
+
+import org.apache.ivy.core.module.id.ModuleRevisionId
+import sbt.Keys._
+import sbt.internal.librarymanagement.{ IvySbt, IvyXml }
 
 /** This local plugin provides ways of publishing just the binary jar. */
 object PublishBinPlugin extends AutoPlugin {
-  override def requires = plugins.JvmPlugin
-  override def trigger  = allRequirements
+  override def trigger = allRequirements
 
   object autoImport {
-    val publishLocalBin       = taskKey[Unit]("")
+    val publishLocalBin = taskKey[Unit]("")
     val publishLocalBinConfig = taskKey[PublishConfiguration]("")
   }
-
   import autoImport._
 
-  override def projectSettings = Def settings (
-    publishLocalBin       := Classpaths.publishTask(publishLocalBinConfig, deliverLocal).value,
+  private val dummyDoc = taskKey[File]("").withRank(Int.MaxValue)
+  override val globalSettings = Seq(publishLocalBin := (()))
+
+  override val projectSettings: Seq[Def.Setting[_]] = Def settings (
+    publishLocalBin := Classpaths.publishTask(publishLocalBinConfig).value,
     publishLocalBinConfig := Classpaths.publishConfig(
-      (packagedArtifacts in publishLocalBin).value, Some(deliverLocal.value),
-      (checksums in publishLocalBin).value, logging = ivyLoggingLevel.value, overwrite = isSnapshot.value),
-    packagedArtifacts in publishLocalBin := Classpaths.packaged(Seq(packageBin in Compile)).value
+      false, // publishMavenStyle.value,
+      Classpaths.deliverPattern(crossTarget.value),
+      if (isSnapshot.value) "integration" else "release",
+      ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
+      (packagedArtifacts in publishLocalBin).value.toVector,
+      (checksums in publishLocalBin).value.toVector,
+      logging = ivyLoggingLevel.value,
+      overwrite = isSnapshot.value
+    ),
+    publishLocalBinConfig := publishLocalBinConfig
+      .dependsOn(
+        // Copied from sbt.internal.
+        Def.taskDyn {
+          val doGen = useCoursier.value
+          if (doGen)
+            Def.task {
+              val currentProject = {
+                val proj = csrProject.value
+                val publications = csrPublications.value
+                proj.withPublications(publications)
+              }
+              IvyXml.writeFiles(currentProject, None, ivySbt.value, streams.value.log)
+            } else
+            Def.task(())
+        }
+      )
+      .value,
+    dummyDoc := {
+      val dummyFile = streams.value.cacheDirectory / "doc.jar"
+      try {
+        Files.createDirectories(dummyFile.toPath.getParent)
+        Files.createFile(dummyFile.toPath)
+      } catch { case _: FileAlreadyExistsException => }
+      dummyFile
+    },
+    dummyDoc / packagedArtifact := (Compile / packageDoc / artifact).value -> dummyDoc.value,
+    packagedArtifacts in publishLocalBin :=
+      Classpaths
+        .packaged(Seq(packageBin in Compile, packageSrc in Compile, makePom, dummyDoc))
+        .value
   )
 }
diff --git a/project/Release.scala b/project/Release.scala
deleted file mode 100644
index d53cc1875..000000000
--- a/project/Release.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-import sbt._
-import Keys._
-import com.typesafe.sbt.JavaVersionCheckPlugin.autoImport._
-import _root_.bintray.BintrayPlugin.autoImport._
-import _root_.bintray.InternalBintrayKeys._
-
-object Release {
-  lazy val launcherRemotePath = SettingKey[String]("launcher-remote-path")
-  lazy val deployLauncher = TaskKey[Unit]("deploy-launcher", "Upload the launcher to its traditional location for compatibility with existing scripts.")
-
-  def launcherSettings(launcher: TaskKey[File]): Seq[Setting[_]] = Seq(
-    launcherRemotePath := {
-      val organizationPath = organization.value.replaceAll("""\.""", "/")
-      s"$organizationPath/${moduleName.value}/${version.value}/${moduleName.value}.jar"
-    },
-    deployLauncher := {
-      val repo = bintrayRepo.value
-      repo.upload(bintrayPackage.value, version.value, launcherRemotePath.value, launcher.value, sLog.value)
-    }
-  )
-
-  def javaVersionCheckSettings = Seq(
-    javaVersionPrefix in javaVersionCheck := Some("1.8")
-  )
-}
diff --git a/project/SbtLauncherPlugin.scala b/project/SbtLauncherPlugin.scala
index 7cfde5983..0c24d2de5 100644
--- a/project/SbtLauncherPlugin.scala
+++ b/project/SbtLauncherPlugin.scala
@@ -1,6 +1,6 @@
+import sbt.Keys._
 import sbt._
-import Keys._
-
+import sbt.io.CopyOptions
 
 object SbtLauncherPlugin extends AutoPlugin {
   override def requires = plugins.IvyPlugin
@@ -8,7 +8,8 @@ object SbtLauncherPlugin extends AutoPlugin {
   object autoImport {
     val SbtLaunchConfiguration = config("sbt-launch")
     val sbtLaunchJar = taskKey[File]("constructs an sbt-launch.jar for this version of sbt.")
-    val rawSbtLaunchJar = taskKey[File]("The released version of the sbt-launcher we use to bundle this application.")
+    val rawSbtLaunchJar =
+      taskKey[File]("The released version of the sbt-launcher we use to bundle this application.")
   }
   import autoImport._
 
@@ -18,30 +19,35 @@ object SbtLauncherPlugin extends AutoPlugin {
     rawSbtLaunchJar := {
       Classpaths.managedJars(SbtLaunchConfiguration, Set("jar"), update.value).headOption match {
         case Some(jar) => jar.data
-        case None => sys.error(s"Could not resolve sbt launcher!, dependencies := ${libraryDependencies.value}")
+        case None =>
+          sys.error(
+            s"Could not resolve sbt launcher!, dependencies := ${libraryDependencies.value}"
+          )
       }
     },
     sbtLaunchJar := {
       val propFiles = (resources in Compile).value
       val propFileLocations =
-         for(file <- propFiles; if file.getName != "resources") yield {
-           if(file.getName == "sbt.boot.properties") "sbt/sbt.boot.properties" -> file
-           else file.getName -> file
-         }
+        for (file <- propFiles; if file.getName != "resources") yield {
+          if (file.getName == "sbt.boot.properties") "sbt/sbt.boot.properties" -> file
+          else file.getName -> file
+        }
       // TODO - We need to inject the appropriate boot.properties file for this version of sbt.
       rebundle(rawSbtLaunchJar.value, propFileLocations.toMap, target.value / "sbt-launch.jar")
     }
   )
 
-
-
   def rebundle(jar: File, overrides: Map[String, File], target: File): File = {
     // TODO - Check if we should rebuild the jar or not....
     IO.withTemporaryDirectory { dir =>
       IO.unzip(jar, dir)
-      IO.copy(overrides.map({ case (n, f) => (f, dir / n)}), overwrite = true)
+      IO.copy(overrides.map({ case (n, f) => (f, dir / n) }), CopyOptions().withOverwrite(true))
       // TODO - is the ok for creating a jar?
-      IO.zip((dir.*** --- dir) pair relativeTo(dir), target)
+      val rebase: File => Seq[(File, String)] = {
+        val path = dir.toPath
+        f => if (f != dir) f -> path.relativize(f.toPath).toString :: Nil else Nil
+      }
+      IO.zip(dir.allPaths.get().flatMap(rebase), target)
     }
     target
   }
diff --git a/project/Scripted.scala b/project/Scripted.scala
index 20d8ad7b4..7bc7ccb06 100644
--- a/project/Scripted.scala
+++ b/project/Scripted.scala
@@ -1,110 +1,165 @@
+package local
+
+import java.lang.reflect.InvocationTargetException
+
 import sbt._
-import Keys._
-import Def.Initialize
+import sbt.internal.inc.ScalaInstance
+import sbt.internal.inc.classpath.{ ClasspathUtilities, FilteredLoader }
 
-import scala.language.reflectiveCalls
-
-object ScriptedPlugin extends sbt.AutoPlugin {
+object LocalScriptedPlugin extends AutoPlugin {
   override def requires = plugins.JvmPlugin
-  object autoImport extends ScriptedKeys {
-    def scriptedPath = file("scripted")
-  }
 
-  import autoImport._
-  import Scripted._
-  override def projectSettings = Seq(
-    scriptedBufferLog := true,
-    scriptedPrescripted := { _ => }
-  )
+  object autoImport extends ScriptedKeys
 }
 
 trait ScriptedKeys {
-  lazy val publishAll = TaskKey[Unit]("publish-all")
-  lazy val publishLocalBinAll = taskKey[Unit]("")
-  lazy val scripted = InputKey[Unit]("scripted")
-  lazy val scriptedUnpublished = InputKey[Unit]("scripted-unpublished", "Execute scripted without publishing SBT first. Saves you some time when only your test has changed.")
-  lazy val scriptedSource = SettingKey[File]("scripted-source")
-  lazy val scriptedPrescripted = TaskKey[File => Unit]("scripted-prescripted")
-  lazy val scriptedBufferLog = SettingKey[Boolean]("scripted-buffer-log")
-  lazy val scriptedLaunchOpts = SettingKey[Seq[String]]("scripted-launch-opts", "options to pass to jvm launching scripted tasks")
+  val publishLocalBinAll = taskKey[Unit]("")
+  val scriptedUnpublished = inputKey[Unit](
+    "Execute scripted without publishing sbt first. " +
+      "Saves you some time when only your test has changed"
+  )
+  val scriptedSource = settingKey[File]("")
+  val scriptedPrescripted = taskKey[File => Unit]("")
 }
 
 object Scripted {
-  lazy val MavenResolverPluginTest = config("mavenResolverPluginTest") extend Compile
-  lazy val RepoOverrideTest = config("repoOverrideTest") extend Compile
+  // This is to workaround https://github.com/sbt/io/issues/110
+  sys.props.put("jna.nosys", "true")
+
+  val RepoOverrideTest = config("repoOverrideTest") extend Compile
 
   import sbt.complete._
-  import DefaultParsers._
+
   // Paging, 1-index based.
-  case class ScriptedTestPage(page: Int, total: Int)
-  def scriptedParser(scriptedBase: File): Parser[Seq[String]] =
-    {
-      val scriptedFiles: NameFilter = ("test": NameFilter) | "pending"
-      val pairs = (scriptedBase * AllPassFilter * AllPassFilter * scriptedFiles).get map { (f: File) =>
+  final case class ScriptedTestPage(page: Int, total: Int)
+
+  // FIXME: Duplicated with ScriptedPlugin.scriptedParser, this can be
+  // avoided once we upgrade build.properties to 0.13.14
+  def scriptedParser(scriptedBase: File): Parser[Seq[String]] = {
+    import DefaultParsers._
+
+    val scriptedFiles: NameFilter = ("test": NameFilter) | "pending"
+    val pairs = (scriptedBase * AllPassFilter * AllPassFilter * scriptedFiles).get map {
+      (f: File) =>
         val p = f.getParentFile
         (p.getParentFile.getName, p.getName)
-      }
-      val pairMap = pairs.groupBy(_._1).mapValues(_.map(_._2).toSet);
+    }
+    val pairMap = pairs.groupBy(_._1).mapValues(_.map(_._2).toSet)
 
-      val id = charClass(c => !c.isWhitespace && c != '/').+.string
-      val groupP = token(id.examples(pairMap.keySet.toSet)) <~ token('/')
+    val id = charClass(c => !c.isWhitespace && c != '/').+.string
+    val groupP = token(id.examples(pairMap.keySet)) <~ token('/')
 
-      // A parser for page definitions
-      val pageP: Parser[ScriptedTestPage] = ("*" ~ NatBasic ~ "of" ~ NatBasic) map {
-        case _ ~ page ~ _ ~ total => ScriptedTestPage(page, total)
-      }
-      // Grabs the filenames from a given test group in the current page definition.
-      def pagedFilenames(group: String, page: ScriptedTestPage): Seq[String] = {
-        val files = pairMap(group).toSeq.sortBy(_.toLowerCase)
-        val pageSize = files.size / page.total
-        // The last page may loose some values, so we explicitly keep them
-        val dropped = files.drop(pageSize * (page.page - 1))
-        if (page.page == page.total) dropped
-        else dropped.take(pageSize)
-      }
-      def nameP(group: String) = {
-        token("*".id | id.examples(pairMap(group)))
-      }
-      val PagedIds: Parser[Seq[String]] =
-        for {
-          group <- groupP
-          page <- pageP
-          files = pagedFilenames(group, page)
-          // TODO -  Fail the parser if we don't have enough files for the given page size
-          //if !files.isEmpty
-        } yield files map (f => group + '/' + f)
-
-      val testID = (for (group <- groupP; name <- nameP(group)) yield (group, name))
-      val testIdAsGroup = matched(testID) map (test => Seq(test))
-      //(token(Space) ~> matched(testID)).*
-      (token(Space) ~> (PagedIds | testIdAsGroup)).* map (_.flatten)
+    // A parser for page definitions
+    val pageNumber = (NatBasic & not('0', "zero page number")).flatMap { i =>
+      if (i <= pairs.size) Parser.success(i)
+      else Parser.failure(s"$i exceeds the number of tests (${pairs.size})")
+    }
+    val pageP: Parser[ScriptedTestPage] = ("*" ~> pageNumber ~ ("of" ~> pageNumber)) flatMap {
+      case (page, total) if page <= total => success(ScriptedTestPage(page, total))
+      case (page, total)                  => failure(s"Page $page was greater than $total")
     }
 
-  // Interface to cross class loader
-  type SbtScriptedRunner = {
-    def run(resourceBaseDirectory: File, bufferLog: Boolean, tests: Array[String], bootProperties: File,
-      launchOpts: Array[String], prescripted: java.util.List[File]): Unit
+    // Grabs the filenames from a given test group in the current page definition.
+    def pagedFilenames(group: String, page: ScriptedTestPage): Seq[String] = {
+      val files = pairMap.get(group).toSeq.flatten.sortBy(_.toLowerCase)
+      val pageSize = if (page.total == 0) files.size else files.size / page.total
+      // The last page may loose some values, so we explicitly keep them
+      val dropped = files.drop(pageSize * (page.page - 1))
+      if (page.page == page.total) dropped
+      else dropped.take(pageSize)
+    }
+
+    def nameP(group: String) = {
+      token("*".id | id.examples(pairMap.getOrElse(group, Set.empty[String])))
+    }
+
+    val PagedIds: Parser[Seq[String]] =
+      for {
+        group <- groupP
+        page <- pageP
+        files = pagedFilenames(group, page)
+        // TODO -  Fail the parser if we don't have enough files for the given page size
+        //if !files.isEmpty
+      } yield files map (f => s"$group/$f")
+
+    val testID = (for (group <- groupP; name <- nameP(group)) yield (group, name))
+    val testIdAsGroup = matched(testID) map (test => Seq(test))
+
+    //(token(Space) ~> matched(testID)).*
+    (token(Space) ~> (PagedIds | testIdAsGroup)).* map (_.flatten)
   }
 
-  def doScripted(launcher: File, scriptedSbtClasspath: Seq[Attributed[File]],
-    scriptedSbtInstance: ScalaInstance, sourcePath: File, bufferLog: Boolean,
-    args: Seq[String], prescripted: File => Unit, launchOpts: Seq[String]): Unit = {
-    System.err.println(s"About to run tests: ${args.mkString("\n * ", "\n * ", "\n")}")
-    val noJLine = new classpath.FilteredLoader(scriptedSbtInstance.loader, "jline." :: Nil)
-    val loader = classpath.ClasspathUtilities.toLoader(scriptedSbtClasspath.files, noJLine)
-    val bridgeClass = Class.forName("sbt.test.ScriptedRunner", true, loader)
-    val bridge = bridgeClass.newInstance.asInstanceOf[SbtScriptedRunner]
+  def doScripted(
+      scriptedSbtInstance: ScalaInstance,
+      sourcePath: File,
+      bufferLog: Boolean,
+      args: Seq[String],
+      prescripted: File => Unit,
+      launchOpts: Seq[String],
+      scalaVersion: String,
+      sbtVersion: String,
+      classpath: Seq[File],
+      logger: Logger
+  ): Unit = {
+    logger.info(s"About to run tests: ${args.mkString("\n * ", "\n * ", "\n")}")
+    logger.info("")
+
+    // Force Log4J to not use a thread context classloader otherwise it throws a CCE
+    sys.props(org.apache.logging.log4j.util.LoaderUtil.IGNORE_TCCL_PROPERTY) = "true"
+
+    val noJLine = new FilteredLoader(scriptedSbtInstance.loader, "jline." :: Nil)
+    val loader = ClasspathUtilities.toLoader(classpath, noJLine)
+    val bridgeClass = Class.forName("sbt.scriptedtest.ScriptedRunner", true, loader)
+
+    // Interface to cross class loader
+    type SbtScriptedRunner = {
+      def runInParallel(
+          resourceBaseDirectory: File,
+          bufferLog: Boolean,
+          tests: Array[String],
+          launchOpts: Array[String],
+          prescripted: java.util.List[File],
+          scalaVersion: String,
+          sbtVersion: String,
+          classpath: Array[File],
+          instances: Int
+      ): Unit
+    }
+
+    val initLoader = Thread.currentThread.getContextClassLoader
     try {
-      // Using java.util.List to encode File => Unit.
-      val callback = new java.util.AbstractList[File] {
-        override def add(x: File): Boolean = {
-          prescripted(x)
-          false
+      Thread.currentThread.setContextClassLoader(loader)
+      val bridge =
+        bridgeClass.getDeclaredConstructor().newInstance().asInstanceOf[SbtScriptedRunner]
+      try {
+        // Using java.util.List to encode File => Unit.
+        val callback = new java.util.AbstractList[File] {
+          override def add(x: File): Boolean = { prescripted(x); false }
+          def get(x: Int): sbt.File = ???
+          def size(): Int = 0
         }
-        def get(x: Int): sbt.File = ???
-        def size(): Int = 0
-      }
-      bridge.run(sourcePath, bufferLog, args.toArray, launcher, launchOpts.toArray, callback)
-    } catch { case ite: java.lang.reflect.InvocationTargetException => throw ite.getCause }
+        val instances: Int = (System.getProperty("sbt.scripted.parallel.instances") match {
+          case null => 1
+          case i    => scala.util.Try(i.toInt).getOrElse(1)
+        }) match {
+          case i if i > 0 => i
+          case _          => 1
+        }
+        import scala.language.reflectiveCalls
+        bridge.runInParallel(
+          sourcePath,
+          bufferLog,
+          args.toArray,
+          launchOpts.toArray,
+          callback,
+          scalaVersion,
+          sbtVersion,
+          classpath.toArray,
+          instances
+        )
+      } catch { case ite: InvocationTargetException => throw ite.getCause }
+    } finally {
+      Thread.currentThread.setContextClassLoader(initLoader)
+    }
   }
 }
diff --git a/project/SiteMap.scala b/project/SiteMap.scala
deleted file mode 100644
index 4084e203d..000000000
--- a/project/SiteMap.scala
+++ /dev/null
@@ -1,90 +0,0 @@
-import sbt._
-
-object SiteMap {
-  // represents the configurable aspects of a sitemap entry
-  final case class Entry(changeFreq: String, priority: Double) {
-    assert(priority >= 0.0 && priority <= 1.0, s"Priority must be between 0.0 and 1.0:, was $priority")
-  }
-  def generate(repoBase: File, remoteBase: URI, gzip: Boolean, entry: (File, String) => Option[Entry], log: Logger): (File, Seq[File]) =
-    {
-      def relativize(files: PathFinder): Seq[(File, String)] = files pair relativeTo(repoBase)
-      def entries(files: PathFinder) =
-        relativize(files) flatMap {
-          case (f, path) =>
-            entry(f, path).toList map { e =>
-              entryXML(e, f, path)
-            }
-        }
-      def entriesXML(entries: Seq[xml.Node]): xml.Elem =
-        {
-          assert(entries.size <= 50000, "A site map cannot contain more than 50,000 entries.")
-          <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-            { entries }
-          </urlset>
-        }
-
-      def entryXML(e: Entry, f: File, relPath: String) =
-        <url>
-          <loc>{ remoteBase.resolve(relPath).toString }</loc>
-          <lastmod>{ lastModifiedString(f) }</lastmod>
-          <changefreq>{ e.changeFreq }</changefreq>
-          <priority>{ e.priority.toString }</priority>
-        </url>
-
-      def singleSiteMap(dir: File, files: PathFinder): Option[File] = {
-        val es = entries(files)
-        if (es.isEmpty) None else Some(writeXMLgz(dir / "sitemap.xml", dir / "sitemap.xml.gz", gzip, entriesXML(es)))
-      }
-      def indexEntryXML(sub: File, relPath: String): xml.Elem =
-        <sitemap>
-          <loc>{ remoteBase.resolve(relPath).toString }</loc>
-          <lastmod>{ lastModifiedString(sub) }</lastmod>
-        </sitemap>
-      def indexEntriesXML(entries: Seq[xml.Node]): xml.Elem =
-        <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-          { entries }
-        </sitemapindex>
-      def indexEntries(subs: Seq[File]) =
-        relativize(subs) map { case (f, path) => indexEntryXML(f, path) }
-      def siteMapIndex(dir: File, subs: Seq[File]): File =
-        {
-          val xml = indexEntriesXML(indexEntries(subs))
-          writeXMLgz(dir / "sitemap_index.xml", dir / "sitemap_index.xml.gz", gzip, xml)
-        }
-      def isSymlink(f: File) = f.getCanonicalFile != f.getAbsoluteFile
-
-      val (symlinks, normal) = (repoBase * DirectoryFilter).get.partition(dir => isSymlink(dir))
-      log.debug("Detected symlinks: " + symlinks.mkString("\n\t", "\n\t", ""))
-      val subMaps =
-        singleSiteMap(repoBase, (repoBase * "*.html") +++ (symlinks ** "*.html")).toList ++
-          normal.flatMap(dir =>
-            singleSiteMap(dir, dir ** "*.html").toList
-          )
-      val index = siteMapIndex(repoBase, subMaps)
-      (index, subMaps)
-    }
-  // generates a string suitable for a sitemap file representing the last modified time of the given File
-  private[this] def lastModifiedString(f: File): String =
-    {
-      val formatter = new java.text.SimpleDateFormat("yyyy-MM-dd")
-      formatter.format(new java.util.Date(f.lastModified))
-    }
-  // writes the provided XML node to `output` and then gzips it to `gzipped` if `gzip` is true
-  private[this] def writeXMLgz(output: File, gzipped: File, gzip: Boolean, node: xml.Node): File =
-    {
-      writeXML(output, node)
-      if (gzip) {
-        IO.gzip(output, gzipped)
-        gzipped
-      } else
-        output
-    }
-  private[this] def writeXML(output: File, node: xml.Node): Unit =
-    write(output, new xml.PrettyPrinter(1000, 4).format(node))
-
-  private[this] def write(output: File, xmlString: String): Unit = {
-    // use \n as newline because toString uses PrettyPrinter, which hard codes line endings to be \n
-    IO.write(output, s"<?xml version='1.0' encoding='${IO.utf8.name}'?>\n")
-    IO.append(output, xmlString)
-  }
-}
diff --git a/project/StatusPlugin.scala b/project/StatusPlugin.scala
deleted file mode 100644
index 6c33b3ebf..000000000
--- a/project/StatusPlugin.scala
+++ /dev/null
@@ -1,51 +0,0 @@
-import sbt._
-import Keys._
-
-object StatusPlugin extends AutoPlugin {
-  override def requires = plugins.JvmPlugin
-  override def trigger = allRequirements
-
-  object autoImport {
-    lazy val publishStatus = settingKey[String]("possible values are snapshots or releases.")
-  }
-
-  import autoImport._
-
-  override def buildSettings: Seq[Setting[_]] = Seq(
-    isSnapshot := {
-      val SnapshotQualifier = """(.+)(-.*SNAPSHOT)(.*)""".r
-      val v = version.value
-      v match {
-        case SnapshotQualifier(_, _, _) => true
-        case _                          => false
-      }
-    },
-    publishStatus := {
-      if (isSnapshot.value) "snapshots"
-      else "releases"
-    },
-    commands += stampVersion
-  )
-  def stampVersion = Command.command("stamp-version") { state =>
-    val extracted = Project.extract(state)
-    val status = extracted.get(publishStatus)
-    // Set new version AND lock down the publishStatus to what it was, as
-    // our release regexes no longer support ivy data format, due to other issues.
-    extracted.append(
-      (version in ThisBuild ~= stamp) ::
-        (publishStatus in ThisBuild := status) ::
-        Nil,
-      state)
-  }
-  def stamp(v: String): String =
-    {
-      val Snapshot = "-SNAPSHOT" 
-      if (v endsWith Snapshot) (v stripSuffix Snapshot) + "-" + timestampString(System.currentTimeMillis)
-      else sys.error("Release version '" + v + "' cannot be stamped")
-    }
-  def timestampString(time: Long): String =
-    {
-      val format = new java.text.SimpleDateFormat("yyyyMMdd-HHmmss")
-      format.format(new java.util.Date(time))
-    }
-}
diff --git a/project/Sxr.scala b/project/Sxr.scala
deleted file mode 100644
index 4fcc5fe91..000000000
--- a/project/Sxr.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-import sbt._
-import Keys._
-import Scope.ThisScope
-
-object Sxr {
-  val sxrConf = config("sxr").hide
-  val sxr = TaskKey[File]("sxr")
-  val sourceDirectories = TaskKey[Seq[File]]("sxr-source-directories")
-
-  lazy val settings: Seq[Setting[_]] = inTask(sxr)(inSxrSettings) ++ baseSettings
-
-  def baseSettings = Seq(
-    libraryDependencies += "org.scala-sbt.sxr" % "sxr_2.10" % "0.3.0" % sxrConf.name
-  )
-  def inSxrSettings = Seq(
-    managedClasspath := update.value.matching(configurationFilter(sxrConf.name)).classpath,
-    scalacOptions += "-P:sxr:base-directory:" + sourceDirectories.value.absString,
-    scalacOptions += "-Xplugin:" + managedClasspath.value.files.filter(_.getName.contains("sxr")).absString,
-    scalacOptions += "-Ystop-after:sxr",
-    target := target.in(taskGlobal).value / "browse",
-    sxr in taskGlobal <<= sxrTask
-  )
-  def taskGlobal = ThisScope.copy(task = Global)
-  def sxrTask = (sources, target, scalacOptions, classpathOptions, scalaInstance, fullClasspath, streams) map { (srcs, out, opts, cpOpts, si, cp, s) =>
-    val cache = s.cacheDirectory
-    val outputDir = out.getParentFile / (out.getName + ".sxr")
-    val f = FileFunction.cached(cache / "sxr", FilesInfo.hash) { in =>
-      s.log.info("Generating sxr output in " + outputDir.getAbsolutePath + "...")
-      IO.delete(out)
-      IO.createDirectory(out)
-      val comp = new compiler.RawCompiler(si, cpOpts, s.log)
-      comp(in.toSeq.sorted, cp.files, out, opts)
-      Set(outputDir)
-    }
-    f(srcs.toSet)
-    outputDir
-  }
-}
diff --git a/project/Transform.scala b/project/Transform.scala
index 521397cb1..fde66b01c 100644
--- a/project/Transform.scala
+++ b/project/Transform.scala
@@ -1,90 +1,50 @@
 import sbt._
-import Keys._
+import sbt.Keys._
 
 object Transform {
-  lazy val transformSources = TaskKey[Seq[File]]("transform-sources")
-  lazy val inputSourceDirectories = SettingKey[Seq[File]]("input-source-directories")
-  lazy val inputSourceDirectory = SettingKey[File]("input-source-directory")
-  lazy val inputSources = TaskKey[Seq[File]]("input-sources")
-  lazy val sourceProperties = TaskKey[Map[String, String]]("source-properties")
-
-  lazy val transformResources = TaskKey[Seq[File]]("transform-resources")
-  lazy val inputResourceDirectories = SettingKey[Seq[File]]("input-resource-directories")
-  lazy val inputResourceDirectory = SettingKey[File]("input-resource-directory")
-  lazy val inputResources = TaskKey[Seq[File]]("input-resources")
-  lazy val resourceProperties = TaskKey[Map[String, String]]("resource-properties")
-
-  lazy val conscriptConfigs = TaskKey[Unit]("conscript-configs")
+  private val conscriptConfigs = taskKey[Unit]("")
 
   def conscriptSettings(launch: Reference) = Seq(
-    conscriptConfigs <<= (managedResources in launch in Compile, sourceDirectory in Compile).map { (res, src) =>
-      val source = res.find(_.getName == "sbt.boot.properties") getOrElse sys.error("No managed boot.properties file.")
-      copyConscriptProperties(source, src / "conscript")
-      ()
-    }
-  )
-  def copyConscriptProperties(source: File, conscriptBase: File): Seq[File] =
-    {
+    conscriptConfigs := {
+      val sourceFile = (launch / Compile / managedResources).value
+        .find(_.getName == "sbt.boot.properties")
+        .getOrElse(sys.error("No managed boot.properties file."))
+      val source = IO.readLines(sourceFile)
+      val conscriptBase = (Compile / sourceDirectory).value / "conscript"
       IO.delete(conscriptBase)
       val pairs = Seq(
         "sbt.xMain" -> "xsbt",
         "sbt.ScriptMain" -> "scalas",
-        "sbt.ConsoleMain" -> "screpl"
+        "sbt.ConsoleMain" -> "screpl",
       )
-      for ((main, dir) <- pairs) yield {
-        val file = conscriptBase / dir / "launchconfig"
-        copyPropertiesFile(source, main, file)
-        file
+      for ((main, dir) <- pairs) {
+        val lines = source.map(l => if (l.trim.startsWith("class:")) s"  class: $main" else l)
+        IO.writeLines(conscriptBase / dir / "launchconfig", lines)
       }
-    }
-  def copyPropertiesFile(source: File, newMain: String, target: File): Unit = {
-    def subMain(line: String): String = if (line.trim.startsWith("class:")) "  class: " + newMain else line
-    IO.writeLines(target, IO.readLines(source) map subMain)
-  }
-
-  def crossGenSettings = transSourceSettings ++ Seq(
-    sourceProperties := Map("cross.package0" -> "sbt", "cross.package1" -> "cross")
-  )
-  def transSourceSettings = Seq(
-    inputSourceDirectory := sourceDirectory.value / "input_sources",
-    inputSourceDirectories <<= Seq(inputSourceDirectory).join,
-    inputSources <<= inputSourceDirectories.map(dirs => (dirs ** (-DirectoryFilter)).get),
-    fileMappings in transformSources <<= transformSourceMappings,
-    transformSources <<= (fileMappings in transformSources, sourceProperties) map { (rs, props) =>
-      rs map { case (in, out) => transform(in, out, props) }
     },
-    sourceGenerators <+= transformSources
   )
-  def transformSourceMappings = (inputSources, inputSourceDirectories, sourceManaged) map { (ss, sdirs, sm) =>
-    ((ss --- sdirs) pair (rebase(sdirs, sm) | flat(sm))).toSeq
-  }
-  def configSettings = transResourceSettings ++ Seq(
-    resourceProperties <<= (organization, version, scalaVersion, isSnapshot) map { (org, v, sv, isSnapshot) =>
-      Map("org" -> org, "sbt.version" -> v, "scala.version" -> sv)
-    }
-  )
-  def transResourceSettings = Seq(
-    inputResourceDirectory := sourceDirectory.value / "input_resources",
-    inputResourceDirectories <<= Seq(inputResourceDirectory).join,
-    inputResources <<= inputResourceDirectories.map(dirs => (dirs ** (-DirectoryFilter)).get),
-    fileMappings in transformResources <<= transformResourceMappings,
-    transformResources <<= (fileMappings in transformResources, resourceProperties) map { (rs, props) =>
-      rs map { case (in, out) => transform(in, out, props) }
-    },
-    resourceGenerators <+= transformResources
-  )
-  def transformResourceMappings = (inputResources, inputResourceDirectories, resourceManaged) map { (rs, rdirs, rm) =>
-    ((rs --- rdirs) pair (rebase(rdirs, rm) | flat(rm))).toSeq
-  }
 
-  def transform(in: File, out: File, map: Map[String, String]): File =
-    {
-      def get(key: String): String = map.getOrElse(key, sys.error("No value defined for key '" + key + "'"))
-      val newString = Property.replaceAllIn(IO.read(in), mtch => get(mtch.group(1)))
-      if (Some(newString) != read(out))
-        IO.write(out, newString)
-      out
-    }
-  def read(file: File): Option[String] = try { Some(IO.read(file)) } catch { case _: java.io.IOException => None }
-  lazy val Property = """\$\{\{([\w.-]+)\}\}""".r
+  def configSettings = Seq(
+    resourceGenerators += Def.task {
+      val rdirs = Seq(sourceDirectory.value / "input_resources")
+      val rm = resourceManaged.value
+      val paths = (rdirs ** (-DirectoryFilter)).get --- rdirs
+      val rs = paths.pair(Path.rebase(rdirs, rm) | Path.flat(rm))
+      val props = Map(
+        "org" -> organization.value,
+        "sbt.version" -> version.value,
+        "scala.version" -> scalaVersion.value,
+      )
+      def get(key: String) = props.getOrElse(key, sys.error(s"No value defined for key '$key'"))
+      val Property = """\$\{\{([\w.-]+)\}\}""".r
+      val catcher = scala.util.control.Exception.catching(classOf[java.io.IOException])
+      rs.map {
+        case (in, out) =>
+          val newString = Property.replaceAllIn(IO.read(in), mtch => get(mtch.group(1)))
+          if (Some(newString) != catcher.opt(IO.read(out)))
+            IO.write(out, newString)
+          out
+      }
+    }.taskValue,
+  )
 }
diff --git a/project/Util.scala b/project/Util.scala
index 4d8419e36..8618f206d 100644
--- a/project/Util.scala
+++ b/project/Util.scala
@@ -1,93 +1,107 @@
 import scala.util.control.NonFatal
 import sbt._
 import Keys._
-import StringUtilities.normalize
+
+import sbt.internal.inc.Analysis
 
 object Util {
-  val ExclusiveTest = Tags.Tag("exclusive-test")
-  lazy val componentID = SettingKey[Option[String]]("component-id")
-  lazy val scalaKeywords = TaskKey[Set[String]]("scala-keywords")
-  lazy val generateKeywords = TaskKey[File]("generateKeywords")
+  val version2_13 = settingKey[String]("version number")
+  val ExclusiveTest: Tags.Tag = Tags.Tag("exclusive-test")
+
+  val componentID: SettingKey[Option[String]] = settingKey[Option[String]]("")
+  val scalaKeywords: TaskKey[Set[String]] = taskKey[Set[String]]("")
+  val generateKeywords: TaskKey[File] = taskKey[File]("")
 
   def noPublishSettings: Seq[Setting[_]] = Seq(publish := {})
 
   def crossBuild: Seq[Setting[_]] =
     Seq(
-      crossPaths := (scalaBinaryVersion.value match {
-        case "2.10" => false
-        case _      => true
-      })
+      crossPaths := true
     )
 
-  lazy val javaOnlySettings = Seq[Setting[_]]( /*crossPaths := false, */ compileOrder := CompileOrder.JavaThenScala, unmanagedSourceDirectories in Compile <<= Seq(javaSource in Compile).join)
-  lazy val baseScalacOptions = Seq(
-    scalacOptions ++= Seq("-Xelide-below", "0"),
-    scalacOptions <++= scalaVersion map CrossVersion.partialVersion map {
-      case Some((2, 9)) | Some((2, 8)) => Nil // support 2.9 for some subprojects for the Scala Eclipse IDE
-      case _ => Seq(
-        "-encoding", "utf8",
-        "-deprecation", "-feature", "-unchecked", "-Xlint",
-        "-language:existentials",
-        "-language:higherKinds",
-        "-language:implicitConversions",
-        "-language:postfixOps",
-        "-Xfuture",
-        "-Yinline-warnings",
-        "-Yno-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused",
-        "-Ywarn-unused-import"
-      )
-    },
-    scalacOptions <++= scalaVersion map CrossVersion.partialVersion map {
-      case Some((2, 10)) => Seq("-deprecation", "-Xlint")
-      case _             => Seq()
-    }
+  lazy val javaOnlySettings: Seq[Setting[_]] = Seq(
+    // crossPaths := false,
+    // compileOrder := CompileOrder.JavaThenScala,
+    unmanagedSourceDirectories in Compile := Seq((javaSource in Compile).value)
   )
 
-  def projectComponent = projectID <<= (projectID, componentID) { (pid, cid) =>
-    cid match { case Some(id) => pid extra ("e:component" -> id); case None => pid }
-  }
+  lazy val baseScalacOptions = Seq(
+    scalacOptions ++= Seq(
+      "-Xelide-below",
+      "0",
+      "-language:existentials",
+      "-language:postfixOps",
+      "-Yrangepos",
+      "-Wconf:cat=unused-nowarn:s",
+    ),
+    Compile / doc / scalacOptions -= "-Xlint",
+    Compile / doc / scalacOptions -= "-Xfatal-warnings",
+  )
+
+  def projectComponent: Setting[_] =
+    projectID := (componentID.value match {
+      case Some(id) => projectID.value extra ("e:component" -> id)
+      case None     => projectID.value
+    })
 
   lazy val apiDefinitions = TaskKey[Seq[File]]("api-definitions")
 
-  def generateAPICached(defs: Seq[File], cp: Classpath, out: File, main: Option[String], run: ScalaRun, s: TaskStreams): Seq[File] =
-    {
-      def gen() = generateAPI(defs, cp, out, main, run, s)
-      val f = FileFunction.cached(s.cacheDirectory / "gen-api", FilesInfo.hash) { _ => gen().toSet } // TODO: check if output directory changed
-      f(defs.toSet).toSeq
-    }
-  def generateAPI(defs: Seq[File], cp: Classpath, out: File, main: Option[String], run: ScalaRun, s: TaskStreams): Seq[File] =
-    {
-      IO.delete(out)
-      IO.createDirectory(out)
-      val args = "xsbti.api" :: out.getAbsolutePath :: defs.map(_.getAbsolutePath).toList
-      val mainClass = main getOrElse "No main class defined for datatype generator"
-      toError(run.run(mainClass, cp.files, args, s.log))
-      (out ** "*.java").get
-    }
-  def lastCompilationTime(analysis: sbt.inc.Analysis): Long =
-    {
-      val lastCompilation = analysis.compilations.allCompilations.lastOption
-      lastCompilation.map(_.startTime) getOrElse 0L
-    }
-  def generateVersionFile(version: String, dir: File, s: TaskStreams, analysis: sbt.inc.Analysis): Seq[File] =
-    {
-      import java.util.{ Date, TimeZone }
-      val formatter = new java.text.SimpleDateFormat("yyyyMMdd'T'HHmmss")
-      formatter.setTimeZone(TimeZone.getTimeZone("GMT"))
-      val timestamp = formatter.format(new Date)
-      val content = versionLine(version) + "\ntimestamp=" + timestamp
-      val f = dir / "xsbt.version.properties"
-      if (!f.exists || f.lastModified < lastCompilationTime(analysis) || !containsVersion(f, version)) {
-        s.log.info("Writing version information to " + f + " :\n" + content)
-        IO.write(f, content)
-      }
-      f :: Nil
+  def generateAPICached(
+      defs: Seq[File],
+      cp: Classpath,
+      out: File,
+      main: Option[String],
+      run: ScalaRun,
+      s: TaskStreams
+  ): Seq[File] = {
+    def gen() = generateAPI(defs, cp, out, main, run, s)
+    val f = FileFunction.cached(s.cacheDirectory / "gen-api", FilesInfo.hash) { _ =>
+      gen().toSet
+    } // TODO: check if output directory changed
+    f(defs.toSet).toSeq
+  }
+  def generateAPI(
+      defs: Seq[File],
+      cp: Classpath,
+      out: File,
+      main: Option[String],
+      run: ScalaRun,
+      s: TaskStreams
+  ): Seq[File] = {
+    IO.delete(out)
+    IO.createDirectory(out)
+    val args = "xsbti.api" :: out.getAbsolutePath :: defs.map(_.getAbsolutePath).toList
+    val mainClass = main getOrElse "No main class defined for datatype generator"
+    run.run(mainClass, cp.files, args, s.log).failed foreach (e => sys error e.getMessage)
+    (out ** "*.java").get
+  }
+  def lastCompilationTime(analysis: Analysis): Long = {
+    val lastCompilation = analysis.compilations.allCompilations.lastOption
+    lastCompilation.map(_.getStartTime) getOrElse 0L
+  }
+  def generateVersionFile(
+      version: String,
+      dir: File,
+      s: TaskStreams,
+      analysis: Analysis
+  ): Seq[File] = {
+    import java.util.{ Date, TimeZone }
+    val formatter = new java.text.SimpleDateFormat("yyyyMMdd'T'HHmmss")
+    formatter.setTimeZone(TimeZone.getTimeZone("GMT"))
+    val timestamp = formatter.format(new Date)
+    val content = versionLine(version) + "\ntimestamp=" + timestamp
+    val f = dir / "xsbt.version.properties"
+    // TODO: replace lastModified() with sbt.io.IO.getModifiedTimeOrZero(), once the build
+    // has been upgraded to a version of sbt that includes that call.
+    if (!f.exists || f.lastModified < lastCompilationTime(analysis) || !containsVersion(f, version)) {
+      s.log.info("Writing version information to " + f + " :\n" + content)
+      IO.write(f, content)
     }
+    f :: Nil
+  }
   def versionLine(version: String): String = "version=" + version
-  def containsVersion(propFile: File, version: String): Boolean = IO.read(propFile).contains(versionLine(version))
+  def containsVersion(propFile: File, version: String): Boolean =
+    IO.read(propFile).contains(versionLine(version))
 
   def binID = "compiler-interface-bin"
   def srcID = "compiler-interface-src"
@@ -96,23 +110,24 @@ object Util {
     pomPostProcess := cleanPom _
   )
 
-  def cleanPom(pomNode: scala.xml.Node) =
-    {
-      import scala.xml._
-      def cleanNodes(nodes: Seq[Node]): Seq[Node] = nodes flatMap {
-        case elem @ Elem(prefix, "dependency", attributes, scope, children @ _*) if excludePomDependency(elem) =>
-          NodeSeq.Empty
-        case Elem(prefix, "classifier", attributes, scope, children @ _*) =>
-          NodeSeq.Empty
-        case Elem(prefix, label, attributes, scope, children @ _*) =>
-          val cleanedNodes = cleanNodes(children)
-          Elem(prefix, label, attributes, scope, cleanedNodes.isEmpty, cleanedNodes: _*).theSeq
-        case other => other
-      }
-      cleanNodes(pomNode.theSeq)(0)
+  def cleanPom(pomNode: scala.xml.Node) = {
+    import scala.xml._
+    def cleanNodes(nodes: Seq[Node]): Seq[Node] = nodes flatMap {
+      case elem @ Elem(_, "dependency", _, _, _*) if excludePomDependency(elem) =>
+        NodeSeq.Empty
+      case Elem(_, "classifier", _, _, _*) =>
+        NodeSeq.Empty
+      case Elem(prefix, label, attributes, scope, children @ _*) =>
+        val cleanedNodes = cleanNodes(children)
+        Elem(prefix, label, attributes, scope, cleanedNodes.isEmpty, cleanedNodes: _*).theSeq
+      case other => other
     }
+    cleanNodes(pomNode.theSeq)(0)
+  }
 
-  def excludePomDependency(node: scala.xml.Node) = node \ "artifactId" exists { n => excludePomArtifact(n.text) }
+  def excludePomDependency(node: scala.xml.Node) = node \ "artifactId" exists { n =>
+    excludePomArtifact(n.text)
+  }
 
   def excludePomArtifact(artifactId: String) = (artifactId startsWith "compiler-bridge")
 
@@ -125,30 +140,34 @@ object Util {
     exclusive == 0 || all == 1
   }
 
-  def getScalaKeywords: Set[String] =
-    {
-      val g = new scala.tools.nsc.Global(new scala.tools.nsc.Settings)
-      g.nme.keywords.map(_.toString)
-    }
-  def writeScalaKeywords(base: File, keywords: Set[String]): File =
-    {
-      val init = keywords.map(tn => '"' + tn + '"').mkString("Set(", ", ", ")")
-      val ObjectName = "ScalaKeywords"
-      val PackageName = "sbt"
-      val keywordsSrc =
-        """package %s
-object %s {
-	val values = %s
-}""".format(PackageName, ObjectName, init)
-      val out = base / PackageName.replace('.', '/') / (ObjectName + ".scala")
-      IO.write(out, keywordsSrc)
-      out
-    }
-  def keywordsSettings: Seq[Setting[_]] = inConfig(Compile)(Seq(
-    scalaKeywords := getScalaKeywords,
-    generateKeywords <<= (sourceManaged, scalaKeywords) map writeScalaKeywords,
-    sourceGenerators <+= generateKeywords map (x => Seq(x))
-  ))
+  def getScalaKeywords: Set[String] = {
+    val g = new scala.tools.nsc.Global(new scala.tools.nsc.Settings)
+    g.nme.keywords.map(_.toString)
+  }
+
+  def writeScalaKeywords(base: File, keywords: Set[String]): File = {
+    val init = keywords.map(tn => '"' + tn + '"').mkString("Set(", ", ", ")")
+    val ObjectName = "ScalaKeywords"
+    val PackageName = "sbt.internal.util"
+    val keywordsSrc = s"""
+      |package $PackageName
+      |object $ObjectName {
+      |  val values = $init
+      |}
+    """.trim.stripMargin
+    val out = base / PackageName.replace('.', '/') / s"$ObjectName.scala"
+    IO.write(out, keywordsSrc)
+    out
+  }
+
+  def keywordsSettings: Seq[Setting[_]] =
+    inConfig(Compile)(
+      Seq(
+        scalaKeywords := getScalaKeywords,
+        generateKeywords := writeScalaKeywords(sourceManaged.value, scalaKeywords.value),
+        sourceGenerators += Def.task(Seq(generateKeywords.value)).taskValue
+      )
+    )
 }
 
 object Licensed {
@@ -156,16 +175,28 @@ object Licensed {
   lazy val extractLicenses = TaskKey[Seq[File]]("extract-licenses")
 
   lazy val seeRegex = """\(see (.*?)\)""".r
-  def licensePath(base: File, str: String): File = { val path = base / str; if (path.exists) path else sys.error("Referenced license '" + str + "' not found at " + path) }
-  def seePaths(base: File, noticeString: String): Seq[File] = seeRegex.findAllIn(noticeString).matchData.map(d => licensePath(base, d.group(1))).toList
+  def licensePath(base: File, str: String): File = {
+    val path = base / str;
+    if (path.exists) path else sys.error("Referenced license '" + str + "' not found at " + path)
+  }
+  def seePaths(base: File, noticeString: String): Seq[File] =
+    seeRegex.findAllIn(noticeString).matchData.map(d => licensePath(base, d.group(1))).toList
 
   def settings: Seq[Setting[_]] = Seq(
-    notice <<= baseDirectory(_ / "NOTICE"),
-    unmanagedResources in Compile <++= (notice, extractLicenses) map { _ +: _ },
-    extractLicenses <<= (baseDirectory in ThisBuild, notice, streams) map extractLicenses0
+    notice := (baseDirectory.value / "NOTICE"),
+    unmanagedResources in Compile ++= notice.value +: extractLicenses.value,
+    extractLicenses := extractLicenses0(
+      (baseDirectory in ThisBuild).value,
+      notice.value,
+      streams.value
+    )
   )
   def extractLicenses0(base: File, note: File, s: TaskStreams): Seq[File] =
-    if (!note.exists) Nil else
-      try { seePaths(base, IO.read(note)) }
-      catch { case NonFatal(e) => s.log.warn("Could not read NOTICE"); Nil }
+    if (!note.exists) Nil
+    else
+      try {
+        seePaths(base, IO.read(note))
+      } catch {
+        case NonFatal(_) => s.log.warn("Could not read NOTICE"); Nil
+      }
 }
diff --git a/project/build.properties b/project/build.properties
index 43b8278c6..dbae93bcf 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=0.13.11
+sbt.version=1.4.9
diff --git a/project/datatype.sbt b/project/datatype.sbt
deleted file mode 100644
index 3fd610568..000000000
--- a/project/datatype.sbt
+++ /dev/null
@@ -1 +0,0 @@
-addSbtPlugin("org.scala-sbt" % "sbt-datatype" % "0.2.6")
diff --git a/project/flamegraph_svg.png b/project/flamegraph_svg.png
new file mode 100644
index 000000000..2fc2638c3
Binary files /dev/null and b/project/flamegraph_svg.png differ
diff --git a/project/plugins.sbt b/project/plugins.sbt
index b9b335cf8..6fd8635fe 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,10 +1,13 @@
-scalaVersion := "2.10.6"
+ThisBuild / useCoursier := false
 
-addSbtPlugin("com.eed3si9n" % "sbt-doge" % "0.1.5")
-addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.8")
-addSbtPlugin("com.typesafe.sbt" % "sbt-ghpages" % "0.5.4")
-addSbtPlugin("com.typesafe.sbt" % "sbt-git" % "0.8.5")
-addSbtPlugin("com.typesafe.sbt" % "sbt-javaversioncheck" % "0.1.0")
-addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.3.0") // 1.6.0 is out but is a hard upgrade
-addSbtPlugin("com.typesafe.sbt" % "sbt-site" % "0.8.2")
-addSbtPlugin("me.lessis" % "bintray-sbt" % "0.3.0")
+scalacOptions ++= Seq("-feature", "-language:postfixOps", "-Ywarn-unused:_,-imports")
+
+addSbtPlugin("com.dwijnand" % "sbt-dynver" % "4.0.0")
+addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.1.2")
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.3.0")
+addSbtPlugin("org.scala-sbt" % "sbt-contraband" % "0.5.1")
+addSbtPlugin("de.heikoseeberger" % "sbt-header" % "3.0.2")
+addSbtPlugin("com.lightbend" % "sbt-whitesource" % "0.1.14")
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.9")
+addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.6.1")
+addSbtPlugin("com.swoval" % "sbt-java-format" % "0.3.1")
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/BspCompileResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/BspCompileResult.scala
new file mode 100644
index 000000000..a007c0a3d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/BspCompileResult.scala
@@ -0,0 +1,45 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Compile Response
+ * @param originId An optional request id to know the origin of this report.
+ * @param statusCode A status code for the execution.
+ */
+final class BspCompileResult private (
+  val originId: Option[String],
+  val statusCode: Int) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: BspCompileResult => (this.originId == x.originId) && (this.statusCode == x.statusCode)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.BspCompileResult".##) + originId.##) + statusCode.##)
+  }
+  override def toString: String = {
+    "BspCompileResult(" + originId + ", " + statusCode + ")"
+  }
+  private[this] def copy(originId: Option[String] = originId, statusCode: Int = statusCode): BspCompileResult = {
+    new BspCompileResult(originId, statusCode)
+  }
+  def withOriginId(originId: Option[String]): BspCompileResult = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): BspCompileResult = {
+    copy(originId = Option(originId))
+  }
+  def withStatusCode(statusCode: Int): BspCompileResult = {
+    copy(statusCode = statusCode)
+  }
+}
+object BspCompileResult {
+  
+  def apply(originId: Option[String], statusCode: Int): BspCompileResult = new BspCompileResult(originId, statusCode)
+  def apply(originId: String, statusCode: Int): BspCompileResult = new BspCompileResult(Option(originId), statusCode)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/BspConnectionDetails.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/BspConnectionDetails.scala
new file mode 100644
index 000000000..fdd5b2b7d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/BspConnectionDetails.scala
@@ -0,0 +1,56 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * https://build-server-protocol.github.io/docs/server-discovery.html
+ * @param name The name of the build tool
+ * @param version The version of the build tool
+ * @param bspVersion The bsp version of the build tool
+ * @param languages A collection of languages supported by this BSP server
+ * @param argv Command arguments runnable via system processes to start a BSP server
+ */
+final class BspConnectionDetails private (
+  val name: String,
+  val version: String,
+  val bspVersion: String,
+  val languages: Vector[String],
+  val argv: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: BspConnectionDetails => (this.name == x.name) && (this.version == x.version) && (this.bspVersion == x.bspVersion) && (this.languages == x.languages) && (this.argv == x.argv)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.BspConnectionDetails".##) + name.##) + version.##) + bspVersion.##) + languages.##) + argv.##)
+  }
+  override def toString: String = {
+    "BspConnectionDetails(" + name + ", " + version + ", " + bspVersion + ", " + languages + ", " + argv + ")"
+  }
+  private[this] def copy(name: String = name, version: String = version, bspVersion: String = bspVersion, languages: Vector[String] = languages, argv: Vector[String] = argv): BspConnectionDetails = {
+    new BspConnectionDetails(name, version, bspVersion, languages, argv)
+  }
+  def withName(name: String): BspConnectionDetails = {
+    copy(name = name)
+  }
+  def withVersion(version: String): BspConnectionDetails = {
+    copy(version = version)
+  }
+  def withBspVersion(bspVersion: String): BspConnectionDetails = {
+    copy(bspVersion = bspVersion)
+  }
+  def withLanguages(languages: Vector[String]): BspConnectionDetails = {
+    copy(languages = languages)
+  }
+  def withArgv(argv: Vector[String]): BspConnectionDetails = {
+    copy(argv = argv)
+  }
+}
+object BspConnectionDetails {
+  
+  def apply(name: String, version: String, bspVersion: String, languages: Vector[String], argv: Vector[String]): BspConnectionDetails = new BspConnectionDetails(name, version, bspVersion, languages, argv)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildClientCapabilities.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildClientCapabilities.scala
new file mode 100644
index 000000000..7e6c05f4d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildClientCapabilities.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** @param languageIds The languages that this client supports.
+The ID strings for each language is defined in the LSP.
+The server must never respond with build targets for other
+languages than those that appear in this list. */
+final class BuildClientCapabilities private (
+  val languageIds: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: BuildClientCapabilities => (this.languageIds == x.languageIds)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.BuildClientCapabilities".##) + languageIds.##)
+  }
+  override def toString: String = {
+    "BuildClientCapabilities(" + languageIds + ")"
+  }
+  private[this] def copy(languageIds: Vector[String] = languageIds): BuildClientCapabilities = {
+    new BuildClientCapabilities(languageIds)
+  }
+  def withLanguageIds(languageIds: Vector[String]): BuildClientCapabilities = {
+    copy(languageIds = languageIds)
+  }
+}
+object BuildClientCapabilities {
+  
+  def apply(languageIds: Vector[String]): BuildClientCapabilities = new BuildClientCapabilities(languageIds)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildServerCapabilities.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildServerCapabilities.scala
new file mode 100644
index 000000000..c9a08fee8
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildServerCapabilities.scala
@@ -0,0 +1,71 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param compileProvider The languages the server supports compilation via method buildTarget/compile.
+ * @param testProvider The languages the server supports test execution via method buildTarget/test
+ * @param dependencySourcesProvider The server provides sources for library dependencies
+                                    via method buildTarget/dependencySources
+ * @param canReload Reloading the workspace state through workspace/reload is supported
+ */
+final class BuildServerCapabilities private (
+  val compileProvider: Option[sbt.internal.bsp.CompileProvider],
+  val testProvider: Option[sbt.internal.bsp.TestProvider],
+  val runProvider: Option[sbt.internal.bsp.RunProvider],
+  val dependencySourcesProvider: Option[Boolean],
+  val canReload: Option[Boolean]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: BuildServerCapabilities => (this.compileProvider == x.compileProvider) && (this.testProvider == x.testProvider) && (this.runProvider == x.runProvider) && (this.dependencySourcesProvider == x.dependencySourcesProvider) && (this.canReload == x.canReload)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.BuildServerCapabilities".##) + compileProvider.##) + testProvider.##) + runProvider.##) + dependencySourcesProvider.##) + canReload.##)
+  }
+  override def toString: String = {
+    "BuildServerCapabilities(" + compileProvider + ", " + testProvider + ", " + runProvider + ", " + dependencySourcesProvider + ", " + canReload + ")"
+  }
+  private[this] def copy(compileProvider: Option[sbt.internal.bsp.CompileProvider] = compileProvider, testProvider: Option[sbt.internal.bsp.TestProvider] = testProvider, runProvider: Option[sbt.internal.bsp.RunProvider] = runProvider, dependencySourcesProvider: Option[Boolean] = dependencySourcesProvider, canReload: Option[Boolean] = canReload): BuildServerCapabilities = {
+    new BuildServerCapabilities(compileProvider, testProvider, runProvider, dependencySourcesProvider, canReload)
+  }
+  def withCompileProvider(compileProvider: Option[sbt.internal.bsp.CompileProvider]): BuildServerCapabilities = {
+    copy(compileProvider = compileProvider)
+  }
+  def withCompileProvider(compileProvider: sbt.internal.bsp.CompileProvider): BuildServerCapabilities = {
+    copy(compileProvider = Option(compileProvider))
+  }
+  def withTestProvider(testProvider: Option[sbt.internal.bsp.TestProvider]): BuildServerCapabilities = {
+    copy(testProvider = testProvider)
+  }
+  def withTestProvider(testProvider: sbt.internal.bsp.TestProvider): BuildServerCapabilities = {
+    copy(testProvider = Option(testProvider))
+  }
+  def withRunProvider(runProvider: Option[sbt.internal.bsp.RunProvider]): BuildServerCapabilities = {
+    copy(runProvider = runProvider)
+  }
+  def withRunProvider(runProvider: sbt.internal.bsp.RunProvider): BuildServerCapabilities = {
+    copy(runProvider = Option(runProvider))
+  }
+  def withDependencySourcesProvider(dependencySourcesProvider: Option[Boolean]): BuildServerCapabilities = {
+    copy(dependencySourcesProvider = dependencySourcesProvider)
+  }
+  def withDependencySourcesProvider(dependencySourcesProvider: Boolean): BuildServerCapabilities = {
+    copy(dependencySourcesProvider = Option(dependencySourcesProvider))
+  }
+  def withCanReload(canReload: Option[Boolean]): BuildServerCapabilities = {
+    copy(canReload = canReload)
+  }
+  def withCanReload(canReload: Boolean): BuildServerCapabilities = {
+    copy(canReload = Option(canReload))
+  }
+}
+object BuildServerCapabilities {
+  
+  def apply(compileProvider: Option[sbt.internal.bsp.CompileProvider], testProvider: Option[sbt.internal.bsp.TestProvider], runProvider: Option[sbt.internal.bsp.RunProvider], dependencySourcesProvider: Option[Boolean], canReload: Option[Boolean]): BuildServerCapabilities = new BuildServerCapabilities(compileProvider, testProvider, runProvider, dependencySourcesProvider, canReload)
+  def apply(compileProvider: sbt.internal.bsp.CompileProvider, testProvider: sbt.internal.bsp.TestProvider, runProvider: sbt.internal.bsp.RunProvider, dependencySourcesProvider: Boolean, canReload: Boolean): BuildServerCapabilities = new BuildServerCapabilities(Option(compileProvider), Option(testProvider), Option(runProvider), Option(dependencySourcesProvider), Option(canReload))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTarget.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTarget.scala
new file mode 100644
index 000000000..f7d4f4c2c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTarget.scala
@@ -0,0 +1,102 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Build target
+ * @param id The target’s unique identifier
+ * @param displayName A human readable name for this target.
+                      May be presented in the user interface.
+                      Should be unique if possible.
+                      The id.uri is used if None.
+ * @param baseDirectory The directory where this target belongs to. Multiple build targets are allowed to map
+                        to the same base directory, and a build target is not required to have a base directory.
+                        A base directory does not determine the sources of a target, see buildTarget/sources.
+ * @param tags Free-form string tags to categorize or label this build target.
+               For example, can be used by the client to:
+               - customize how the target should be translated into the client's project model.
+               - group together different but related targets in the user interface.
+               - display icons or colors in the user interface.
+               Pre-defined tags are listed in `BuildTargetTag` but clients and servers
+               are free to define new tags for custom purposes.
+ * @param capabilities The capabilities of this build target.
+ * @param languageIds The set of languages that this target contains.
+                      The ID string for each language is defined in the LSP.
+ * @param dependencies The direct upstream build target dependencies of this build target
+ * @param dataKind Kind of data to expect in the `data` field. If this field is not set, the kind of data is not specified.
+ * @param data Language-specific metadata about this target.
+               See ScalaBuildTarget as an example.
+ */
+final class BuildTarget private (
+  val id: sbt.internal.bsp.BuildTargetIdentifier,
+  val displayName: Option[String],
+  val baseDirectory: Option[java.net.URI],
+  val tags: Vector[String],
+  val capabilities: sbt.internal.bsp.BuildTargetCapabilities,
+  val languageIds: Vector[String],
+  val dependencies: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val dataKind: Option[String],
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: BuildTarget => (this.id == x.id) && (this.displayName == x.displayName) && (this.baseDirectory == x.baseDirectory) && (this.tags == x.tags) && (this.capabilities == x.capabilities) && (this.languageIds == x.languageIds) && (this.dependencies == x.dependencies) && (this.dataKind == x.dataKind) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.BuildTarget".##) + id.##) + displayName.##) + baseDirectory.##) + tags.##) + capabilities.##) + languageIds.##) + dependencies.##) + dataKind.##) + data.##)
+  }
+  override def toString: String = {
+    "BuildTarget(" + id + ", " + displayName + ", " + baseDirectory + ", " + tags + ", " + capabilities + ", " + languageIds + ", " + dependencies + ", " + dataKind + ", " + data + ")"
+  }
+  private[this] def copy(id: sbt.internal.bsp.BuildTargetIdentifier = id, displayName: Option[String] = displayName, baseDirectory: Option[java.net.URI] = baseDirectory, tags: Vector[String] = tags, capabilities: sbt.internal.bsp.BuildTargetCapabilities = capabilities, languageIds: Vector[String] = languageIds, dependencies: Vector[sbt.internal.bsp.BuildTargetIdentifier] = dependencies, dataKind: Option[String] = dataKind, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): BuildTarget = {
+    new BuildTarget(id, displayName, baseDirectory, tags, capabilities, languageIds, dependencies, dataKind, data)
+  }
+  def withId(id: sbt.internal.bsp.BuildTargetIdentifier): BuildTarget = {
+    copy(id = id)
+  }
+  def withDisplayName(displayName: Option[String]): BuildTarget = {
+    copy(displayName = displayName)
+  }
+  def withDisplayName(displayName: String): BuildTarget = {
+    copy(displayName = Option(displayName))
+  }
+  def withBaseDirectory(baseDirectory: Option[java.net.URI]): BuildTarget = {
+    copy(baseDirectory = baseDirectory)
+  }
+  def withBaseDirectory(baseDirectory: java.net.URI): BuildTarget = {
+    copy(baseDirectory = Option(baseDirectory))
+  }
+  def withTags(tags: Vector[String]): BuildTarget = {
+    copy(tags = tags)
+  }
+  def withCapabilities(capabilities: sbt.internal.bsp.BuildTargetCapabilities): BuildTarget = {
+    copy(capabilities = capabilities)
+  }
+  def withLanguageIds(languageIds: Vector[String]): BuildTarget = {
+    copy(languageIds = languageIds)
+  }
+  def withDependencies(dependencies: Vector[sbt.internal.bsp.BuildTargetIdentifier]): BuildTarget = {
+    copy(dependencies = dependencies)
+  }
+  def withDataKind(dataKind: Option[String]): BuildTarget = {
+    copy(dataKind = dataKind)
+  }
+  def withDataKind(dataKind: String): BuildTarget = {
+    copy(dataKind = Option(dataKind))
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): BuildTarget = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): BuildTarget = {
+    copy(data = Option(data))
+  }
+}
+object BuildTarget {
+  
+  def apply(id: sbt.internal.bsp.BuildTargetIdentifier, displayName: Option[String], baseDirectory: Option[java.net.URI], tags: Vector[String], capabilities: sbt.internal.bsp.BuildTargetCapabilities, languageIds: Vector[String], dependencies: Vector[sbt.internal.bsp.BuildTargetIdentifier], dataKind: Option[String], data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): BuildTarget = new BuildTarget(id, displayName, baseDirectory, tags, capabilities, languageIds, dependencies, dataKind, data)
+  def apply(id: sbt.internal.bsp.BuildTargetIdentifier, displayName: String, baseDirectory: java.net.URI, tags: Vector[String], capabilities: sbt.internal.bsp.BuildTargetCapabilities, languageIds: Vector[String], dependencies: Vector[sbt.internal.bsp.BuildTargetIdentifier], dataKind: String, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): BuildTarget = new BuildTarget(id, Option(displayName), Option(baseDirectory), tags, capabilities, languageIds, dependencies, Option(dataKind), Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTargetCapabilities.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTargetCapabilities.scala
new file mode 100644
index 000000000..bc4950db4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTargetCapabilities.scala
@@ -0,0 +1,45 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param canCompile This target can be compiled by the BSP server.
+ * @param canTest This target can be tested by the BSP server.
+ * @param canRun This target can be run by the BSP server.
+ */
+final class BuildTargetCapabilities private (
+  val canCompile: Boolean,
+  val canTest: Boolean,
+  val canRun: Boolean) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: BuildTargetCapabilities => (this.canCompile == x.canCompile) && (this.canTest == x.canTest) && (this.canRun == x.canRun)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.BuildTargetCapabilities".##) + canCompile.##) + canTest.##) + canRun.##)
+  }
+  override def toString: String = {
+    "BuildTargetCapabilities(" + canCompile + ", " + canTest + ", " + canRun + ")"
+  }
+  private[this] def copy(canCompile: Boolean = canCompile, canTest: Boolean = canTest, canRun: Boolean = canRun): BuildTargetCapabilities = {
+    new BuildTargetCapabilities(canCompile, canTest, canRun)
+  }
+  def withCanCompile(canCompile: Boolean): BuildTargetCapabilities = {
+    copy(canCompile = canCompile)
+  }
+  def withCanTest(canTest: Boolean): BuildTargetCapabilities = {
+    copy(canTest = canTest)
+  }
+  def withCanRun(canRun: Boolean): BuildTargetCapabilities = {
+    copy(canRun = canRun)
+  }
+}
+object BuildTargetCapabilities {
+  
+  def apply(canCompile: Boolean, canTest: Boolean, canRun: Boolean): BuildTargetCapabilities = new BuildTargetCapabilities(canCompile, canTest, canRun)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTargetIdentifier.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTargetIdentifier.scala
new file mode 100644
index 000000000..15ed0becc
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/BuildTargetIdentifier.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Build Target Identifier
+ * @param uri The target's Uri
+ */
+final class BuildTargetIdentifier private (
+  val uri: java.net.URI) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: BuildTargetIdentifier => (this.uri == x.uri)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.BuildTargetIdentifier".##) + uri.##)
+  }
+  override def toString: String = {
+    "BuildTargetIdentifier(" + uri + ")"
+  }
+  private[this] def copy(uri: java.net.URI = uri): BuildTargetIdentifier = {
+    new BuildTargetIdentifier(uri)
+  }
+  def withUri(uri: java.net.URI): BuildTargetIdentifier = {
+    copy(uri = uri)
+  }
+}
+object BuildTargetIdentifier {
+  
+  def apply(uri: java.net.URI): BuildTargetIdentifier = new BuildTargetIdentifier(uri)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileParams.scala
new file mode 100644
index 000000000..5d533aaad
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileParams.scala
@@ -0,0 +1,51 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Compile Request
+ * @param targets A sequence of build targets to compile
+ * @param originId An optional unique identifier generated by the client to identify this request.
+                   The server may include this id in triggered notifications or response.
+ * @param arguments Optional arguments to the compilation process
+ */
+final class CompileParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val originId: Option[String],
+  val arguments: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CompileParams => (this.targets == x.targets) && (this.originId == x.originId) && (this.arguments == x.arguments)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.CompileParams".##) + targets.##) + originId.##) + arguments.##)
+  }
+  override def toString: String = {
+    "CompileParams(" + targets + ", " + originId + ", " + arguments + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId, arguments: Vector[String] = arguments): CompileParams = {
+    new CompileParams(targets, originId, arguments)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): CompileParams = {
+    copy(targets = targets)
+  }
+  def withOriginId(originId: Option[String]): CompileParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): CompileParams = {
+    copy(originId = Option(originId))
+  }
+  def withArguments(arguments: Vector[String]): CompileParams = {
+    copy(arguments = arguments)
+  }
+}
+object CompileParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String], arguments: Vector[String]): CompileParams = new CompileParams(targets, originId, arguments)
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String, arguments: Vector[String]): CompileParams = new CompileParams(targets, Option(originId), arguments)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileProvider.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileProvider.scala
new file mode 100644
index 000000000..b0b9455f8
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileProvider.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class CompileProvider private (
+  val languageIds: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CompileProvider => (this.languageIds == x.languageIds)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.CompileProvider".##) + languageIds.##)
+  }
+  override def toString: String = {
+    "CompileProvider(" + languageIds + ")"
+  }
+  private[this] def copy(languageIds: Vector[String] = languageIds): CompileProvider = {
+    new CompileProvider(languageIds)
+  }
+  def withLanguageIds(languageIds: Vector[String]): CompileProvider = {
+    copy(languageIds = languageIds)
+  }
+}
+object CompileProvider {
+  
+  def apply(languageIds: Vector[String]): CompileProvider = new CompileProvider(languageIds)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileReport.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileReport.scala
new file mode 100644
index 000000000..5eb2ac41a
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileReport.scala
@@ -0,0 +1,62 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param target The build target that was compiled
+ * @param originId An optional request id to know the origin of this report
+ * @param errors The total number of reported errors compiling this target.
+ * @param warnings The total number of reported warnings compiling the target.
+ * @param time The total number of milliseconds it took to compile the target.
+ */
+final class CompileReport private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier,
+  val originId: Option[String],
+  val errors: Int,
+  val warnings: Int,
+  val time: Option[Int]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CompileReport => (this.target == x.target) && (this.originId == x.originId) && (this.errors == x.errors) && (this.warnings == x.warnings) && (this.time == x.time)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.CompileReport".##) + target.##) + originId.##) + errors.##) + warnings.##) + time.##)
+  }
+  override def toString: String = {
+    "CompileReport(" + target + ", " + originId + ", " + errors + ", " + warnings + ", " + time + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, originId: Option[String] = originId, errors: Int = errors, warnings: Int = warnings, time: Option[Int] = time): CompileReport = {
+    new CompileReport(target, originId, errors, warnings, time)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): CompileReport = {
+    copy(target = target)
+  }
+  def withOriginId(originId: Option[String]): CompileReport = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): CompileReport = {
+    copy(originId = Option(originId))
+  }
+  def withErrors(errors: Int): CompileReport = {
+    copy(errors = errors)
+  }
+  def withWarnings(warnings: Int): CompileReport = {
+    copy(warnings = warnings)
+  }
+  def withTime(time: Option[Int]): CompileReport = {
+    copy(time = time)
+  }
+  def withTime(time: Int): CompileReport = {
+    copy(time = Option(time))
+  }
+}
+object CompileReport {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, originId: Option[String], errors: Int, warnings: Int, time: Option[Int]): CompileReport = new CompileReport(target, originId, errors, warnings, time)
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, originId: String, errors: Int, warnings: Int, time: Int): CompileReport = new CompileReport(target, Option(originId), errors, warnings, Option(time))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileTask.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileTask.scala
new file mode 100644
index 000000000..cbe6ee205
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/CompileTask.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** Compile Notifications */
+final class CompileTask private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CompileTask => (this.target == x.target)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.CompileTask".##) + target.##)
+  }
+  override def toString: String = {
+    "CompileTask(" + target + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target): CompileTask = {
+    new CompileTask(target)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): CompileTask = {
+    copy(target = target)
+  }
+}
+object CompileTask {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier): CompileTask = new CompileTask(target)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/DebugSessionAddress.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/DebugSessionAddress.scala
new file mode 100644
index 000000000..23db6d9d4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/DebugSessionAddress.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** @param uri The target's Uri */
+final class DebugSessionAddress private (
+  val uri: java.net.URI) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: DebugSessionAddress => (this.uri == x.uri)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.DebugSessionAddress".##) + uri.##)
+  }
+  override def toString: String = {
+    "DebugSessionAddress(" + uri + ")"
+  }
+  private[this] def copy(uri: java.net.URI = uri): DebugSessionAddress = {
+    new DebugSessionAddress(uri)
+  }
+  def withUri(uri: java.net.URI): DebugSessionAddress = {
+    copy(uri = uri)
+  }
+}
+object DebugSessionAddress {
+  
+  def apply(uri: java.net.URI): DebugSessionAddress = new DebugSessionAddress(uri)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/DebugSessionParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/DebugSessionParams.scala
new file mode 100644
index 000000000..a19a814c0
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/DebugSessionParams.scala
@@ -0,0 +1,52 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param targets A sequence of build targets affected by the debugging action.
+ * @param dataKind The kind of data to expect in the `data` field.
+ * @param data A language-agnostic JSON object interpreted by the server.
+ */
+final class DebugSessionParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val dataKind: Option[String],
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: DebugSessionParams => (this.targets == x.targets) && (this.dataKind == x.dataKind) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.DebugSessionParams".##) + targets.##) + dataKind.##) + data.##)
+  }
+  override def toString: String = {
+    "DebugSessionParams(" + targets + ", " + dataKind + ", " + data + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, dataKind: Option[String] = dataKind, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): DebugSessionParams = {
+    new DebugSessionParams(targets, dataKind, data)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): DebugSessionParams = {
+    copy(targets = targets)
+  }
+  def withDataKind(dataKind: Option[String]): DebugSessionParams = {
+    copy(dataKind = dataKind)
+  }
+  def withDataKind(dataKind: String): DebugSessionParams = {
+    copy(dataKind = Option(dataKind))
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): DebugSessionParams = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): DebugSessionParams = {
+    copy(data = Option(data))
+  }
+}
+object DebugSessionParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], dataKind: Option[String], data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): DebugSessionParams = new DebugSessionParams(targets, dataKind, data)
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], dataKind: String, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): DebugSessionParams = new DebugSessionParams(targets, Option(dataKind), Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesItem.scala
new file mode 100644
index 000000000..39ff3ccdc
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesItem.scala
@@ -0,0 +1,42 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** @param sources List of resources containing source files of the target's dependencies.
+Can be source files, jar files, zip files, or directories */
+final class DependencySourcesItem private (
+  val target: Option[sbt.internal.bsp.BuildTargetIdentifier],
+  val sources: Vector[java.net.URI]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: DependencySourcesItem => (this.target == x.target) && (this.sources == x.sources)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.DependencySourcesItem".##) + target.##) + sources.##)
+  }
+  override def toString: String = {
+    "DependencySourcesItem(" + target + ", " + sources + ")"
+  }
+  private[this] def copy(target: Option[sbt.internal.bsp.BuildTargetIdentifier] = target, sources: Vector[java.net.URI] = sources): DependencySourcesItem = {
+    new DependencySourcesItem(target, sources)
+  }
+  def withTarget(target: Option[sbt.internal.bsp.BuildTargetIdentifier]): DependencySourcesItem = {
+    copy(target = target)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): DependencySourcesItem = {
+    copy(target = Option(target))
+  }
+  def withSources(sources: Vector[java.net.URI]): DependencySourcesItem = {
+    copy(sources = sources)
+  }
+}
+object DependencySourcesItem {
+  
+  def apply(target: Option[sbt.internal.bsp.BuildTargetIdentifier], sources: Vector[java.net.URI]): DependencySourcesItem = new DependencySourcesItem(target, sources)
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, sources: Vector[java.net.URI]): DependencySourcesItem = new DependencySourcesItem(Option(target), sources)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesParams.scala
new file mode 100644
index 000000000..fc3ed3be4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesParams.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** Dependency Sources Request */
+final class DependencySourcesParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: DependencySourcesParams => (this.targets == x.targets)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.DependencySourcesParams".##) + targets.##)
+  }
+  override def toString: String = {
+    "DependencySourcesParams(" + targets + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets): DependencySourcesParams = {
+    new DependencySourcesParams(targets)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): DependencySourcesParams = {
+    copy(targets = targets)
+  }
+}
+object DependencySourcesParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): DependencySourcesParams = new DependencySourcesParams(targets)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesResult.scala
new file mode 100644
index 000000000..4ee1fe136
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/DependencySourcesResult.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** Dependency Sources Result */
+final class DependencySourcesResult private (
+  val items: Vector[sbt.internal.bsp.DependencySourcesItem]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: DependencySourcesResult => (this.items == x.items)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.DependencySourcesResult".##) + items.##)
+  }
+  override def toString: String = {
+    "DependencySourcesResult(" + items + ")"
+  }
+  private[this] def copy(items: Vector[sbt.internal.bsp.DependencySourcesItem] = items): DependencySourcesResult = {
+    new DependencySourcesResult(items)
+  }
+  def withItems(items: Vector[sbt.internal.bsp.DependencySourcesItem]): DependencySourcesResult = {
+    copy(items = items)
+  }
+}
+object DependencySourcesResult {
+  
+  def apply(items: Vector[sbt.internal.bsp.DependencySourcesItem]): DependencySourcesResult = new DependencySourcesResult(items)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/Diagnostic.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/Diagnostic.scala
new file mode 100644
index 000000000..a9e2dd10f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/Diagnostic.scala
@@ -0,0 +1,69 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Represents a diagnostic, such as a compiler error or warning.
+ * Diagnostic objects are only valid in the scope of a resource.
+ * @param range The range at which the message applies.
+ * @param severity The diagnostic's severity. Can be omitted. If omitted it is up to the
+                   client to interpret diagnostics as error, warning, info or hint.
+ * @param code The diagnostic's code. Can be omitted.
+ * @param source A human-readable string describing the source of this
+                 diagnostic, e.g. 'typescript' or 'super lint'.
+ * @param message The diagnostic's message.
+ */
+final class Diagnostic private (
+  val range: sbt.internal.bsp.Range,
+  val severity: Option[Long],
+  val code: Option[String],
+  val source: Option[String],
+  val message: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Diagnostic => (this.range == x.range) && (this.severity == x.severity) && (this.code == x.code) && (this.source == x.source) && (this.message == x.message)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.Diagnostic".##) + range.##) + severity.##) + code.##) + source.##) + message.##)
+  }
+  override def toString: String = {
+    "Diagnostic(" + range + ", " + severity + ", " + code + ", " + source + ", " + message + ")"
+  }
+  private[this] def copy(range: sbt.internal.bsp.Range = range, severity: Option[Long] = severity, code: Option[String] = code, source: Option[String] = source, message: String = message): Diagnostic = {
+    new Diagnostic(range, severity, code, source, message)
+  }
+  def withRange(range: sbt.internal.bsp.Range): Diagnostic = {
+    copy(range = range)
+  }
+  def withSeverity(severity: Option[Long]): Diagnostic = {
+    copy(severity = severity)
+  }
+  def withSeverity(severity: Long): Diagnostic = {
+    copy(severity = Option(severity))
+  }
+  def withCode(code: Option[String]): Diagnostic = {
+    copy(code = code)
+  }
+  def withCode(code: String): Diagnostic = {
+    copy(code = Option(code))
+  }
+  def withSource(source: Option[String]): Diagnostic = {
+    copy(source = source)
+  }
+  def withSource(source: String): Diagnostic = {
+    copy(source = Option(source))
+  }
+  def withMessage(message: String): Diagnostic = {
+    copy(message = message)
+  }
+}
+object Diagnostic {
+  
+  def apply(range: sbt.internal.bsp.Range, severity: Option[Long], code: Option[String], source: Option[String], message: String): Diagnostic = new Diagnostic(range, severity, code, source, message)
+  def apply(range: sbt.internal.bsp.Range, severity: Long, code: String, source: String, message: String): Diagnostic = new Diagnostic(range, Option(severity), Option(code), Option(source), message)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/InitializeBuildParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/InitializeBuildParams.scala
new file mode 100644
index 000000000..233153517
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/InitializeBuildParams.scala
@@ -0,0 +1,65 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Initialize Build Request
+ * @param displayName Name of the client
+ * @param version The version of the client
+ * @param bspVersion The BSP version that the client speaks
+ * @param rootUri The rootUri of the workspace
+ * @param capabilities The capabilities of the client
+ * @param data Additional metadata about the client
+ */
+final class InitializeBuildParams private (
+  val displayName: String,
+  val version: String,
+  val bspVersion: String,
+  val rootUri: java.net.URI,
+  val capabilities: sbt.internal.bsp.BuildClientCapabilities,
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: InitializeBuildParams => (this.displayName == x.displayName) && (this.version == x.version) && (this.bspVersion == x.bspVersion) && (this.rootUri == x.rootUri) && (this.capabilities == x.capabilities) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.InitializeBuildParams".##) + displayName.##) + version.##) + bspVersion.##) + rootUri.##) + capabilities.##) + data.##)
+  }
+  override def toString: String = {
+    "InitializeBuildParams(" + displayName + ", " + version + ", " + bspVersion + ", " + rootUri + ", " + capabilities + ", " + data + ")"
+  }
+  private[this] def copy(displayName: String = displayName, version: String = version, bspVersion: String = bspVersion, rootUri: java.net.URI = rootUri, capabilities: sbt.internal.bsp.BuildClientCapabilities = capabilities, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): InitializeBuildParams = {
+    new InitializeBuildParams(displayName, version, bspVersion, rootUri, capabilities, data)
+  }
+  def withDisplayName(displayName: String): InitializeBuildParams = {
+    copy(displayName = displayName)
+  }
+  def withVersion(version: String): InitializeBuildParams = {
+    copy(version = version)
+  }
+  def withBspVersion(bspVersion: String): InitializeBuildParams = {
+    copy(bspVersion = bspVersion)
+  }
+  def withRootUri(rootUri: java.net.URI): InitializeBuildParams = {
+    copy(rootUri = rootUri)
+  }
+  def withCapabilities(capabilities: sbt.internal.bsp.BuildClientCapabilities): InitializeBuildParams = {
+    copy(capabilities = capabilities)
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): InitializeBuildParams = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): InitializeBuildParams = {
+    copy(data = Option(data))
+  }
+}
+object InitializeBuildParams {
+  
+  def apply(displayName: String, version: String, bspVersion: String, rootUri: java.net.URI, capabilities: sbt.internal.bsp.BuildClientCapabilities, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): InitializeBuildParams = new InitializeBuildParams(displayName, version, bspVersion, rootUri, capabilities, data)
+  def apply(displayName: String, version: String, bspVersion: String, rootUri: java.net.URI, capabilities: sbt.internal.bsp.BuildClientCapabilities, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): InitializeBuildParams = new InitializeBuildParams(displayName, version, bspVersion, rootUri, capabilities, Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/InitializeBuildResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/InitializeBuildResult.scala
new file mode 100644
index 000000000..f88df9469
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/InitializeBuildResult.scala
@@ -0,0 +1,59 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param displayName Name of the server
+ * @param version The version of the server
+ * @param bspVersion The BSP version that the server speaks
+ * @param capabilities The capabilities of the build server
+ * @param data Additional metadata about the server
+ */
+final class InitializeBuildResult private (
+  val displayName: String,
+  val version: String,
+  val bspVersion: String,
+  val capabilities: sbt.internal.bsp.BuildServerCapabilities,
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: InitializeBuildResult => (this.displayName == x.displayName) && (this.version == x.version) && (this.bspVersion == x.bspVersion) && (this.capabilities == x.capabilities) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.InitializeBuildResult".##) + displayName.##) + version.##) + bspVersion.##) + capabilities.##) + data.##)
+  }
+  override def toString: String = {
+    "InitializeBuildResult(" + displayName + ", " + version + ", " + bspVersion + ", " + capabilities + ", " + data + ")"
+  }
+  private[this] def copy(displayName: String = displayName, version: String = version, bspVersion: String = bspVersion, capabilities: sbt.internal.bsp.BuildServerCapabilities = capabilities, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): InitializeBuildResult = {
+    new InitializeBuildResult(displayName, version, bspVersion, capabilities, data)
+  }
+  def withDisplayName(displayName: String): InitializeBuildResult = {
+    copy(displayName = displayName)
+  }
+  def withVersion(version: String): InitializeBuildResult = {
+    copy(version = version)
+  }
+  def withBspVersion(bspVersion: String): InitializeBuildResult = {
+    copy(bspVersion = bspVersion)
+  }
+  def withCapabilities(capabilities: sbt.internal.bsp.BuildServerCapabilities): InitializeBuildResult = {
+    copy(capabilities = capabilities)
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): InitializeBuildResult = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): InitializeBuildResult = {
+    copy(data = Option(data))
+  }
+}
+object InitializeBuildResult {
+  
+  def apply(displayName: String, version: String, bspVersion: String, capabilities: sbt.internal.bsp.BuildServerCapabilities, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): InitializeBuildResult = new InitializeBuildResult(displayName, version, bspVersion, capabilities, data)
+  def apply(displayName: String, version: String, bspVersion: String, capabilities: sbt.internal.bsp.BuildServerCapabilities, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): InitializeBuildResult = new InitializeBuildResult(displayName, version, bspVersion, capabilities, Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/MetalsMetadata.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/MetalsMetadata.scala
new file mode 100644
index 000000000..cc21ab855
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/MetalsMetadata.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Metals metadata in the initialization request
+ * @param semanticdbVersion The semanticdb plugin version that should be enabled for Metals code navigation
+ * @param supportedScalaVersions The list of scala versions that are supported by Metals
+ */
+final class MetalsMetadata private (
+  val semanticdbVersion: String,
+  val supportedScalaVersions: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: MetalsMetadata => (this.semanticdbVersion == x.semanticdbVersion) && (this.supportedScalaVersions == x.supportedScalaVersions)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.MetalsMetadata".##) + semanticdbVersion.##) + supportedScalaVersions.##)
+  }
+  override def toString: String = {
+    "MetalsMetadata(" + semanticdbVersion + ", " + supportedScalaVersions + ")"
+  }
+  private[this] def copy(semanticdbVersion: String = semanticdbVersion, supportedScalaVersions: Vector[String] = supportedScalaVersions): MetalsMetadata = {
+    new MetalsMetadata(semanticdbVersion, supportedScalaVersions)
+  }
+  def withSemanticdbVersion(semanticdbVersion: String): MetalsMetadata = {
+    copy(semanticdbVersion = semanticdbVersion)
+  }
+  def withSupportedScalaVersions(supportedScalaVersions: Vector[String]): MetalsMetadata = {
+    copy(supportedScalaVersions = supportedScalaVersions)
+  }
+}
+object MetalsMetadata {
+  
+  def apply(semanticdbVersion: String, supportedScalaVersions: Vector[String]): MetalsMetadata = new MetalsMetadata(semanticdbVersion, supportedScalaVersions)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/Position.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/Position.scala
new file mode 100644
index 000000000..39b6279ba
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/Position.scala
@@ -0,0 +1,42 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Position in a text document expressed as zero-based line and zero-based character offset.
+ * A position is between two characters like an 'insert' cursor in a editor.
+ * @param line Line position in a document (zero-based).
+ * @param character Character offset on a line in a document (zero-based).
+ */
+final class Position private (
+  val line: Long,
+  val character: Long) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Position => (this.line == x.line) && (this.character == x.character)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.Position".##) + line.##) + character.##)
+  }
+  override def toString: String = {
+    "Position(" + line + ", " + character + ")"
+  }
+  private[this] def copy(line: Long = line, character: Long = character): Position = {
+    new Position(line, character)
+  }
+  def withLine(line: Long): Position = {
+    copy(line = line)
+  }
+  def withCharacter(character: Long): Position = {
+    copy(character = character)
+  }
+}
+object Position {
+  
+  def apply(line: Long, character: Long): Position = new Position(line, character)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/PublishDiagnosticsParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/PublishDiagnosticsParams.scala
new file mode 100644
index 000000000..1dbf2f6c8
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/PublishDiagnosticsParams.scala
@@ -0,0 +1,63 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Publish Diagnostics
+ * @param textDocument The document where the diagnostics are published.
+ * @param buildTarget The build target where the diagnostics origin.
+                      It is valid for one text to belong to multiple build targets,
+                      for example sources that are compiled against multiple platforms (JVM, JavaScript).
+ * @param originId The request id that originated this notification
+ * @param diagnostics The diagnostics to be published by the client
+ * @param reset Whether the client should clear the previous diagnostics
+                mapped to the same `textDocument` and buildTarget
+ */
+final class PublishDiagnosticsParams private (
+  val textDocument: sbt.internal.bsp.TextDocumentIdentifier,
+  val buildTarget: sbt.internal.bsp.BuildTargetIdentifier,
+  val originId: Option[String],
+  val diagnostics: Vector[sbt.internal.bsp.Diagnostic],
+  val reset: Boolean) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: PublishDiagnosticsParams => (this.textDocument == x.textDocument) && (this.buildTarget == x.buildTarget) && (this.originId == x.originId) && (this.diagnostics == x.diagnostics) && (this.reset == x.reset)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.PublishDiagnosticsParams".##) + textDocument.##) + buildTarget.##) + originId.##) + diagnostics.##) + reset.##)
+  }
+  override def toString: String = {
+    "PublishDiagnosticsParams(" + textDocument + ", " + buildTarget + ", " + originId + ", " + diagnostics + ", " + reset + ")"
+  }
+  private[this] def copy(textDocument: sbt.internal.bsp.TextDocumentIdentifier = textDocument, buildTarget: sbt.internal.bsp.BuildTargetIdentifier = buildTarget, originId: Option[String] = originId, diagnostics: Vector[sbt.internal.bsp.Diagnostic] = diagnostics, reset: Boolean = reset): PublishDiagnosticsParams = {
+    new PublishDiagnosticsParams(textDocument, buildTarget, originId, diagnostics, reset)
+  }
+  def withTextDocument(textDocument: sbt.internal.bsp.TextDocumentIdentifier): PublishDiagnosticsParams = {
+    copy(textDocument = textDocument)
+  }
+  def withBuildTarget(buildTarget: sbt.internal.bsp.BuildTargetIdentifier): PublishDiagnosticsParams = {
+    copy(buildTarget = buildTarget)
+  }
+  def withOriginId(originId: Option[String]): PublishDiagnosticsParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): PublishDiagnosticsParams = {
+    copy(originId = Option(originId))
+  }
+  def withDiagnostics(diagnostics: Vector[sbt.internal.bsp.Diagnostic]): PublishDiagnosticsParams = {
+    copy(diagnostics = diagnostics)
+  }
+  def withReset(reset: Boolean): PublishDiagnosticsParams = {
+    copy(reset = reset)
+  }
+}
+object PublishDiagnosticsParams {
+  
+  def apply(textDocument: sbt.internal.bsp.TextDocumentIdentifier, buildTarget: sbt.internal.bsp.BuildTargetIdentifier, originId: Option[String], diagnostics: Vector[sbt.internal.bsp.Diagnostic], reset: Boolean): PublishDiagnosticsParams = new PublishDiagnosticsParams(textDocument, buildTarget, originId, diagnostics, reset)
+  def apply(textDocument: sbt.internal.bsp.TextDocumentIdentifier, buildTarget: sbt.internal.bsp.BuildTargetIdentifier, originId: String, diagnostics: Vector[sbt.internal.bsp.Diagnostic], reset: Boolean): PublishDiagnosticsParams = new PublishDiagnosticsParams(textDocument, buildTarget, Option(originId), diagnostics, reset)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/Range.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/Range.scala
new file mode 100644
index 000000000..bfda98ca6
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/Range.scala
@@ -0,0 +1,42 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * A range in a text document expressed as (zero-based) start and end positions. A range is comparable to a selection in an editor.
+ * Therefore the end position is exclusive.
+ * @param start The range's start position.
+ * @param end The range's end position.
+ */
+final class Range private (
+  val start: sbt.internal.bsp.Position,
+  val end: sbt.internal.bsp.Position) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Range => (this.start == x.start) && (this.end == x.end)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.Range".##) + start.##) + end.##)
+  }
+  override def toString: String = {
+    "Range(" + start + ", " + end + ")"
+  }
+  private[this] def copy(start: sbt.internal.bsp.Position = start, end: sbt.internal.bsp.Position = end): Range = {
+    new Range(start, end)
+  }
+  def withStart(start: sbt.internal.bsp.Position): Range = {
+    copy(start = start)
+  }
+  def withEnd(end: sbt.internal.bsp.Position): Range = {
+    copy(end = end)
+  }
+}
+object Range {
+  
+  def apply(start: sbt.internal.bsp.Position, end: sbt.internal.bsp.Position): Range = new Range(start, end)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/RunParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/RunParams.scala
new file mode 100644
index 000000000..4d0f5a74b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/RunParams.scala
@@ -0,0 +1,71 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Run Request
+ * The run request is sent from the client to the server to run a build target.
+ * The server communicates during the initialize handshake whether this method is supported or not.
+ * An empty run request is valid.
+ * @param target The build target to run.
+ * @param originId An option identifier gnerated by the client to identify this request.
+                   The server may include this id in triggered notifications or responses.
+ * @param arguments Optional arguments to the executed application.
+ * @param dataKind Kind of data to expect in the data field.
+                   If this field is not set, the kind of data is not specified.
+ * @param data Language-specific metadata for this execution.
+ */
+final class RunParams private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier,
+  val originId: Option[String],
+  val arguments: Vector[String],
+  val dataKind: Option[String],
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: RunParams => (this.target == x.target) && (this.originId == x.originId) && (this.arguments == x.arguments) && (this.dataKind == x.dataKind) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.RunParams".##) + target.##) + originId.##) + arguments.##) + dataKind.##) + data.##)
+  }
+  override def toString: String = {
+    "RunParams(" + target + ", " + originId + ", " + arguments + ", " + dataKind + ", " + data + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, originId: Option[String] = originId, arguments: Vector[String] = arguments, dataKind: Option[String] = dataKind, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): RunParams = {
+    new RunParams(target, originId, arguments, dataKind, data)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): RunParams = {
+    copy(target = target)
+  }
+  def withOriginId(originId: Option[String]): RunParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): RunParams = {
+    copy(originId = Option(originId))
+  }
+  def withArguments(arguments: Vector[String]): RunParams = {
+    copy(arguments = arguments)
+  }
+  def withDataKind(dataKind: Option[String]): RunParams = {
+    copy(dataKind = dataKind)
+  }
+  def withDataKind(dataKind: String): RunParams = {
+    copy(dataKind = Option(dataKind))
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): RunParams = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): RunParams = {
+    copy(data = Option(data))
+  }
+}
+object RunParams {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, originId: Option[String], arguments: Vector[String], dataKind: Option[String], data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): RunParams = new RunParams(target, originId, arguments, dataKind, data)
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, originId: String, arguments: Vector[String], dataKind: String, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): RunParams = new RunParams(target, Option(originId), arguments, Option(dataKind), Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/RunProvider.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/RunProvider.scala
new file mode 100644
index 000000000..2b8088890
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/RunProvider.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class RunProvider private (
+  val languageIds: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: RunProvider => (this.languageIds == x.languageIds)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.RunProvider".##) + languageIds.##)
+  }
+  override def toString: String = {
+    "RunProvider(" + languageIds + ")"
+  }
+  private[this] def copy(languageIds: Vector[String] = languageIds): RunProvider = {
+    new RunProvider(languageIds)
+  }
+  def withLanguageIds(languageIds: Vector[String]): RunProvider = {
+    copy(languageIds = languageIds)
+  }
+}
+object RunProvider {
+  
+  def apply(languageIds: Vector[String]): RunProvider = new RunProvider(languageIds)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/RunResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/RunResult.scala
new file mode 100644
index 000000000..a8a0086c3
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/RunResult.scala
@@ -0,0 +1,45 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Run Result
+ * @param originId An optional request id to know the origin of this report.
+ * @param statusCode A status code for the execution.
+ */
+final class RunResult private (
+  val originId: Option[String],
+  val statusCode: Int) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: RunResult => (this.originId == x.originId) && (this.statusCode == x.statusCode)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.RunResult".##) + originId.##) + statusCode.##)
+  }
+  override def toString: String = {
+    "RunResult(" + originId + ", " + statusCode + ")"
+  }
+  private[this] def copy(originId: Option[String] = originId, statusCode: Int = statusCode): RunResult = {
+    new RunResult(originId, statusCode)
+  }
+  def withOriginId(originId: Option[String]): RunResult = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): RunResult = {
+    copy(originId = Option(originId))
+  }
+  def withStatusCode(statusCode: Int): RunResult = {
+    copy(statusCode = statusCode)
+  }
+}
+object RunResult {
+  
+  def apply(originId: Option[String], statusCode: Int): RunResult = new RunResult(originId, statusCode)
+  def apply(originId: String, statusCode: Int): RunResult = new RunResult(Option(originId), statusCode)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/SbtBuildTarget.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/SbtBuildTarget.scala
new file mode 100644
index 000000000..723010eb5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/SbtBuildTarget.scala
@@ -0,0 +1,65 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Contains sbt-specific metadata for providing editor support for sbt build files.
+ * This metadata is embedded in the data: Option[Json] field of the BuildTarget definition
+ * when the dataKind field contains "sbt".
+ * @param sbtVersion The sbt version. Useful to support version-dependent syntax.
+ * @param autoImports A sequence of Scala imports that are automatically imported in the sbt build files.
+ * @param scalaBuildTarget The Scala build target describing the scala
+                           version and scala jars used by this sbt version.
+ * @param parent An optional parent if the target has an sbt meta project.
+ * @param children The inverse of parent, list of targets that have this build target
+                   defined as their parent. It can contain normal project targets or
+                   sbt build targets if this target represents an sbt meta-meta build.
+ */
+final class SbtBuildTarget private (
+  val sbtVersion: String,
+  val autoImports: Vector[String],
+  val scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget,
+  val parent: Option[sbt.internal.bsp.BuildTargetIdentifier],
+  val children: Vector[sbt.internal.bsp.BuildTargetIdentifier]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SbtBuildTarget => (this.sbtVersion == x.sbtVersion) && (this.autoImports == x.autoImports) && (this.scalaBuildTarget == x.scalaBuildTarget) && (this.parent == x.parent) && (this.children == x.children)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.SbtBuildTarget".##) + sbtVersion.##) + autoImports.##) + scalaBuildTarget.##) + parent.##) + children.##)
+  }
+  override def toString: String = {
+    "SbtBuildTarget(" + sbtVersion + ", " + autoImports + ", " + scalaBuildTarget + ", " + parent + ", " + children + ")"
+  }
+  private[this] def copy(sbtVersion: String = sbtVersion, autoImports: Vector[String] = autoImports, scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget = scalaBuildTarget, parent: Option[sbt.internal.bsp.BuildTargetIdentifier] = parent, children: Vector[sbt.internal.bsp.BuildTargetIdentifier] = children): SbtBuildTarget = {
+    new SbtBuildTarget(sbtVersion, autoImports, scalaBuildTarget, parent, children)
+  }
+  def withSbtVersion(sbtVersion: String): SbtBuildTarget = {
+    copy(sbtVersion = sbtVersion)
+  }
+  def withAutoImports(autoImports: Vector[String]): SbtBuildTarget = {
+    copy(autoImports = autoImports)
+  }
+  def withScalaBuildTarget(scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget): SbtBuildTarget = {
+    copy(scalaBuildTarget = scalaBuildTarget)
+  }
+  def withParent(parent: Option[sbt.internal.bsp.BuildTargetIdentifier]): SbtBuildTarget = {
+    copy(parent = parent)
+  }
+  def withParent(parent: sbt.internal.bsp.BuildTargetIdentifier): SbtBuildTarget = {
+    copy(parent = Option(parent))
+  }
+  def withChildren(children: Vector[sbt.internal.bsp.BuildTargetIdentifier]): SbtBuildTarget = {
+    copy(children = children)
+  }
+}
+object SbtBuildTarget {
+  
+  def apply(sbtVersion: String, autoImports: Vector[String], scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget, parent: Option[sbt.internal.bsp.BuildTargetIdentifier], children: Vector[sbt.internal.bsp.BuildTargetIdentifier]): SbtBuildTarget = new SbtBuildTarget(sbtVersion, autoImports, scalaBuildTarget, parent, children)
+  def apply(sbtVersion: String, autoImports: Vector[String], scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget, parent: sbt.internal.bsp.BuildTargetIdentifier, children: Vector[sbt.internal.bsp.BuildTargetIdentifier]): SbtBuildTarget = new SbtBuildTarget(sbtVersion, autoImports, scalaBuildTarget, Option(parent), children)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaBuildTarget.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaBuildTarget.scala
new file mode 100644
index 000000000..32e5885a9
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaBuildTarget.scala
@@ -0,0 +1,59 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Contains scala-specific metadata for compiling a target containing Scala sources.
+ * This metadata is embedded in the data: Option[Json] field of the BuildTarget definition,
+ * when the dataKind field contains "scala".
+ * @param scalaOrganization The Scala organization that is used for a target.
+ * @param scalaVersion The scala version to compile this target
+ * @param scalaBinaryVersion The binary version of scalaVersion.
+                             For example, 2.12 if scalaVersion is 2.12.4.
+ * @param platform The target platform for this target
+ * @param jars A sequence of Scala jars such as scala-library, scala-compiler and scala-reflect.
+ */
+final class ScalaBuildTarget private (
+  val scalaOrganization: String,
+  val scalaVersion: String,
+  val scalaBinaryVersion: String,
+  val platform: Int,
+  val jars: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaBuildTarget => (this.scalaOrganization == x.scalaOrganization) && (this.scalaVersion == x.scalaVersion) && (this.scalaBinaryVersion == x.scalaBinaryVersion) && (this.platform == x.platform) && (this.jars == x.jars)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaBuildTarget".##) + scalaOrganization.##) + scalaVersion.##) + scalaBinaryVersion.##) + platform.##) + jars.##)
+  }
+  override def toString: String = {
+    "ScalaBuildTarget(" + scalaOrganization + ", " + scalaVersion + ", " + scalaBinaryVersion + ", " + platform + ", " + jars + ")"
+  }
+  private[this] def copy(scalaOrganization: String = scalaOrganization, scalaVersion: String = scalaVersion, scalaBinaryVersion: String = scalaBinaryVersion, platform: Int = platform, jars: Vector[String] = jars): ScalaBuildTarget = {
+    new ScalaBuildTarget(scalaOrganization, scalaVersion, scalaBinaryVersion, platform, jars)
+  }
+  def withScalaOrganization(scalaOrganization: String): ScalaBuildTarget = {
+    copy(scalaOrganization = scalaOrganization)
+  }
+  def withScalaVersion(scalaVersion: String): ScalaBuildTarget = {
+    copy(scalaVersion = scalaVersion)
+  }
+  def withScalaBinaryVersion(scalaBinaryVersion: String): ScalaBuildTarget = {
+    copy(scalaBinaryVersion = scalaBinaryVersion)
+  }
+  def withPlatform(platform: Int): ScalaBuildTarget = {
+    copy(platform = platform)
+  }
+  def withJars(jars: Vector[String]): ScalaBuildTarget = {
+    copy(jars = jars)
+  }
+}
+object ScalaBuildTarget {
+  
+  def apply(scalaOrganization: String, scalaVersion: String, scalaBinaryVersion: String, platform: Int, jars: Vector[String]): ScalaBuildTarget = new ScalaBuildTarget(scalaOrganization, scalaVersion, scalaBinaryVersion, platform, jars)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClass.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClass.scala
new file mode 100644
index 000000000..c33acb898
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClass.scala
@@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param class The main class to run.
+ * @param arguments The user arguments to the main entrypoint.
+ * @param jvmOptions The jvm options for the application.
+ * @param environmentVariables Additional environment variables for the application.
+ */
+final class ScalaMainClass private (
+  val `class`: String,
+  val arguments: Vector[String],
+  val jvmOptions: Vector[String],
+  val environmentVariables: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaMainClass => (this.`class` == x.`class`) && (this.arguments == x.arguments) && (this.jvmOptions == x.jvmOptions) && (this.environmentVariables == x.environmentVariables)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaMainClass".##) + `class`.##) + arguments.##) + jvmOptions.##) + environmentVariables.##)
+  }
+  override def toString: String = {
+    "ScalaMainClass(" + `class` + ", " + arguments + ", " + jvmOptions + ", " + environmentVariables + ")"
+  }
+  private[this] def copy(`class`: String = `class`, arguments: Vector[String] = arguments, jvmOptions: Vector[String] = jvmOptions, environmentVariables: Vector[String] = environmentVariables): ScalaMainClass = {
+    new ScalaMainClass(`class`, arguments, jvmOptions, environmentVariables)
+  }
+  def withClass(`class`: String): ScalaMainClass = {
+    copy(`class` = `class`)
+  }
+  def withArguments(arguments: Vector[String]): ScalaMainClass = {
+    copy(arguments = arguments)
+  }
+  def withJvmOptions(jvmOptions: Vector[String]): ScalaMainClass = {
+    copy(jvmOptions = jvmOptions)
+  }
+  def withEnvironmentVariables(environmentVariables: Vector[String]): ScalaMainClass = {
+    copy(environmentVariables = environmentVariables)
+  }
+}
+object ScalaMainClass {
+  
+  def apply(`class`: String, arguments: Vector[String], jvmOptions: Vector[String], environmentVariables: Vector[String]): ScalaMainClass = new ScalaMainClass(`class`, arguments, jvmOptions, environmentVariables)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesItem.scala
new file mode 100644
index 000000000..188b3fcd5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesItem.scala
@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param target The build target that contains the test classes.
+ * @param classes The main class items
+ */
+final class ScalaMainClassesItem private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier,
+  val classes: Vector[sbt.internal.bsp.ScalaMainClass]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaMainClassesItem => (this.target == x.target) && (this.classes == x.classes)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaMainClassesItem".##) + target.##) + classes.##)
+  }
+  override def toString: String = {
+    "ScalaMainClassesItem(" + target + ", " + classes + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, classes: Vector[sbt.internal.bsp.ScalaMainClass] = classes): ScalaMainClassesItem = {
+    new ScalaMainClassesItem(target, classes)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): ScalaMainClassesItem = {
+    copy(target = target)
+  }
+  def withClasses(classes: Vector[sbt.internal.bsp.ScalaMainClass]): ScalaMainClassesItem = {
+    copy(classes = classes)
+  }
+}
+object ScalaMainClassesItem {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, classes: Vector[sbt.internal.bsp.ScalaMainClass]): ScalaMainClassesItem = new ScalaMainClassesItem(target, classes)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesParams.scala
new file mode 100644
index 000000000..7e891531c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesParams.scala
@@ -0,0 +1,46 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Scala Main Class Request
+ * The build target main classes request is sent from the client to the server
+ * to query for the list of main classes that can be fed as arguments to buildTarget/run.
+ * @param originId An optional number uniquely identifying a client request.
+ */
+final class ScalaMainClassesParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaMainClassesParams => (this.targets == x.targets) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaMainClassesParams".##) + targets.##) + originId.##)
+  }
+  override def toString: String = {
+    "ScalaMainClassesParams(" + targets + ", " + originId + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId): ScalaMainClassesParams = {
+    new ScalaMainClassesParams(targets, originId)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): ScalaMainClassesParams = {
+    copy(targets = targets)
+  }
+  def withOriginId(originId: Option[String]): ScalaMainClassesParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): ScalaMainClassesParams = {
+    copy(originId = Option(originId))
+  }
+}
+object ScalaMainClassesParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String]): ScalaMainClassesParams = new ScalaMainClassesParams(targets, originId)
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String): ScalaMainClassesParams = new ScalaMainClassesParams(targets, Option(originId))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesResult.scala
new file mode 100644
index 000000000..5ebccfb3b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaMainClassesResult.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** @param originId An optional id of the request that triggered this result. */
+final class ScalaMainClassesResult private (
+  val items: Vector[sbt.internal.bsp.ScalaMainClassesItem],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaMainClassesResult => (this.items == x.items) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaMainClassesResult".##) + items.##) + originId.##)
+  }
+  override def toString: String = {
+    "ScalaMainClassesResult(" + items + ", " + originId + ")"
+  }
+  private[this] def copy(items: Vector[sbt.internal.bsp.ScalaMainClassesItem] = items, originId: Option[String] = originId): ScalaMainClassesResult = {
+    new ScalaMainClassesResult(items, originId)
+  }
+  def withItems(items: Vector[sbt.internal.bsp.ScalaMainClassesItem]): ScalaMainClassesResult = {
+    copy(items = items)
+  }
+  def withOriginId(originId: Option[String]): ScalaMainClassesResult = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): ScalaMainClassesResult = {
+    copy(originId = Option(originId))
+  }
+}
+object ScalaMainClassesResult {
+  
+  def apply(items: Vector[sbt.internal.bsp.ScalaMainClassesItem], originId: Option[String]): ScalaMainClassesResult = new ScalaMainClassesResult(items, originId)
+  def apply(items: Vector[sbt.internal.bsp.ScalaMainClassesItem], originId: String): ScalaMainClassesResult = new ScalaMainClassesResult(items, Option(originId))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesItem.scala
new file mode 100644
index 000000000..210e8cc30
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesItem.scala
@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param target The build target that contains the test classes.
+ * @param classes The fully qualified names of the test classes in this target
+ */
+final class ScalaTestClassesItem private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier,
+  val classes: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaTestClassesItem => (this.target == x.target) && (this.classes == x.classes)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaTestClassesItem".##) + target.##) + classes.##)
+  }
+  override def toString: String = {
+    "ScalaTestClassesItem(" + target + ", " + classes + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, classes: Vector[String] = classes): ScalaTestClassesItem = {
+    new ScalaTestClassesItem(target, classes)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): ScalaTestClassesItem = {
+    copy(target = target)
+  }
+  def withClasses(classes: Vector[String]): ScalaTestClassesItem = {
+    copy(classes = classes)
+  }
+}
+object ScalaTestClassesItem {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, classes: Vector[String]): ScalaTestClassesItem = new ScalaTestClassesItem(target, classes)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesParams.scala
new file mode 100644
index 000000000..d7c4b9a39
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesParams.scala
@@ -0,0 +1,46 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Scala Test Class Request
+ * The build target scala test options request is sent from the client to the server
+ * to query for the list of fully qualified names of test clases in a given list of targets.
+ * @param originId An optional number uniquely identifying a client request.
+ */
+final class ScalaTestClassesParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaTestClassesParams => (this.targets == x.targets) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaTestClassesParams".##) + targets.##) + originId.##)
+  }
+  override def toString: String = {
+    "ScalaTestClassesParams(" + targets + ", " + originId + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId): ScalaTestClassesParams = {
+    new ScalaTestClassesParams(targets, originId)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): ScalaTestClassesParams = {
+    copy(targets = targets)
+  }
+  def withOriginId(originId: Option[String]): ScalaTestClassesParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): ScalaTestClassesParams = {
+    copy(originId = Option(originId))
+  }
+}
+object ScalaTestClassesParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String]): ScalaTestClassesParams = new ScalaTestClassesParams(targets, originId)
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String): ScalaTestClassesParams = new ScalaTestClassesParams(targets, Option(originId))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesResult.scala
new file mode 100644
index 000000000..40000a25a
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestClassesResult.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** @param originId An optional id of the request that triggered this result. */
+final class ScalaTestClassesResult private (
+  val items: Vector[sbt.internal.bsp.ScalaTestClassesItem],
+  val originId: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaTestClassesResult => (this.items == x.items) && (this.originId == x.originId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalaTestClassesResult".##) + items.##) + originId.##)
+  }
+  override def toString: String = {
+    "ScalaTestClassesResult(" + items + ", " + originId + ")"
+  }
+  private[this] def copy(items: Vector[sbt.internal.bsp.ScalaTestClassesItem] = items, originId: Option[String] = originId): ScalaTestClassesResult = {
+    new ScalaTestClassesResult(items, originId)
+  }
+  def withItems(items: Vector[sbt.internal.bsp.ScalaTestClassesItem]): ScalaTestClassesResult = {
+    copy(items = items)
+  }
+  def withOriginId(originId: Option[String]): ScalaTestClassesResult = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): ScalaTestClassesResult = {
+    copy(originId = Option(originId))
+  }
+}
+object ScalaTestClassesResult {
+  
+  def apply(items: Vector[sbt.internal.bsp.ScalaTestClassesItem], originId: Option[String]): ScalaTestClassesResult = new ScalaTestClassesResult(items, originId)
+  def apply(items: Vector[sbt.internal.bsp.ScalaTestClassesItem], originId: String): ScalaTestClassesResult = new ScalaTestClassesResult(items, Option(originId))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestParams.scala
new file mode 100644
index 000000000..67c19a889
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalaTestParams.scala
@@ -0,0 +1,38 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Scala Test Params
+ * ScalaTestParams contains scala-specific metadata for testing Scala targets.
+ * This metadata is embedded in the data field of the buildTarget/test request
+ * when the dataKind field contains "scala-test".
+ */
+final class ScalaTestParams private (
+  val testClasses: Vector[sbt.internal.bsp.ScalaTestClassesItem]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalaTestParams => (this.testClasses == x.testClasses)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.ScalaTestParams".##) + testClasses.##)
+  }
+  override def toString: String = {
+    "ScalaTestParams(" + testClasses + ")"
+  }
+  private[this] def copy(testClasses: Vector[sbt.internal.bsp.ScalaTestClassesItem] = testClasses): ScalaTestParams = {
+    new ScalaTestParams(testClasses)
+  }
+  def withTestClasses(testClasses: Vector[sbt.internal.bsp.ScalaTestClassesItem]): ScalaTestParams = {
+    copy(testClasses = testClasses)
+  }
+}
+object ScalaTestParams {
+  
+  def apply(testClasses: Vector[sbt.internal.bsp.ScalaTestClassesItem]): ScalaTestParams = new ScalaTestParams(testClasses)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsItem.scala
new file mode 100644
index 000000000..21f25ef80
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsItem.scala
@@ -0,0 +1,57 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param options Additional arguments to the compiler.
+                  For example, -deprecation.
+ * @param classpath The dependency classpath for this target, must be
+                    identical to what is passed as arguments to
+                    the -classpath flag in the command line interface
+                    of scalac.
+ * @param classDirectory The output directory for classfiles produced by this target
+ */
+final class ScalacOptionsItem private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier,
+  val options: Vector[String],
+  val classpath: Vector[java.net.URI],
+  val classDirectory: Option[java.net.URI]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalacOptionsItem => (this.target == x.target) && (this.options == x.options) && (this.classpath == x.classpath) && (this.classDirectory == x.classDirectory)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.ScalacOptionsItem".##) + target.##) + options.##) + classpath.##) + classDirectory.##)
+  }
+  override def toString: String = {
+    "ScalacOptionsItem(" + target + ", " + options + ", " + classpath + ", " + classDirectory + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, options: Vector[String] = options, classpath: Vector[java.net.URI] = classpath, classDirectory: Option[java.net.URI] = classDirectory): ScalacOptionsItem = {
+    new ScalacOptionsItem(target, options, classpath, classDirectory)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): ScalacOptionsItem = {
+    copy(target = target)
+  }
+  def withOptions(options: Vector[String]): ScalacOptionsItem = {
+    copy(options = options)
+  }
+  def withClasspath(classpath: Vector[java.net.URI]): ScalacOptionsItem = {
+    copy(classpath = classpath)
+  }
+  def withClassDirectory(classDirectory: Option[java.net.URI]): ScalacOptionsItem = {
+    copy(classDirectory = classDirectory)
+  }
+  def withClassDirectory(classDirectory: java.net.URI): ScalacOptionsItem = {
+    copy(classDirectory = Option(classDirectory))
+  }
+}
+object ScalacOptionsItem {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, options: Vector[String], classpath: Vector[java.net.URI], classDirectory: Option[java.net.URI]): ScalacOptionsItem = new ScalacOptionsItem(target, options, classpath, classDirectory)
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, options: Vector[String], classpath: Vector[java.net.URI], classDirectory: java.net.URI): ScalacOptionsItem = new ScalacOptionsItem(target, options, classpath, Option(classDirectory))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsParams.scala
new file mode 100644
index 000000000..405ea9239
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsParams.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Scalac options
+ * The build target scalac options request is sent from the client to the server
+ * to query for the list of compiler options necessary to compile in a given list of targets.
+ */
+final class ScalacOptionsParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalacOptionsParams => (this.targets == x.targets)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.ScalacOptionsParams".##) + targets.##)
+  }
+  override def toString: String = {
+    "ScalacOptionsParams(" + targets + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets): ScalacOptionsParams = {
+    new ScalacOptionsParams(targets)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): ScalacOptionsParams = {
+    copy(targets = targets)
+  }
+}
+object ScalacOptionsParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): ScalacOptionsParams = new ScalacOptionsParams(targets)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsResult.scala
new file mode 100644
index 000000000..0ec117c04
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/ScalacOptionsResult.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class ScalacOptionsResult private (
+  val items: Vector[sbt.internal.bsp.ScalacOptionsItem]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ScalacOptionsResult => (this.items == x.items)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.ScalacOptionsResult".##) + items.##)
+  }
+  override def toString: String = {
+    "ScalacOptionsResult(" + items + ")"
+  }
+  private[this] def copy(items: Vector[sbt.internal.bsp.ScalacOptionsItem] = items): ScalacOptionsResult = {
+    new ScalacOptionsResult(items)
+  }
+  def withItems(items: Vector[sbt.internal.bsp.ScalacOptionsItem]): ScalacOptionsResult = {
+    copy(items = items)
+  }
+}
+object ScalacOptionsResult {
+  
+  def apply(items: Vector[sbt.internal.bsp.ScalacOptionsItem]): ScalacOptionsResult = new ScalacOptionsResult(items)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/SourceItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourceItem.scala
new file mode 100644
index 000000000..8c7eb77a8
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourceItem.scala
@@ -0,0 +1,49 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param uri Either a text document or a directory. A directory entry must end with a forward
+              slash "/" and a directory entry implies that every nested text document within the
+              directory belongs to this source item.
+              
+ * @param kind Type of file of the source item, such as whether it is file or directory.
+ * @param generated Indicates if this source is automatically generated by the build and is not
+                    intended to be manually edited by the user.
+ */
+final class SourceItem private (
+  val uri: java.net.URI,
+  val kind: Int,
+  val generated: Boolean) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SourceItem => (this.uri == x.uri) && (this.kind == x.kind) && (this.generated == x.generated)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.SourceItem".##) + uri.##) + kind.##) + generated.##)
+  }
+  override def toString: String = {
+    "SourceItem(" + uri + ", " + kind + ", " + generated + ")"
+  }
+  private[this] def copy(uri: java.net.URI = uri, kind: Int = kind, generated: Boolean = generated): SourceItem = {
+    new SourceItem(uri, kind, generated)
+  }
+  def withUri(uri: java.net.URI): SourceItem = {
+    copy(uri = uri)
+  }
+  def withKind(kind: Int): SourceItem = {
+    copy(kind = kind)
+  }
+  def withGenerated(generated: Boolean): SourceItem = {
+    copy(generated = generated)
+  }
+}
+object SourceItem {
+  
+  def apply(uri: java.net.URI, kind: Int, generated: Boolean): SourceItem = new SourceItem(uri, kind, generated)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesItem.scala
new file mode 100644
index 000000000..52b399df8
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesItem.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** @param sources The text documents or and directories that belong to this build target. */
+final class SourcesItem private (
+  val target: sbt.internal.bsp.BuildTargetIdentifier,
+  val sources: Vector[sbt.internal.bsp.SourceItem]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SourcesItem => (this.target == x.target) && (this.sources == x.sources)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.SourcesItem".##) + target.##) + sources.##)
+  }
+  override def toString: String = {
+    "SourcesItem(" + target + ", " + sources + ")"
+  }
+  private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, sources: Vector[sbt.internal.bsp.SourceItem] = sources): SourcesItem = {
+    new SourcesItem(target, sources)
+  }
+  def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): SourcesItem = {
+    copy(target = target)
+  }
+  def withSources(sources: Vector[sbt.internal.bsp.SourceItem]): SourcesItem = {
+    copy(sources = sources)
+  }
+}
+object SourcesItem {
+  
+  def apply(target: sbt.internal.bsp.BuildTargetIdentifier, sources: Vector[sbt.internal.bsp.SourceItem]): SourcesItem = new SourcesItem(target, sources)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesParams.scala
new file mode 100644
index 000000000..70f481003
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesParams.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** Build Target Sources Request */
+final class SourcesParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SourcesParams => (this.targets == x.targets)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.SourcesParams".##) + targets.##)
+  }
+  override def toString: String = {
+    "SourcesParams(" + targets + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets): SourcesParams = {
+    new SourcesParams(targets)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): SourcesParams = {
+    copy(targets = targets)
+  }
+}
+object SourcesParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): SourcesParams = new SourcesParams(targets)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesResult.scala
new file mode 100644
index 000000000..c605d062b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/SourcesResult.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** Build Target Sources response */
+final class SourcesResult private (
+  val items: Vector[sbt.internal.bsp.SourcesItem]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SourcesResult => (this.items == x.items)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.SourcesResult".##) + items.##)
+  }
+  override def toString: String = {
+    "SourcesResult(" + items + ")"
+  }
+  private[this] def copy(items: Vector[sbt.internal.bsp.SourcesItem] = items): SourcesResult = {
+    new SourcesResult(items)
+  }
+  def withItems(items: Vector[sbt.internal.bsp.SourcesItem]): SourcesResult = {
+    copy(items = items)
+  }
+}
+object SourcesResult {
+  
+  def apply(items: Vector[sbt.internal.bsp.SourcesItem]): SourcesResult = new SourcesResult(items)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskFinishParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskFinishParams.scala
new file mode 100644
index 000000000..4fa8a4220
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskFinishParams.scala
@@ -0,0 +1,73 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param taskId Unique id of the task with optional reference to parent task id.
+ * @param eventTime Optional timestamp of when the event started in milliseconds since Epoch.
+ * @param message Optional message describing the task.
+ * @param status Task completion status: 1 -> success, 2 -> error, 3 -> cancelled
+ * @param dataKind Kind of data to expect in the `data` field.
+ * @param data Optional metadata about the task.
+ */
+final class TaskFinishParams private (
+  val taskId: sbt.internal.bsp.TaskId,
+  val eventTime: Option[Long],
+  val message: Option[String],
+  val status: Int,
+  val dataKind: Option[String],
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TaskFinishParams => (this.taskId == x.taskId) && (this.eventTime == x.eventTime) && (this.message == x.message) && (this.status == x.status) && (this.dataKind == x.dataKind) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.TaskFinishParams".##) + taskId.##) + eventTime.##) + message.##) + status.##) + dataKind.##) + data.##)
+  }
+  override def toString: String = {
+    "TaskFinishParams(" + taskId + ", " + eventTime + ", " + message + ", " + status + ", " + dataKind + ", " + data + ")"
+  }
+  private[this] def copy(taskId: sbt.internal.bsp.TaskId = taskId, eventTime: Option[Long] = eventTime, message: Option[String] = message, status: Int = status, dataKind: Option[String] = dataKind, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): TaskFinishParams = {
+    new TaskFinishParams(taskId, eventTime, message, status, dataKind, data)
+  }
+  def withTaskId(taskId: sbt.internal.bsp.TaskId): TaskFinishParams = {
+    copy(taskId = taskId)
+  }
+  def withEventTime(eventTime: Option[Long]): TaskFinishParams = {
+    copy(eventTime = eventTime)
+  }
+  def withEventTime(eventTime: Long): TaskFinishParams = {
+    copy(eventTime = Option(eventTime))
+  }
+  def withMessage(message: Option[String]): TaskFinishParams = {
+    copy(message = message)
+  }
+  def withMessage(message: String): TaskFinishParams = {
+    copy(message = Option(message))
+  }
+  def withStatus(status: Int): TaskFinishParams = {
+    copy(status = status)
+  }
+  def withDataKind(dataKind: Option[String]): TaskFinishParams = {
+    copy(dataKind = dataKind)
+  }
+  def withDataKind(dataKind: String): TaskFinishParams = {
+    copy(dataKind = Option(dataKind))
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): TaskFinishParams = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): TaskFinishParams = {
+    copy(data = Option(data))
+  }
+}
+object TaskFinishParams {
+  
+  def apply(taskId: sbt.internal.bsp.TaskId, eventTime: Option[Long], message: Option[String], status: Int, dataKind: Option[String], data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): TaskFinishParams = new TaskFinishParams(taskId, eventTime, message, status, dataKind, data)
+  def apply(taskId: sbt.internal.bsp.TaskId, eventTime: Long, message: String, status: Int, dataKind: String, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): TaskFinishParams = new TaskFinishParams(taskId, Option(eventTime), Option(message), status, Option(dataKind), Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskId.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskId.scala
new file mode 100644
index 000000000..c1dfbc97f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskId.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * @param id A unique identifier
+ * @param parents The parent task ids, if any. A non-empty parents field means
+                  this task is a sub-task of every parent task.
+ */
+final class TaskId private (
+  val id: String,
+  val parents: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TaskId => (this.id == x.id) && (this.parents == x.parents)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.TaskId".##) + id.##) + parents.##)
+  }
+  override def toString: String = {
+    "TaskId(" + id + ", " + parents + ")"
+  }
+  private[this] def copy(id: String = id, parents: Vector[String] = parents): TaskId = {
+    new TaskId(id, parents)
+  }
+  def withId(id: String): TaskId = {
+    copy(id = id)
+  }
+  def withParents(parents: Vector[String]): TaskId = {
+    copy(parents = parents)
+  }
+}
+object TaskId {
+  
+  def apply(id: String, parents: Vector[String]): TaskId = new TaskId(id, parents)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskStartParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskStartParams.scala
new file mode 100644
index 000000000..f37febb95
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/TaskStartParams.scala
@@ -0,0 +1,69 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Task Notifications
+ * @param taskId Unique id of the task with optional reference to parent task id.
+ * @param eventTime Optional timestamp of when the event started in milliseconds since Epoch.
+ * @param message Optional message describing the task.
+ * @param dataKind Kind of data to expect in the `data` field.
+ * @param data Optional metadata about the task.
+ */
+final class TaskStartParams private (
+  val taskId: sbt.internal.bsp.TaskId,
+  val eventTime: Option[Long],
+  val message: Option[String],
+  val dataKind: Option[String],
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TaskStartParams => (this.taskId == x.taskId) && (this.eventTime == x.eventTime) && (this.message == x.message) && (this.dataKind == x.dataKind) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.TaskStartParams".##) + taskId.##) + eventTime.##) + message.##) + dataKind.##) + data.##)
+  }
+  override def toString: String = {
+    "TaskStartParams(" + taskId + ", " + eventTime + ", " + message + ", " + dataKind + ", " + data + ")"
+  }
+  private[this] def copy(taskId: sbt.internal.bsp.TaskId = taskId, eventTime: Option[Long] = eventTime, message: Option[String] = message, dataKind: Option[String] = dataKind, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): TaskStartParams = {
+    new TaskStartParams(taskId, eventTime, message, dataKind, data)
+  }
+  def withTaskId(taskId: sbt.internal.bsp.TaskId): TaskStartParams = {
+    copy(taskId = taskId)
+  }
+  def withEventTime(eventTime: Option[Long]): TaskStartParams = {
+    copy(eventTime = eventTime)
+  }
+  def withEventTime(eventTime: Long): TaskStartParams = {
+    copy(eventTime = Option(eventTime))
+  }
+  def withMessage(message: Option[String]): TaskStartParams = {
+    copy(message = message)
+  }
+  def withMessage(message: String): TaskStartParams = {
+    copy(message = Option(message))
+  }
+  def withDataKind(dataKind: Option[String]): TaskStartParams = {
+    copy(dataKind = dataKind)
+  }
+  def withDataKind(dataKind: String): TaskStartParams = {
+    copy(dataKind = Option(dataKind))
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): TaskStartParams = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): TaskStartParams = {
+    copy(data = Option(data))
+  }
+}
+object TaskStartParams {
+  
+  def apply(taskId: sbt.internal.bsp.TaskId, eventTime: Option[Long], message: Option[String], dataKind: Option[String], data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): TaskStartParams = new TaskStartParams(taskId, eventTime, message, dataKind, data)
+  def apply(taskId: sbt.internal.bsp.TaskId, eventTime: Long, message: String, dataKind: String, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): TaskStartParams = new TaskStartParams(taskId, Option(eventTime), Option(message), Option(dataKind), Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/TestParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/TestParams.scala
new file mode 100644
index 000000000..a0c8c0b62
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/TestParams.scala
@@ -0,0 +1,70 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Test Request
+ * The test build target request is sent from the client to the server to test the given list of build targets.
+ * The server communicates during the initialize handshake whether this method is supported or not.
+ * @param targets A sequence of build targets to test.
+ * @param originId An option identifier generated by the client to identify this request.
+                   The server may include this id in triggered notifications or responses.
+ * @param arguments Optional arguments to the test execution engine.
+ * @param dataKind Kind of data to expect in the `data` field.
+                   If this field is not set, the kind of data is not specified.
+ * @param data Language-specific metadata for this test execution.
+ */
+final class TestParams private (
+  val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier],
+  val originId: Option[String],
+  val arguments: Vector[String],
+  val dataKind: Option[String],
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestParams => (this.targets == x.targets) && (this.originId == x.originId) && (this.arguments == x.arguments) && (this.dataKind == x.dataKind) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.TestParams".##) + targets.##) + originId.##) + arguments.##) + dataKind.##) + data.##)
+  }
+  override def toString: String = {
+    "TestParams(" + targets + ", " + originId + ", " + arguments + ", " + dataKind + ", " + data + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets, originId: Option[String] = originId, arguments: Vector[String] = arguments, dataKind: Option[String] = dataKind, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): TestParams = {
+    new TestParams(targets, originId, arguments, dataKind, data)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): TestParams = {
+    copy(targets = targets)
+  }
+  def withOriginId(originId: Option[String]): TestParams = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): TestParams = {
+    copy(originId = Option(originId))
+  }
+  def withArguments(arguments: Vector[String]): TestParams = {
+    copy(arguments = arguments)
+  }
+  def withDataKind(dataKind: Option[String]): TestParams = {
+    copy(dataKind = dataKind)
+  }
+  def withDataKind(dataKind: String): TestParams = {
+    copy(dataKind = Option(dataKind))
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): TestParams = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): TestParams = {
+    copy(data = Option(data))
+  }
+}
+object TestParams {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: Option[String], arguments: Vector[String], dataKind: Option[String], data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): TestParams = new TestParams(targets, originId, arguments, dataKind, data)
+  def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier], originId: String, arguments: Vector[String], dataKind: String, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): TestParams = new TestParams(targets, Option(originId), arguments, Option(dataKind), Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/TestProvider.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/TestProvider.scala
new file mode 100644
index 000000000..264ca4245
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/TestProvider.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+final class TestProvider private (
+  val languageIds: Vector[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestProvider => (this.languageIds == x.languageIds)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.TestProvider".##) + languageIds.##)
+  }
+  override def toString: String = {
+    "TestProvider(" + languageIds + ")"
+  }
+  private[this] def copy(languageIds: Vector[String] = languageIds): TestProvider = {
+    new TestProvider(languageIds)
+  }
+  def withLanguageIds(languageIds: Vector[String]): TestProvider = {
+    copy(languageIds = languageIds)
+  }
+}
+object TestProvider {
+  
+  def apply(languageIds: Vector[String]): TestProvider = new TestProvider(languageIds)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/TestResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/TestResult.scala
new file mode 100644
index 000000000..0f3e934e9
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/TestResult.scala
@@ -0,0 +1,45 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Test Result
+ * @param originId An optional request id to know the origin of this report.
+ * @param statusCode A status code for the execution.
+ */
+final class TestResult private (
+  val originId: Option[String],
+  val statusCode: Int) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestResult => (this.originId == x.originId) && (this.statusCode == x.statusCode)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.bsp.TestResult".##) + originId.##) + statusCode.##)
+  }
+  override def toString: String = {
+    "TestResult(" + originId + ", " + statusCode + ")"
+  }
+  private[this] def copy(originId: Option[String] = originId, statusCode: Int = statusCode): TestResult = {
+    new TestResult(originId, statusCode)
+  }
+  def withOriginId(originId: Option[String]): TestResult = {
+    copy(originId = originId)
+  }
+  def withOriginId(originId: String): TestResult = {
+    copy(originId = Option(originId))
+  }
+  def withStatusCode(statusCode: Int): TestResult = {
+    copy(statusCode = statusCode)
+  }
+}
+object TestResult {
+  
+  def apply(originId: Option[String], statusCode: Int): TestResult = new TestResult(originId, statusCode)
+  def apply(originId: String, statusCode: Int): TestResult = new TestResult(Option(originId), statusCode)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/TextDocumentIdentifier.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/TextDocumentIdentifier.scala
new file mode 100644
index 000000000..b62fdd9ef
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/TextDocumentIdentifier.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/** @param uri The file's Uri */
+final class TextDocumentIdentifier private (
+  val uri: java.net.URI) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TextDocumentIdentifier => (this.uri == x.uri)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.TextDocumentIdentifier".##) + uri.##)
+  }
+  override def toString: String = {
+    "TextDocumentIdentifier(" + uri + ")"
+  }
+  private[this] def copy(uri: java.net.URI = uri): TextDocumentIdentifier = {
+    new TextDocumentIdentifier(uri)
+  }
+  def withUri(uri: java.net.URI): TextDocumentIdentifier = {
+    copy(uri = uri)
+  }
+}
+object TextDocumentIdentifier {
+  
+  def apply(uri: java.net.URI): TextDocumentIdentifier = new TextDocumentIdentifier(uri)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/WorkspaceBuildTargetsResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/WorkspaceBuildTargetsResult.scala
new file mode 100644
index 000000000..794ce9fde
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/WorkspaceBuildTargetsResult.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp
+/**
+ * Workspace Build Targets response
+ * @param targets The build targets in this workspace that
+                  contain sources with the given language ids.
+ */
+final class WorkspaceBuildTargetsResult private (
+  val targets: Vector[sbt.internal.bsp.BuildTarget]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: WorkspaceBuildTargetsResult => (this.targets == x.targets)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.bsp.WorkspaceBuildTargetsResult".##) + targets.##)
+  }
+  override def toString: String = {
+    "WorkspaceBuildTargetsResult(" + targets + ")"
+  }
+  private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTarget] = targets): WorkspaceBuildTargetsResult = {
+    new WorkspaceBuildTargetsResult(targets)
+  }
+  def withTargets(targets: Vector[sbt.internal.bsp.BuildTarget]): WorkspaceBuildTargetsResult = {
+    copy(targets = targets)
+  }
+}
+object WorkspaceBuildTargetsResult {
+  
+  def apply(targets: Vector[sbt.internal.bsp.BuildTarget]): WorkspaceBuildTargetsResult = new WorkspaceBuildTargetsResult(targets)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BspCompileResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BspCompileResultFormats.scala
new file mode 100644
index 000000000..23f0b7a6e
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BspCompileResultFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BspCompileResultFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val BspCompileResultFormat: JsonFormat[sbt.internal.bsp.BspCompileResult] = new JsonFormat[sbt.internal.bsp.BspCompileResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.BspCompileResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val statusCode = unbuilder.readField[Int]("statusCode")
+      unbuilder.endObject()
+      sbt.internal.bsp.BspCompileResult(originId, statusCode)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.BspCompileResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("originId", obj.originId)
+    builder.addField("statusCode", obj.statusCode)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BspConnectionDetailsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BspConnectionDetailsFormats.scala
new file mode 100644
index 000000000..6f6b54123
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BspConnectionDetailsFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BspConnectionDetailsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val BspConnectionDetailsFormat: JsonFormat[sbt.internal.bsp.BspConnectionDetails] = new JsonFormat[sbt.internal.bsp.BspConnectionDetails] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.BspConnectionDetails = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val name = unbuilder.readField[String]("name")
+      val version = unbuilder.readField[String]("version")
+      val bspVersion = unbuilder.readField[String]("bspVersion")
+      val languages = unbuilder.readField[Vector[String]]("languages")
+      val argv = unbuilder.readField[Vector[String]]("argv")
+      unbuilder.endObject()
+      sbt.internal.bsp.BspConnectionDetails(name, version, bspVersion, languages, argv)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.BspConnectionDetails, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("version", obj.version)
+    builder.addField("bspVersion", obj.bspVersion)
+    builder.addField("languages", obj.languages)
+    builder.addField("argv", obj.argv)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildClientCapabilitiesFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildClientCapabilitiesFormats.scala
new file mode 100644
index 000000000..0e4602229
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildClientCapabilitiesFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BuildClientCapabilitiesFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val BuildClientCapabilitiesFormat: JsonFormat[sbt.internal.bsp.BuildClientCapabilities] = new JsonFormat[sbt.internal.bsp.BuildClientCapabilities] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.BuildClientCapabilities = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val languageIds = unbuilder.readField[Vector[String]]("languageIds")
+      unbuilder.endObject()
+      sbt.internal.bsp.BuildClientCapabilities(languageIds)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.BuildClientCapabilities, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("languageIds", obj.languageIds)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildServerCapabilitiesFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildServerCapabilitiesFormats.scala
new file mode 100644
index 000000000..37211376a
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildServerCapabilitiesFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BuildServerCapabilitiesFormats { self: sbt.internal.bsp.codec.CompileProviderFormats with sbt.internal.bsp.codec.TestProviderFormats with sbt.internal.bsp.codec.RunProviderFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val BuildServerCapabilitiesFormat: JsonFormat[sbt.internal.bsp.BuildServerCapabilities] = new JsonFormat[sbt.internal.bsp.BuildServerCapabilities] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.BuildServerCapabilities = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val compileProvider = unbuilder.readField[Option[sbt.internal.bsp.CompileProvider]]("compileProvider")
+      val testProvider = unbuilder.readField[Option[sbt.internal.bsp.TestProvider]]("testProvider")
+      val runProvider = unbuilder.readField[Option[sbt.internal.bsp.RunProvider]]("runProvider")
+      val dependencySourcesProvider = unbuilder.readField[Option[Boolean]]("dependencySourcesProvider")
+      val canReload = unbuilder.readField[Option[Boolean]]("canReload")
+      unbuilder.endObject()
+      sbt.internal.bsp.BuildServerCapabilities(compileProvider, testProvider, runProvider, dependencySourcesProvider, canReload)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.BuildServerCapabilities, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("compileProvider", obj.compileProvider)
+    builder.addField("testProvider", obj.testProvider)
+    builder.addField("runProvider", obj.runProvider)
+    builder.addField("dependencySourcesProvider", obj.dependencySourcesProvider)
+    builder.addField("canReload", obj.canReload)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetCapabilitiesFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetCapabilitiesFormats.scala
new file mode 100644
index 000000000..020497c07
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetCapabilitiesFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BuildTargetCapabilitiesFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val BuildTargetCapabilitiesFormat: JsonFormat[sbt.internal.bsp.BuildTargetCapabilities] = new JsonFormat[sbt.internal.bsp.BuildTargetCapabilities] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.BuildTargetCapabilities = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val canCompile = unbuilder.readField[Boolean]("canCompile")
+      val canTest = unbuilder.readField[Boolean]("canTest")
+      val canRun = unbuilder.readField[Boolean]("canRun")
+      unbuilder.endObject()
+      sbt.internal.bsp.BuildTargetCapabilities(canCompile, canTest, canRun)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.BuildTargetCapabilities, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("canCompile", obj.canCompile)
+    builder.addField("canTest", obj.canTest)
+    builder.addField("canRun", obj.canRun)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetFormats.scala
new file mode 100644
index 000000000..8515f37ee
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetFormats.scala
@@ -0,0 +1,43 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BuildTargetFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sbt.internal.bsp.codec.BuildTargetCapabilitiesFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val BuildTargetFormat: JsonFormat[sbt.internal.bsp.BuildTarget] = new JsonFormat[sbt.internal.bsp.BuildTarget] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.BuildTarget = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val id = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("id")
+      val displayName = unbuilder.readField[Option[String]]("displayName")
+      val baseDirectory = unbuilder.readField[Option[java.net.URI]]("baseDirectory")
+      val tags = unbuilder.readField[Vector[String]]("tags")
+      val capabilities = unbuilder.readField[sbt.internal.bsp.BuildTargetCapabilities]("capabilities")
+      val languageIds = unbuilder.readField[Vector[String]]("languageIds")
+      val dependencies = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("dependencies")
+      val dataKind = unbuilder.readField[Option[String]]("dataKind")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.BuildTarget(id, displayName, baseDirectory, tags, capabilities, languageIds, dependencies, dataKind, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.BuildTarget, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("id", obj.id)
+    builder.addField("displayName", obj.displayName)
+    builder.addField("baseDirectory", obj.baseDirectory)
+    builder.addField("tags", obj.tags)
+    builder.addField("capabilities", obj.capabilities)
+    builder.addField("languageIds", obj.languageIds)
+    builder.addField("dependencies", obj.dependencies)
+    builder.addField("dataKind", obj.dataKind)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetIdentifierFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetIdentifierFormats.scala
new file mode 100644
index 000000000..7e5c447bb
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/BuildTargetIdentifierFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BuildTargetIdentifierFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val BuildTargetIdentifierFormat: JsonFormat[sbt.internal.bsp.BuildTargetIdentifier] = new JsonFormat[sbt.internal.bsp.BuildTargetIdentifier] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.BuildTargetIdentifier = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[java.net.URI]("uri")
+      unbuilder.endObject()
+      sbt.internal.bsp.BuildTargetIdentifier(uri)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.BuildTargetIdentifier, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileParamsFormats.scala
new file mode 100644
index 000000000..f662874df
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileParamsFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CompileParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val CompileParamsFormat: JsonFormat[sbt.internal.bsp.CompileParams] = new JsonFormat[sbt.internal.bsp.CompileParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.CompileParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val arguments = unbuilder.readField[Vector[String]]("arguments")
+      unbuilder.endObject()
+      sbt.internal.bsp.CompileParams(targets, originId, arguments)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.CompileParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.addField("originId", obj.originId)
+    builder.addField("arguments", obj.arguments)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileProviderFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileProviderFormats.scala
new file mode 100644
index 000000000..dfa87f066
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileProviderFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CompileProviderFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val CompileProviderFormat: JsonFormat[sbt.internal.bsp.CompileProvider] = new JsonFormat[sbt.internal.bsp.CompileProvider] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.CompileProvider = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val languageIds = unbuilder.readField[Vector[String]]("languageIds")
+      unbuilder.endObject()
+      sbt.internal.bsp.CompileProvider(languageIds)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.CompileProvider, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("languageIds", obj.languageIds)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileReportFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileReportFormats.scala
new file mode 100644
index 000000000..953258a86
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileReportFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CompileReportFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val CompileReportFormat: JsonFormat[sbt.internal.bsp.CompileReport] = new JsonFormat[sbt.internal.bsp.CompileReport] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.CompileReport = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val errors = unbuilder.readField[Int]("errors")
+      val warnings = unbuilder.readField[Int]("warnings")
+      val time = unbuilder.readField[Option[Int]]("time")
+      unbuilder.endObject()
+      sbt.internal.bsp.CompileReport(target, originId, errors, warnings, time)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.CompileReport, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("originId", obj.originId)
+    builder.addField("errors", obj.errors)
+    builder.addField("warnings", obj.warnings)
+    builder.addField("time", obj.time)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileTaskFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileTaskFormats.scala
new file mode 100644
index 000000000..b79b825af
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/CompileTaskFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CompileTaskFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val CompileTaskFormat: JsonFormat[sbt.internal.bsp.CompileTask] = new JsonFormat[sbt.internal.bsp.CompileTask] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.CompileTask = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      unbuilder.endObject()
+      sbt.internal.bsp.CompileTask(target)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.CompileTask, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DebugSessionAddressFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DebugSessionAddressFormats.scala
new file mode 100644
index 000000000..d63db6510
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DebugSessionAddressFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DebugSessionAddressFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val DebugSessionAddressFormat: JsonFormat[sbt.internal.bsp.DebugSessionAddress] = new JsonFormat[sbt.internal.bsp.DebugSessionAddress] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.DebugSessionAddress = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[java.net.URI]("uri")
+      unbuilder.endObject()
+      sbt.internal.bsp.DebugSessionAddress(uri)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.DebugSessionAddress, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DebugSessionParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DebugSessionParamsFormats.scala
new file mode 100644
index 000000000..8d4ccab6e
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DebugSessionParamsFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DebugSessionParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val DebugSessionParamsFormat: JsonFormat[sbt.internal.bsp.DebugSessionParams] = new JsonFormat[sbt.internal.bsp.DebugSessionParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.DebugSessionParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      val dataKind = unbuilder.readField[Option[String]]("dataKind")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.DebugSessionParams(targets, dataKind, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.DebugSessionParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.addField("dataKind", obj.dataKind)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesItemFormats.scala
new file mode 100644
index 000000000..f2ecf0266
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesItemFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DependencySourcesItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val DependencySourcesItemFormat: JsonFormat[sbt.internal.bsp.DependencySourcesItem] = new JsonFormat[sbt.internal.bsp.DependencySourcesItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.DependencySourcesItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[Option[sbt.internal.bsp.BuildTargetIdentifier]]("target")
+      val sources = unbuilder.readField[Vector[java.net.URI]]("sources")
+      unbuilder.endObject()
+      sbt.internal.bsp.DependencySourcesItem(target, sources)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.DependencySourcesItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("sources", obj.sources)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesParamsFormats.scala
new file mode 100644
index 000000000..7b5a8dc91
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesParamsFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DependencySourcesParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val DependencySourcesParamsFormat: JsonFormat[sbt.internal.bsp.DependencySourcesParams] = new JsonFormat[sbt.internal.bsp.DependencySourcesParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.DependencySourcesParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      unbuilder.endObject()
+      sbt.internal.bsp.DependencySourcesParams(targets)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.DependencySourcesParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesResultFormats.scala
new file mode 100644
index 000000000..974150a78
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DependencySourcesResultFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DependencySourcesResultFormats { self: sbt.internal.bsp.codec.DependencySourcesItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val DependencySourcesResultFormat: JsonFormat[sbt.internal.bsp.DependencySourcesResult] = new JsonFormat[sbt.internal.bsp.DependencySourcesResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.DependencySourcesResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[sbt.internal.bsp.DependencySourcesItem]]("items")
+      unbuilder.endObject()
+      sbt.internal.bsp.DependencySourcesResult(items)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.DependencySourcesResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DiagnosticFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DiagnosticFormats.scala
new file mode 100644
index 000000000..64a3a224b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/DiagnosticFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DiagnosticFormats { self: sbt.internal.bsp.codec.RangeFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val DiagnosticFormat: JsonFormat[sbt.internal.bsp.Diagnostic] = new JsonFormat[sbt.internal.bsp.Diagnostic] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.Diagnostic = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val range = unbuilder.readField[sbt.internal.bsp.Range]("range")
+      val severity = unbuilder.readField[Option[Long]]("severity")
+      val code = unbuilder.readField[Option[String]]("code")
+      val source = unbuilder.readField[Option[String]]("source")
+      val message = unbuilder.readField[String]("message")
+      unbuilder.endObject()
+      sbt.internal.bsp.Diagnostic(range, severity, code, source, message)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.Diagnostic, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("range", obj.range)
+    builder.addField("severity", obj.severity)
+    builder.addField("code", obj.code)
+    builder.addField("source", obj.source)
+    builder.addField("message", obj.message)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/InitializeBuildParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/InitializeBuildParamsFormats.scala
new file mode 100644
index 000000000..943feb664
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/InitializeBuildParamsFormats.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InitializeBuildParamsFormats { self: sbt.internal.bsp.codec.BuildClientCapabilitiesFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val InitializeBuildParamsFormat: JsonFormat[sbt.internal.bsp.InitializeBuildParams] = new JsonFormat[sbt.internal.bsp.InitializeBuildParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.InitializeBuildParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val displayName = unbuilder.readField[String]("displayName")
+      val version = unbuilder.readField[String]("version")
+      val bspVersion = unbuilder.readField[String]("bspVersion")
+      val rootUri = unbuilder.readField[java.net.URI]("rootUri")
+      val capabilities = unbuilder.readField[sbt.internal.bsp.BuildClientCapabilities]("capabilities")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.InitializeBuildParams(displayName, version, bspVersion, rootUri, capabilities, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.InitializeBuildParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("displayName", obj.displayName)
+    builder.addField("version", obj.version)
+    builder.addField("bspVersion", obj.bspVersion)
+    builder.addField("rootUri", obj.rootUri)
+    builder.addField("capabilities", obj.capabilities)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/InitializeBuildResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/InitializeBuildResultFormats.scala
new file mode 100644
index 000000000..1b555b42c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/InitializeBuildResultFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InitializeBuildResultFormats { self: sbt.internal.bsp.codec.BuildServerCapabilitiesFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val InitializeBuildResultFormat: JsonFormat[sbt.internal.bsp.InitializeBuildResult] = new JsonFormat[sbt.internal.bsp.InitializeBuildResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.InitializeBuildResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val displayName = unbuilder.readField[String]("displayName")
+      val version = unbuilder.readField[String]("version")
+      val bspVersion = unbuilder.readField[String]("bspVersion")
+      val capabilities = unbuilder.readField[sbt.internal.bsp.BuildServerCapabilities]("capabilities")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.InitializeBuildResult(displayName, version, bspVersion, capabilities, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.InitializeBuildResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("displayName", obj.displayName)
+    builder.addField("version", obj.version)
+    builder.addField("bspVersion", obj.bspVersion)
+    builder.addField("capabilities", obj.capabilities)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala
new file mode 100644
index 000000000..a5fd68958
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala
@@ -0,0 +1,60 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+trait JsonProtocol extends sjsonnew.BasicJsonProtocol
+  with sbt.internal.bsp.codec.BuildTargetIdentifierFormats
+  with sbt.internal.bsp.codec.BuildTargetCapabilitiesFormats
+  with sbt.internal.util.codec.JValueFormats
+  with sbt.internal.bsp.codec.BuildTargetFormats
+  with sbt.internal.bsp.codec.DebugSessionAddressFormats
+  with sbt.internal.bsp.codec.DebugSessionParamsFormats
+  with sbt.internal.bsp.codec.TaskIdFormats
+  with sbt.internal.bsp.codec.TextDocumentIdentifierFormats
+  with sbt.internal.bsp.codec.PositionFormats
+  with sbt.internal.bsp.codec.RangeFormats
+  with sbt.internal.bsp.codec.DiagnosticFormats
+  with sbt.internal.bsp.codec.BuildClientCapabilitiesFormats
+  with sbt.internal.bsp.codec.InitializeBuildParamsFormats
+  with sbt.internal.bsp.codec.CompileProviderFormats
+  with sbt.internal.bsp.codec.TestProviderFormats
+  with sbt.internal.bsp.codec.RunProviderFormats
+  with sbt.internal.bsp.codec.BuildServerCapabilitiesFormats
+  with sbt.internal.bsp.codec.InitializeBuildResultFormats
+  with sbt.internal.bsp.codec.PublishDiagnosticsParamsFormats
+  with sbt.internal.bsp.codec.WorkspaceBuildTargetsResultFormats
+  with sbt.internal.bsp.codec.SourcesParamsFormats
+  with sbt.internal.bsp.codec.SourceItemFormats
+  with sbt.internal.bsp.codec.SourcesItemFormats
+  with sbt.internal.bsp.codec.SourcesResultFormats
+  with sbt.internal.bsp.codec.DependencySourcesParamsFormats
+  with sbt.internal.bsp.codec.DependencySourcesItemFormats
+  with sbt.internal.bsp.codec.DependencySourcesResultFormats
+  with sbt.internal.bsp.codec.TaskStartParamsFormats
+  with sbt.internal.bsp.codec.TaskFinishParamsFormats
+  with sbt.internal.bsp.codec.CompileParamsFormats
+  with sbt.internal.bsp.codec.BspCompileResultFormats
+  with sbt.internal.bsp.codec.CompileTaskFormats
+  with sbt.internal.bsp.codec.CompileReportFormats
+  with sbt.internal.bsp.codec.TestParamsFormats
+  with sbt.internal.bsp.codec.TestResultFormats
+  with sbt.internal.bsp.codec.RunParamsFormats
+  with sbt.internal.bsp.codec.RunResultFormats
+  with sbt.internal.bsp.codec.ScalaBuildTargetFormats
+  with sbt.internal.bsp.codec.SbtBuildTargetFormats
+  with sbt.internal.bsp.codec.ScalacOptionsParamsFormats
+  with sbt.internal.bsp.codec.ScalacOptionsItemFormats
+  with sbt.internal.bsp.codec.ScalacOptionsResultFormats
+  with sbt.internal.bsp.codec.BspConnectionDetailsFormats
+  with sbt.internal.bsp.codec.MetalsMetadataFormats
+  with sbt.internal.bsp.codec.ScalaTestClassesItemFormats
+  with sbt.internal.bsp.codec.ScalaTestParamsFormats
+  with sbt.internal.bsp.codec.ScalaTestClassesParamsFormats
+  with sbt.internal.bsp.codec.ScalaTestClassesResultFormats
+  with sbt.internal.bsp.codec.ScalaMainClassesParamsFormats
+  with sbt.internal.bsp.codec.ScalaMainClassFormats
+  with sbt.internal.bsp.codec.ScalaMainClassesItemFormats
+  with sbt.internal.bsp.codec.ScalaMainClassesResultFormats
+object JsonProtocol extends JsonProtocol
\ No newline at end of file
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/MetalsMetadataFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/MetalsMetadataFormats.scala
new file mode 100644
index 000000000..2e6a249fd
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/MetalsMetadataFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait MetalsMetadataFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val MetalsMetadataFormat: JsonFormat[sbt.internal.bsp.MetalsMetadata] = new JsonFormat[sbt.internal.bsp.MetalsMetadata] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.MetalsMetadata = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val semanticdbVersion = unbuilder.readField[String]("semanticdbVersion")
+      val supportedScalaVersions = unbuilder.readField[Vector[String]]("supportedScalaVersions")
+      unbuilder.endObject()
+      sbt.internal.bsp.MetalsMetadata(semanticdbVersion, supportedScalaVersions)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.MetalsMetadata, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("semanticdbVersion", obj.semanticdbVersion)
+    builder.addField("supportedScalaVersions", obj.supportedScalaVersions)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/PositionFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/PositionFormats.scala
new file mode 100644
index 000000000..1a8dcdd30
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/PositionFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val PositionFormat: JsonFormat[sbt.internal.bsp.Position] = new JsonFormat[sbt.internal.bsp.Position] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.Position = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val line = unbuilder.readField[Long]("line")
+      val character = unbuilder.readField[Long]("character")
+      unbuilder.endObject()
+      sbt.internal.bsp.Position(line, character)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.Position, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("line", obj.line)
+    builder.addField("character", obj.character)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/PublishDiagnosticsParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/PublishDiagnosticsParamsFormats.scala
new file mode 100644
index 000000000..0b5551c66
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/PublishDiagnosticsParamsFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PublishDiagnosticsParamsFormats { self: sbt.internal.bsp.codec.TextDocumentIdentifierFormats with sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sbt.internal.bsp.codec.DiagnosticFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val PublishDiagnosticsParamsFormat: JsonFormat[sbt.internal.bsp.PublishDiagnosticsParams] = new JsonFormat[sbt.internal.bsp.PublishDiagnosticsParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.PublishDiagnosticsParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val textDocument = unbuilder.readField[sbt.internal.bsp.TextDocumentIdentifier]("textDocument")
+      val buildTarget = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("buildTarget")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val diagnostics = unbuilder.readField[Vector[sbt.internal.bsp.Diagnostic]]("diagnostics")
+      val reset = unbuilder.readField[Boolean]("reset")
+      unbuilder.endObject()
+      sbt.internal.bsp.PublishDiagnosticsParams(textDocument, buildTarget, originId, diagnostics, reset)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.PublishDiagnosticsParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("textDocument", obj.textDocument)
+    builder.addField("buildTarget", obj.buildTarget)
+    builder.addField("originId", obj.originId)
+    builder.addField("diagnostics", obj.diagnostics)
+    builder.addField("reset", obj.reset)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RangeFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RangeFormats.scala
new file mode 100644
index 000000000..1f50ef349
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RangeFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait RangeFormats { self: sbt.internal.bsp.codec.PositionFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val RangeFormat: JsonFormat[sbt.internal.bsp.Range] = new JsonFormat[sbt.internal.bsp.Range] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.Range = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val start = unbuilder.readField[sbt.internal.bsp.Position]("start")
+      val end = unbuilder.readField[sbt.internal.bsp.Position]("end")
+      unbuilder.endObject()
+      sbt.internal.bsp.Range(start, end)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.Range, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("start", obj.start)
+    builder.addField("end", obj.end)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunParamsFormats.scala
new file mode 100644
index 000000000..808c53fcf
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunParamsFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait RunParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val RunParamsFormat: JsonFormat[sbt.internal.bsp.RunParams] = new JsonFormat[sbt.internal.bsp.RunParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.RunParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val arguments = unbuilder.readField[Vector[String]]("arguments")
+      val dataKind = unbuilder.readField[Option[String]]("dataKind")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.RunParams(target, originId, arguments, dataKind, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.RunParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("originId", obj.originId)
+    builder.addField("arguments", obj.arguments)
+    builder.addField("dataKind", obj.dataKind)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunProviderFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunProviderFormats.scala
new file mode 100644
index 000000000..09ec6eeae
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunProviderFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait RunProviderFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val RunProviderFormat: JsonFormat[sbt.internal.bsp.RunProvider] = new JsonFormat[sbt.internal.bsp.RunProvider] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.RunProvider = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val languageIds = unbuilder.readField[Vector[String]]("languageIds")
+      unbuilder.endObject()
+      sbt.internal.bsp.RunProvider(languageIds)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.RunProvider, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("languageIds", obj.languageIds)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunResultFormats.scala
new file mode 100644
index 000000000..b22aa7e82
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/RunResultFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait RunResultFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val RunResultFormat: JsonFormat[sbt.internal.bsp.RunResult] = new JsonFormat[sbt.internal.bsp.RunResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.RunResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val statusCode = unbuilder.readField[Int]("statusCode")
+      unbuilder.endObject()
+      sbt.internal.bsp.RunResult(originId, statusCode)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.RunResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("originId", obj.originId)
+    builder.addField("statusCode", obj.statusCode)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SbtBuildTargetFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SbtBuildTargetFormats.scala
new file mode 100644
index 000000000..788d26a98
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SbtBuildTargetFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SbtBuildTargetFormats { self: sbt.internal.bsp.codec.ScalaBuildTargetFormats with sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SbtBuildTargetFormat: JsonFormat[sbt.internal.bsp.SbtBuildTarget] = new JsonFormat[sbt.internal.bsp.SbtBuildTarget] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.SbtBuildTarget = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val sbtVersion = unbuilder.readField[String]("sbtVersion")
+      val autoImports = unbuilder.readField[Vector[String]]("autoImports")
+      val scalaBuildTarget = unbuilder.readField[sbt.internal.bsp.ScalaBuildTarget]("scalaBuildTarget")
+      val parent = unbuilder.readField[Option[sbt.internal.bsp.BuildTargetIdentifier]]("parent")
+      val children = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("children")
+      unbuilder.endObject()
+      sbt.internal.bsp.SbtBuildTarget(sbtVersion, autoImports, scalaBuildTarget, parent, children)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.SbtBuildTarget, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("sbtVersion", obj.sbtVersion)
+    builder.addField("autoImports", obj.autoImports)
+    builder.addField("scalaBuildTarget", obj.scalaBuildTarget)
+    builder.addField("parent", obj.parent)
+    builder.addField("children", obj.children)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaBuildTargetFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaBuildTargetFormats.scala
new file mode 100644
index 000000000..900994c4e
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaBuildTargetFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaBuildTargetFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaBuildTargetFormat: JsonFormat[sbt.internal.bsp.ScalaBuildTarget] = new JsonFormat[sbt.internal.bsp.ScalaBuildTarget] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaBuildTarget = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val scalaOrganization = unbuilder.readField[String]("scalaOrganization")
+      val scalaVersion = unbuilder.readField[String]("scalaVersion")
+      val scalaBinaryVersion = unbuilder.readField[String]("scalaBinaryVersion")
+      val platform = unbuilder.readField[Int]("platform")
+      val jars = unbuilder.readField[Vector[String]]("jars")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaBuildTarget(scalaOrganization, scalaVersion, scalaBinaryVersion, platform, jars)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaBuildTarget, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("scalaOrganization", obj.scalaOrganization)
+    builder.addField("scalaVersion", obj.scalaVersion)
+    builder.addField("scalaBinaryVersion", obj.scalaBinaryVersion)
+    builder.addField("platform", obj.platform)
+    builder.addField("jars", obj.jars)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassFormats.scala
new file mode 100644
index 000000000..a6fece2f4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassFormats.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaMainClassFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaMainClassFormat: JsonFormat[sbt.internal.bsp.ScalaMainClass] = new JsonFormat[sbt.internal.bsp.ScalaMainClass] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaMainClass = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val `class` = unbuilder.readField[String]("class")
+      val arguments = unbuilder.readField[Vector[String]]("arguments")
+      val jvmOptions = unbuilder.readField[Vector[String]]("jvmOptions")
+      val environmentVariables = unbuilder.readField[Vector[String]]("environmentVariables")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaMainClass(`class`, arguments, jvmOptions, environmentVariables)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaMainClass, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("class", obj.`class`)
+    builder.addField("arguments", obj.arguments)
+    builder.addField("jvmOptions", obj.jvmOptions)
+    builder.addField("environmentVariables", obj.environmentVariables)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesItemFormats.scala
new file mode 100644
index 000000000..2f96a2dc5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesItemFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaMainClassesItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sbt.internal.bsp.codec.ScalaMainClassFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaMainClassesItemFormat: JsonFormat[sbt.internal.bsp.ScalaMainClassesItem] = new JsonFormat[sbt.internal.bsp.ScalaMainClassesItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaMainClassesItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      val classes = unbuilder.readField[Vector[sbt.internal.bsp.ScalaMainClass]]("classes")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaMainClassesItem(target, classes)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaMainClassesItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("classes", obj.classes)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesParamsFormats.scala
new file mode 100644
index 000000000..18857df4f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesParamsFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaMainClassesParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaMainClassesParamsFormat: JsonFormat[sbt.internal.bsp.ScalaMainClassesParams] = new JsonFormat[sbt.internal.bsp.ScalaMainClassesParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaMainClassesParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaMainClassesParams(targets, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaMainClassesParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesResultFormats.scala
new file mode 100644
index 000000000..b7410be21
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaMainClassesResultFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaMainClassesResultFormats { self: sbt.internal.bsp.codec.ScalaMainClassesItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaMainClassesResultFormat: JsonFormat[sbt.internal.bsp.ScalaMainClassesResult] = new JsonFormat[sbt.internal.bsp.ScalaMainClassesResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaMainClassesResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[sbt.internal.bsp.ScalaMainClassesItem]]("items")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaMainClassesResult(items, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaMainClassesResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesItemFormats.scala
new file mode 100644
index 000000000..a079301b3
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesItemFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaTestClassesItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaTestClassesItemFormat: JsonFormat[sbt.internal.bsp.ScalaTestClassesItem] = new JsonFormat[sbt.internal.bsp.ScalaTestClassesItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaTestClassesItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      val classes = unbuilder.readField[Vector[String]]("classes")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaTestClassesItem(target, classes)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaTestClassesItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("classes", obj.classes)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesParamsFormats.scala
new file mode 100644
index 000000000..8a3cad4ae
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesParamsFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaTestClassesParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaTestClassesParamsFormat: JsonFormat[sbt.internal.bsp.ScalaTestClassesParams] = new JsonFormat[sbt.internal.bsp.ScalaTestClassesParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaTestClassesParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaTestClassesParams(targets, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaTestClassesParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesResultFormats.scala
new file mode 100644
index 000000000..ab51a7bb2
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestClassesResultFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaTestClassesResultFormats { self: sbt.internal.bsp.codec.ScalaTestClassesItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaTestClassesResultFormat: JsonFormat[sbt.internal.bsp.ScalaTestClassesResult] = new JsonFormat[sbt.internal.bsp.ScalaTestClassesResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaTestClassesResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[sbt.internal.bsp.ScalaTestClassesItem]]("items")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaTestClassesResult(items, originId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaTestClassesResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.addField("originId", obj.originId)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestParamsFormats.scala
new file mode 100644
index 000000000..3837db231
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalaTestParamsFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalaTestParamsFormats { self: sbt.internal.bsp.codec.ScalaTestClassesItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalaTestParamsFormat: JsonFormat[sbt.internal.bsp.ScalaTestParams] = new JsonFormat[sbt.internal.bsp.ScalaTestParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalaTestParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val testClasses = unbuilder.readField[Vector[sbt.internal.bsp.ScalaTestClassesItem]]("testClasses")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalaTestParams(testClasses)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalaTestParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("testClasses", obj.testClasses)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsItemFormats.scala
new file mode 100644
index 000000000..29d7d0b68
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsItemFormats.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalacOptionsItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalacOptionsItemFormat: JsonFormat[sbt.internal.bsp.ScalacOptionsItem] = new JsonFormat[sbt.internal.bsp.ScalacOptionsItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalacOptionsItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      val options = unbuilder.readField[Vector[String]]("options")
+      val classpath = unbuilder.readField[Vector[java.net.URI]]("classpath")
+      val classDirectory = unbuilder.readField[Option[java.net.URI]]("classDirectory")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalacOptionsItem(target, options, classpath, classDirectory)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalacOptionsItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("options", obj.options)
+    builder.addField("classpath", obj.classpath)
+    builder.addField("classDirectory", obj.classDirectory)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsParamsFormats.scala
new file mode 100644
index 000000000..7d80d1118
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsParamsFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalacOptionsParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalacOptionsParamsFormat: JsonFormat[sbt.internal.bsp.ScalacOptionsParams] = new JsonFormat[sbt.internal.bsp.ScalacOptionsParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalacOptionsParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalacOptionsParams(targets)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalacOptionsParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsResultFormats.scala
new file mode 100644
index 000000000..ac7a2863b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/ScalacOptionsResultFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScalacOptionsResultFormats { self: sbt.internal.bsp.codec.ScalacOptionsItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScalacOptionsResultFormat: JsonFormat[sbt.internal.bsp.ScalacOptionsResult] = new JsonFormat[sbt.internal.bsp.ScalacOptionsResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.ScalacOptionsResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[sbt.internal.bsp.ScalacOptionsItem]]("items")
+      unbuilder.endObject()
+      sbt.internal.bsp.ScalacOptionsResult(items)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.ScalacOptionsResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourceItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourceItemFormats.scala
new file mode 100644
index 000000000..63e843b7e
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourceItemFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SourceItemFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val SourceItemFormat: JsonFormat[sbt.internal.bsp.SourceItem] = new JsonFormat[sbt.internal.bsp.SourceItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.SourceItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[java.net.URI]("uri")
+      val kind = unbuilder.readField[Int]("kind")
+      val generated = unbuilder.readField[Boolean]("generated")
+      unbuilder.endObject()
+      sbt.internal.bsp.SourceItem(uri, kind, generated)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.SourceItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.addField("kind", obj.kind)
+    builder.addField("generated", obj.generated)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesItemFormats.scala
new file mode 100644
index 000000000..6862a8575
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesItemFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SourcesItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sbt.internal.bsp.codec.SourceItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SourcesItemFormat: JsonFormat[sbt.internal.bsp.SourcesItem] = new JsonFormat[sbt.internal.bsp.SourcesItem] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.SourcesItem = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target")
+      val sources = unbuilder.readField[Vector[sbt.internal.bsp.SourceItem]]("sources")
+      unbuilder.endObject()
+      sbt.internal.bsp.SourcesItem(target, sources)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.SourcesItem, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("target", obj.target)
+    builder.addField("sources", obj.sources)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesParamsFormats.scala
new file mode 100644
index 000000000..99322474d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesParamsFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SourcesParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SourcesParamsFormat: JsonFormat[sbt.internal.bsp.SourcesParams] = new JsonFormat[sbt.internal.bsp.SourcesParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.SourcesParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      unbuilder.endObject()
+      sbt.internal.bsp.SourcesParams(targets)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.SourcesParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesResultFormats.scala
new file mode 100644
index 000000000..d021e1e4f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/SourcesResultFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SourcesResultFormats { self: sbt.internal.bsp.codec.SourcesItemFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SourcesResultFormat: JsonFormat[sbt.internal.bsp.SourcesResult] = new JsonFormat[sbt.internal.bsp.SourcesResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.SourcesResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[sbt.internal.bsp.SourcesItem]]("items")
+      unbuilder.endObject()
+      sbt.internal.bsp.SourcesResult(items)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.SourcesResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskFinishParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskFinishParamsFormats.scala
new file mode 100644
index 000000000..d9186fe33
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskFinishParamsFormats.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TaskFinishParamsFormats { self: sbt.internal.bsp.codec.TaskIdFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TaskFinishParamsFormat: JsonFormat[sbt.internal.bsp.TaskFinishParams] = new JsonFormat[sbt.internal.bsp.TaskFinishParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.TaskFinishParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val taskId = unbuilder.readField[sbt.internal.bsp.TaskId]("taskId")
+      val eventTime = unbuilder.readField[Option[Long]]("eventTime")
+      val message = unbuilder.readField[Option[String]]("message")
+      val status = unbuilder.readField[Int]("status")
+      val dataKind = unbuilder.readField[Option[String]]("dataKind")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.TaskFinishParams(taskId, eventTime, message, status, dataKind, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.TaskFinishParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("taskId", obj.taskId)
+    builder.addField("eventTime", obj.eventTime)
+    builder.addField("message", obj.message)
+    builder.addField("status", obj.status)
+    builder.addField("dataKind", obj.dataKind)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskIdFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskIdFormats.scala
new file mode 100644
index 000000000..55c52734e
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskIdFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TaskIdFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TaskIdFormat: JsonFormat[sbt.internal.bsp.TaskId] = new JsonFormat[sbt.internal.bsp.TaskId] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.TaskId = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val id = unbuilder.readField[String]("id")
+      val parents = unbuilder.readField[Vector[String]]("parents")
+      unbuilder.endObject()
+      sbt.internal.bsp.TaskId(id, parents)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.TaskId, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("id", obj.id)
+    builder.addField("parents", obj.parents)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskStartParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskStartParamsFormats.scala
new file mode 100644
index 000000000..a6f4ef766
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TaskStartParamsFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TaskStartParamsFormats { self: sbt.internal.bsp.codec.TaskIdFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TaskStartParamsFormat: JsonFormat[sbt.internal.bsp.TaskStartParams] = new JsonFormat[sbt.internal.bsp.TaskStartParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.TaskStartParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val taskId = unbuilder.readField[sbt.internal.bsp.TaskId]("taskId")
+      val eventTime = unbuilder.readField[Option[Long]]("eventTime")
+      val message = unbuilder.readField[Option[String]]("message")
+      val dataKind = unbuilder.readField[Option[String]]("dataKind")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.TaskStartParams(taskId, eventTime, message, dataKind, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.TaskStartParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("taskId", obj.taskId)
+    builder.addField("eventTime", obj.eventTime)
+    builder.addField("message", obj.message)
+    builder.addField("dataKind", obj.dataKind)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestParamsFormats.scala
new file mode 100644
index 000000000..7e07dd188
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestParamsFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestParamsFormat: JsonFormat[sbt.internal.bsp.TestParams] = new JsonFormat[sbt.internal.bsp.TestParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.TestParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets")
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val arguments = unbuilder.readField[Vector[String]]("arguments")
+      val dataKind = unbuilder.readField[Option[String]]("dataKind")
+      val data = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("data")
+      unbuilder.endObject()
+      sbt.internal.bsp.TestParams(targets, originId, arguments, dataKind, data)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.TestParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.addField("originId", obj.originId)
+    builder.addField("arguments", obj.arguments)
+    builder.addField("dataKind", obj.dataKind)
+    builder.addField("data", obj.data)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestProviderFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestProviderFormats.scala
new file mode 100644
index 000000000..4a36c57c1
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestProviderFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestProviderFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestProviderFormat: JsonFormat[sbt.internal.bsp.TestProvider] = new JsonFormat[sbt.internal.bsp.TestProvider] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.TestProvider = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val languageIds = unbuilder.readField[Vector[String]]("languageIds")
+      unbuilder.endObject()
+      sbt.internal.bsp.TestProvider(languageIds)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.TestProvider, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("languageIds", obj.languageIds)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestResultFormats.scala
new file mode 100644
index 000000000..2b6d99abd
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TestResultFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestResultFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestResultFormat: JsonFormat[sbt.internal.bsp.TestResult] = new JsonFormat[sbt.internal.bsp.TestResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.TestResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val originId = unbuilder.readField[Option[String]]("originId")
+      val statusCode = unbuilder.readField[Int]("statusCode")
+      unbuilder.endObject()
+      sbt.internal.bsp.TestResult(originId, statusCode)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.TestResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("originId", obj.originId)
+    builder.addField("statusCode", obj.statusCode)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TextDocumentIdentifierFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TextDocumentIdentifierFormats.scala
new file mode 100644
index 000000000..b61f50774
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/TextDocumentIdentifierFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TextDocumentIdentifierFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TextDocumentIdentifierFormat: JsonFormat[sbt.internal.bsp.TextDocumentIdentifier] = new JsonFormat[sbt.internal.bsp.TextDocumentIdentifier] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.TextDocumentIdentifier = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[java.net.URI]("uri")
+      unbuilder.endObject()
+      sbt.internal.bsp.TextDocumentIdentifier(uri)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.TextDocumentIdentifier, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/WorkspaceBuildTargetsResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/WorkspaceBuildTargetsResultFormats.scala
new file mode 100644
index 000000000..d21532d72
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/WorkspaceBuildTargetsResultFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.bsp.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait WorkspaceBuildTargetsResultFormats { self: sbt.internal.bsp.codec.BuildTargetFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val WorkspaceBuildTargetsResultFormat: JsonFormat[sbt.internal.bsp.WorkspaceBuildTargetsResult] = new JsonFormat[sbt.internal.bsp.WorkspaceBuildTargetsResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.WorkspaceBuildTargetsResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTarget]]("targets")
+      unbuilder.endObject()
+      sbt.internal.bsp.WorkspaceBuildTargetsResult(targets)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.bsp.WorkspaceBuildTargetsResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("targets", obj.targets)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/CancelRequestParams.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/CancelRequestParams.scala
new file mode 100644
index 000000000..377fabc33
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/CancelRequestParams.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/** Id for a cancel request */
+final class CancelRequestParams private (
+  val id: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CancelRequestParams => (this.id == x.id)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.langserver.CancelRequestParams".##) + id.##)
+  }
+  override def toString: String = {
+    "CancelRequestParams(" + id + ")"
+  }
+  private[this] def copy(id: String = id): CancelRequestParams = {
+    new CancelRequestParams(id)
+  }
+  def withId(id: String): CancelRequestParams = {
+    copy(id = id)
+  }
+}
+object CancelRequestParams {
+  
+  def apply(id: String): CancelRequestParams = new CancelRequestParams(id)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/ClientCapabilities.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/ClientCapabilities.scala
new file mode 100644
index 000000000..5a0b2329d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/ClientCapabilities.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+final class ClientCapabilities private () extends Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: ClientCapabilities => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.internal.langserver.ClientCapabilities".##)
+}
+override def toString: String = {
+  "ClientCapabilities()"
+}
+private[this] def copy(): ClientCapabilities = {
+  new ClientCapabilities()
+}
+
+}
+object ClientCapabilities {
+  
+  def apply(): ClientCapabilities = new ClientCapabilities()
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/Diagnostic.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/Diagnostic.scala
new file mode 100644
index 000000000..927d2e7e1
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Diagnostic.scala
@@ -0,0 +1,69 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * Represents a diagnostic, such as a compiler error or warning.
+ * Diagnostic objects are only valid in the scope of a resource.
+ * @param range The range at which the message applies.
+ * @param severity The diagnostic's severity. Can be omitted. If omitted it is up to the
+                   client to interpret diagnostics as error, warning, info or hint.
+ * @param code The diagnostic's code. Can be omitted.
+ * @param source A human-readable string describing the source of this
+                 diagnostic, e.g. 'typescript' or 'super lint'.
+ * @param message The diagnostic's message.
+ */
+final class Diagnostic private (
+  val range: sbt.internal.langserver.Range,
+  val severity: Option[Long],
+  val code: Option[String],
+  val source: Option[String],
+  val message: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Diagnostic => (this.range == x.range) && (this.severity == x.severity) && (this.code == x.code) && (this.source == x.source) && (this.message == x.message)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.langserver.Diagnostic".##) + range.##) + severity.##) + code.##) + source.##) + message.##)
+  }
+  override def toString: String = {
+    "Diagnostic(" + range + ", " + severity + ", " + code + ", " + source + ", " + message + ")"
+  }
+  private[this] def copy(range: sbt.internal.langserver.Range = range, severity: Option[Long] = severity, code: Option[String] = code, source: Option[String] = source, message: String = message): Diagnostic = {
+    new Diagnostic(range, severity, code, source, message)
+  }
+  def withRange(range: sbt.internal.langserver.Range): Diagnostic = {
+    copy(range = range)
+  }
+  def withSeverity(severity: Option[Long]): Diagnostic = {
+    copy(severity = severity)
+  }
+  def withSeverity(severity: Long): Diagnostic = {
+    copy(severity = Option(severity))
+  }
+  def withCode(code: Option[String]): Diagnostic = {
+    copy(code = code)
+  }
+  def withCode(code: String): Diagnostic = {
+    copy(code = Option(code))
+  }
+  def withSource(source: Option[String]): Diagnostic = {
+    copy(source = source)
+  }
+  def withSource(source: String): Diagnostic = {
+    copy(source = Option(source))
+  }
+  def withMessage(message: String): Diagnostic = {
+    copy(message = message)
+  }
+}
+object Diagnostic {
+  
+  def apply(range: sbt.internal.langserver.Range, severity: Option[Long], code: Option[String], source: Option[String], message: String): Diagnostic = new Diagnostic(range, severity, code, source, message)
+  def apply(range: sbt.internal.langserver.Range, severity: Long, code: String, source: String, message: String): Diagnostic = new Diagnostic(range, Option(severity), Option(code), Option(source), message)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeParams.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeParams.scala
new file mode 100644
index 000000000..eadda5d4b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeParams.scala
@@ -0,0 +1,72 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/** @param rootPath The rootPath of the workspace. */
+final class InitializeParams private (
+  val processId: Option[Long],
+  val rootPath: Option[String],
+  val rootUri: Option[String],
+  val initializationOptions: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue],
+  val capabilities: Option[sbt.internal.langserver.ClientCapabilities],
+  val trace: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: InitializeParams => (this.processId == x.processId) && (this.rootPath == x.rootPath) && (this.rootUri == x.rootUri) && (this.initializationOptions == x.initializationOptions) && (this.capabilities == x.capabilities) && (this.trace == x.trace)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.langserver.InitializeParams".##) + processId.##) + rootPath.##) + rootUri.##) + initializationOptions.##) + capabilities.##) + trace.##)
+  }
+  override def toString: String = {
+    "InitializeParams(" + processId + ", " + rootPath + ", " + rootUri + ", " + initializationOptions + ", " + capabilities + ", " + trace + ")"
+  }
+  private[this] def copy(processId: Option[Long] = processId, rootPath: Option[String] = rootPath, rootUri: Option[String] = rootUri, initializationOptions: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = initializationOptions, capabilities: Option[sbt.internal.langserver.ClientCapabilities] = capabilities, trace: Option[String] = trace): InitializeParams = {
+    new InitializeParams(processId, rootPath, rootUri, initializationOptions, capabilities, trace)
+  }
+  def withProcessId(processId: Option[Long]): InitializeParams = {
+    copy(processId = processId)
+  }
+  def withProcessId(processId: Long): InitializeParams = {
+    copy(processId = Option(processId))
+  }
+  def withRootPath(rootPath: Option[String]): InitializeParams = {
+    copy(rootPath = rootPath)
+  }
+  def withRootPath(rootPath: String): InitializeParams = {
+    copy(rootPath = Option(rootPath))
+  }
+  def withRootUri(rootUri: Option[String]): InitializeParams = {
+    copy(rootUri = rootUri)
+  }
+  def withRootUri(rootUri: String): InitializeParams = {
+    copy(rootUri = Option(rootUri))
+  }
+  def withInitializationOptions(initializationOptions: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): InitializeParams = {
+    copy(initializationOptions = initializationOptions)
+  }
+  def withInitializationOptions(initializationOptions: sjsonnew.shaded.scalajson.ast.unsafe.JValue): InitializeParams = {
+    copy(initializationOptions = Option(initializationOptions))
+  }
+  def withCapabilities(capabilities: Option[sbt.internal.langserver.ClientCapabilities]): InitializeParams = {
+    copy(capabilities = capabilities)
+  }
+  def withCapabilities(capabilities: sbt.internal.langserver.ClientCapabilities): InitializeParams = {
+    copy(capabilities = Option(capabilities))
+  }
+  def withTrace(trace: Option[String]): InitializeParams = {
+    copy(trace = trace)
+  }
+  def withTrace(trace: String): InitializeParams = {
+    copy(trace = Option(trace))
+  }
+}
+object InitializeParams {
+  
+  def apply(processId: Option[Long], rootPath: Option[String], rootUri: Option[String], initializationOptions: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue], capabilities: Option[sbt.internal.langserver.ClientCapabilities], trace: Option[String]): InitializeParams = new InitializeParams(processId, rootPath, rootUri, initializationOptions, capabilities, trace)
+  def apply(processId: Long, rootPath: String, rootUri: String, initializationOptions: sjsonnew.shaded.scalajson.ast.unsafe.JValue, capabilities: sbt.internal.langserver.ClientCapabilities, trace: String): InitializeParams = new InitializeParams(Option(processId), Option(rootPath), Option(rootUri), Option(initializationOptions), Option(capabilities), Option(trace))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeResult.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeResult.scala
new file mode 100644
index 000000000..38785b20c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeResult.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/** @param capabilities The capabilities the language server provides. */
+final class InitializeResult private (
+  val capabilities: sbt.internal.langserver.ServerCapabilities) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: InitializeResult => (this.capabilities == x.capabilities)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.langserver.InitializeResult".##) + capabilities.##)
+  }
+  override def toString: String = {
+    "InitializeResult(" + capabilities + ")"
+  }
+  private[this] def copy(capabilities: sbt.internal.langserver.ServerCapabilities = capabilities): InitializeResult = {
+    new InitializeResult(capabilities)
+  }
+  def withCapabilities(capabilities: sbt.internal.langserver.ServerCapabilities): InitializeResult = {
+    copy(capabilities = capabilities)
+  }
+}
+object InitializeResult {
+  
+  def apply(capabilities: sbt.internal.langserver.ServerCapabilities): InitializeResult = new InitializeResult(capabilities)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/Location.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/Location.scala
new file mode 100644
index 000000000..2e2300905
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Location.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/** Represents a location inside a resource, such as a line inside a text file. */
+final class Location private (
+  val uri: String,
+  val range: sbt.internal.langserver.Range) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Location => (this.uri == x.uri) && (this.range == x.range)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.langserver.Location".##) + uri.##) + range.##)
+  }
+  override def toString: String = {
+    "Location(" + uri + ", " + range + ")"
+  }
+  private[this] def copy(uri: String = uri, range: sbt.internal.langserver.Range = range): Location = {
+    new Location(uri, range)
+  }
+  def withUri(uri: String): Location = {
+    copy(uri = uri)
+  }
+  def withRange(range: sbt.internal.langserver.Range): Location = {
+    copy(range = range)
+  }
+}
+object Location {
+  
+  def apply(uri: String, range: sbt.internal.langserver.Range): Location = new Location(uri, range)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/LogMessageParams.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/LogMessageParams.scala
new file mode 100644
index 000000000..ee9b1684a
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/LogMessageParams.scala
@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * @param type The message type.
+ * @param message The actual message
+ */
+final class LogMessageParams private (
+  val `type`: Long,
+  val message: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: LogMessageParams => (this.`type` == x.`type`) && (this.message == x.message)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.langserver.LogMessageParams".##) + `type`.##) + message.##)
+  }
+  override def toString: String = {
+    "LogMessageParams(" + `type` + ", " + message + ")"
+  }
+  private[this] def copy(`type`: Long = `type`, message: String = message): LogMessageParams = {
+    new LogMessageParams(`type`, message)
+  }
+  def withType(`type`: Long): LogMessageParams = {
+    copy(`type` = `type`)
+  }
+  def withMessage(message: String): LogMessageParams = {
+    copy(message = message)
+  }
+}
+object LogMessageParams {
+  
+  def apply(`type`: Long, message: String): LogMessageParams = new LogMessageParams(`type`, message)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/Position.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/Position.scala
new file mode 100644
index 000000000..05de12ba4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Position.scala
@@ -0,0 +1,42 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * Position in a text document expressed as zero-based line and zero-based character offset.
+ * A position is between two characters like an 'insert' cursor in a editor.
+ * @param line Line position in a document (zero-based).
+ * @param character Character offset on a line in a document (zero-based).
+ */
+final class Position private (
+  val line: Long,
+  val character: Long) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Position => (this.line == x.line) && (this.character == x.character)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.langserver.Position".##) + line.##) + character.##)
+  }
+  override def toString: String = {
+    "Position(" + line + ", " + character + ")"
+  }
+  private[this] def copy(line: Long = line, character: Long = character): Position = {
+    new Position(line, character)
+  }
+  def withLine(line: Long): Position = {
+    copy(line = line)
+  }
+  def withCharacter(character: Long): Position = {
+    copy(character = character)
+  }
+}
+object Position {
+  
+  def apply(line: Long, character: Long): Position = new Position(line, character)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/PublishDiagnosticsParams.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/PublishDiagnosticsParams.scala
new file mode 100644
index 000000000..36c01f93b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/PublishDiagnosticsParams.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * Diagnostics notification are sent from the server to the client to signal results of validation runs.
+ * @param uri The URI for which diagnostic information is reported.
+ * @param diagnostics An array of diagnostic information items.
+ */
+final class PublishDiagnosticsParams private (
+  val uri: String,
+  val diagnostics: Vector[sbt.internal.langserver.Diagnostic]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: PublishDiagnosticsParams => (this.uri == x.uri) && (this.diagnostics == x.diagnostics)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.langserver.PublishDiagnosticsParams".##) + uri.##) + diagnostics.##)
+  }
+  override def toString: String = {
+    "PublishDiagnosticsParams(" + uri + ", " + diagnostics + ")"
+  }
+  private[this] def copy(uri: String = uri, diagnostics: Vector[sbt.internal.langserver.Diagnostic] = diagnostics): PublishDiagnosticsParams = {
+    new PublishDiagnosticsParams(uri, diagnostics)
+  }
+  def withUri(uri: String): PublishDiagnosticsParams = {
+    copy(uri = uri)
+  }
+  def withDiagnostics(diagnostics: Vector[sbt.internal.langserver.Diagnostic]): PublishDiagnosticsParams = {
+    copy(diagnostics = diagnostics)
+  }
+}
+object PublishDiagnosticsParams {
+  
+  def apply(uri: String, diagnostics: Vector[sbt.internal.langserver.Diagnostic]): PublishDiagnosticsParams = new PublishDiagnosticsParams(uri, diagnostics)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/Range.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/Range.scala
new file mode 100644
index 000000000..ea9f01f46
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Range.scala
@@ -0,0 +1,42 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * A range in a text document expressed as (zero-based) start and end positions. A range is comparable to a selection in an editor.
+ * Therefore the end position is exclusive.
+ * @param start The range's start position.
+ * @param end The range's end position.
+ */
+final class Range private (
+  val start: sbt.internal.langserver.Position,
+  val end: sbt.internal.langserver.Position) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Range => (this.start == x.start) && (this.end == x.end)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.langserver.Range".##) + start.##) + end.##)
+  }
+  override def toString: String = {
+    "Range(" + start + ", " + end + ")"
+  }
+  private[this] def copy(start: sbt.internal.langserver.Position = start, end: sbt.internal.langserver.Position = end): Range = {
+    new Range(start, end)
+  }
+  def withStart(start: sbt.internal.langserver.Position): Range = {
+    copy(start = start)
+  }
+  def withEnd(end: sbt.internal.langserver.Position): Range = {
+    copy(end = end)
+  }
+}
+object Range {
+  
+  def apply(start: sbt.internal.langserver.Position, end: sbt.internal.langserver.Position): Range = new Range(start, end)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/SaveOptions.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/SaveOptions.scala
new file mode 100644
index 000000000..32847730d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/SaveOptions.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/** @param includeText The client is supposed to include the content on save. */
+final class SaveOptions private (
+  val includeText: Option[Boolean]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SaveOptions => (this.includeText == x.includeText)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.langserver.SaveOptions".##) + includeText.##)
+  }
+  override def toString: String = {
+    "SaveOptions(" + includeText + ")"
+  }
+  private[this] def copy(includeText: Option[Boolean] = includeText): SaveOptions = {
+    new SaveOptions(includeText)
+  }
+  def withIncludeText(includeText: Option[Boolean]): SaveOptions = {
+    copy(includeText = includeText)
+  }
+  def withIncludeText(includeText: Boolean): SaveOptions = {
+    copy(includeText = Option(includeText))
+  }
+}
+object SaveOptions {
+  
+  def apply(includeText: Option[Boolean]): SaveOptions = new SaveOptions(includeText)
+  def apply(includeText: Boolean): SaveOptions = new SaveOptions(Option(includeText))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/SbtExecParams.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/SbtExecParams.scala
new file mode 100644
index 000000000..46f4c8cae
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/SbtExecParams.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/** Command to execute sbt command. */
+final class SbtExecParams private (
+  val commandLine: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SbtExecParams => (this.commandLine == x.commandLine)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.langserver.SbtExecParams".##) + commandLine.##)
+  }
+  override def toString: String = {
+    "SbtExecParams(" + commandLine + ")"
+  }
+  private[this] def copy(commandLine: String = commandLine): SbtExecParams = {
+    new SbtExecParams(commandLine)
+  }
+  def withCommandLine(commandLine: String): SbtExecParams = {
+    copy(commandLine = commandLine)
+  }
+}
+object SbtExecParams {
+  
+  def apply(commandLine: String): SbtExecParams = new SbtExecParams(commandLine)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/ServerCapabilities.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/ServerCapabilities.scala
new file mode 100644
index 000000000..d45fb6c8d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/ServerCapabilities.scala
@@ -0,0 +1,54 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * @param hoverProvider The server provides hover support.
+ * @param definitionProvider Goto definition
+ */
+final class ServerCapabilities private (
+  val textDocumentSync: Option[sbt.internal.langserver.TextDocumentSyncOptions],
+  val hoverProvider: Option[Boolean],
+  val definitionProvider: Option[Boolean]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ServerCapabilities => (this.textDocumentSync == x.textDocumentSync) && (this.hoverProvider == x.hoverProvider) && (this.definitionProvider == x.definitionProvider)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.langserver.ServerCapabilities".##) + textDocumentSync.##) + hoverProvider.##) + definitionProvider.##)
+  }
+  override def toString: String = {
+    "ServerCapabilities(" + textDocumentSync + ", " + hoverProvider + ", " + definitionProvider + ")"
+  }
+  private[this] def copy(textDocumentSync: Option[sbt.internal.langserver.TextDocumentSyncOptions] = textDocumentSync, hoverProvider: Option[Boolean] = hoverProvider, definitionProvider: Option[Boolean] = definitionProvider): ServerCapabilities = {
+    new ServerCapabilities(textDocumentSync, hoverProvider, definitionProvider)
+  }
+  def withTextDocumentSync(textDocumentSync: Option[sbt.internal.langserver.TextDocumentSyncOptions]): ServerCapabilities = {
+    copy(textDocumentSync = textDocumentSync)
+  }
+  def withTextDocumentSync(textDocumentSync: sbt.internal.langserver.TextDocumentSyncOptions): ServerCapabilities = {
+    copy(textDocumentSync = Option(textDocumentSync))
+  }
+  def withHoverProvider(hoverProvider: Option[Boolean]): ServerCapabilities = {
+    copy(hoverProvider = hoverProvider)
+  }
+  def withHoverProvider(hoverProvider: Boolean): ServerCapabilities = {
+    copy(hoverProvider = Option(hoverProvider))
+  }
+  def withDefinitionProvider(definitionProvider: Option[Boolean]): ServerCapabilities = {
+    copy(definitionProvider = definitionProvider)
+  }
+  def withDefinitionProvider(definitionProvider: Boolean): ServerCapabilities = {
+    copy(definitionProvider = Option(definitionProvider))
+  }
+}
+object ServerCapabilities {
+  
+  def apply(textDocumentSync: Option[sbt.internal.langserver.TextDocumentSyncOptions], hoverProvider: Option[Boolean], definitionProvider: Option[Boolean]): ServerCapabilities = new ServerCapabilities(textDocumentSync, hoverProvider, definitionProvider)
+  def apply(textDocumentSync: sbt.internal.langserver.TextDocumentSyncOptions, hoverProvider: Boolean, definitionProvider: Boolean): ServerCapabilities = new ServerCapabilities(Option(textDocumentSync), Option(hoverProvider), Option(definitionProvider))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentIdentifier.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentIdentifier.scala
new file mode 100644
index 000000000..3a9a1d01c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentIdentifier.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * Text documents are identified using a URI. On the protocol level, URIs are passed as strings.
+ * @param uri The text document's URI.
+ */
+final class TextDocumentIdentifier private (
+  val uri: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TextDocumentIdentifier => (this.uri == x.uri)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.langserver.TextDocumentIdentifier".##) + uri.##)
+  }
+  override def toString: String = {
+    "TextDocumentIdentifier(" + uri + ")"
+  }
+  private[this] def copy(uri: String = uri): TextDocumentIdentifier = {
+    new TextDocumentIdentifier(uri)
+  }
+  def withUri(uri: String): TextDocumentIdentifier = {
+    copy(uri = uri)
+  }
+}
+object TextDocumentIdentifier {
+  
+  def apply(uri: String): TextDocumentIdentifier = new TextDocumentIdentifier(uri)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParams.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParams.scala
new file mode 100644
index 000000000..7ce1c05e3
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParams.scala
@@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/**
+ * @param textDocument The text document.
+ * @param position The position inside the text document.
+ */
+final class TextDocumentPositionParams private (
+  textDocument: sbt.internal.langserver.TextDocumentIdentifier,
+  position: sbt.internal.langserver.Position) extends sbt.internal.langserver.TextDocumentPositionParamsInterface(textDocument, position) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TextDocumentPositionParams => (this.textDocument == x.textDocument) && (this.position == x.position)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.langserver.TextDocumentPositionParams".##) + textDocument.##) + position.##)
+  }
+  override def toString: String = {
+    "TextDocumentPositionParams(" + textDocument + ", " + position + ")"
+  }
+  private[this] def copy(textDocument: sbt.internal.langserver.TextDocumentIdentifier = textDocument, position: sbt.internal.langserver.Position = position): TextDocumentPositionParams = {
+    new TextDocumentPositionParams(textDocument, position)
+  }
+  def withTextDocument(textDocument: sbt.internal.langserver.TextDocumentIdentifier): TextDocumentPositionParams = {
+    copy(textDocument = textDocument)
+  }
+  def withPosition(position: sbt.internal.langserver.Position): TextDocumentPositionParams = {
+    copy(position = position)
+  }
+}
+object TextDocumentPositionParams {
+  
+  def apply(textDocument: sbt.internal.langserver.TextDocumentIdentifier, position: sbt.internal.langserver.Position): TextDocumentPositionParams = new TextDocumentPositionParams(textDocument, position)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParamsInterface.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParamsInterface.scala
new file mode 100644
index 000000000..ad4fc5bd8
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParamsInterface.scala
@@ -0,0 +1,28 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+/** Goto definition params model */
+abstract class TextDocumentPositionParamsInterface(
+  val textDocument: sbt.internal.langserver.TextDocumentIdentifier,
+  val position: sbt.internal.langserver.Position) extends Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TextDocumentPositionParamsInterface => (this.textDocument == x.textDocument) && (this.position == x.position)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.langserver.TextDocumentPositionParamsInterface".##) + textDocument.##) + position.##)
+  }
+  override def toString: String = {
+    "TextDocumentPositionParamsInterface(" + textDocument + ", " + position + ")"
+  }
+}
+object TextDocumentPositionParamsInterface {
+  
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentSyncOptions.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentSyncOptions.scala
new file mode 100644
index 000000000..43d9ef68c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentSyncOptions.scala
@@ -0,0 +1,64 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver
+final class TextDocumentSyncOptions private (
+  val openClose: Option[Boolean],
+  val change: Option[Long],
+  val willSave: Option[Boolean],
+  val willSaveWaitUntil: Option[Boolean],
+  val save: Option[sbt.internal.langserver.SaveOptions]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TextDocumentSyncOptions => (this.openClose == x.openClose) && (this.change == x.change) && (this.willSave == x.willSave) && (this.willSaveWaitUntil == x.willSaveWaitUntil) && (this.save == x.save)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.langserver.TextDocumentSyncOptions".##) + openClose.##) + change.##) + willSave.##) + willSaveWaitUntil.##) + save.##)
+  }
+  override def toString: String = {
+    "TextDocumentSyncOptions(" + openClose + ", " + change + ", " + willSave + ", " + willSaveWaitUntil + ", " + save + ")"
+  }
+  private[this] def copy(openClose: Option[Boolean] = openClose, change: Option[Long] = change, willSave: Option[Boolean] = willSave, willSaveWaitUntil: Option[Boolean] = willSaveWaitUntil, save: Option[sbt.internal.langserver.SaveOptions] = save): TextDocumentSyncOptions = {
+    new TextDocumentSyncOptions(openClose, change, willSave, willSaveWaitUntil, save)
+  }
+  def withOpenClose(openClose: Option[Boolean]): TextDocumentSyncOptions = {
+    copy(openClose = openClose)
+  }
+  def withOpenClose(openClose: Boolean): TextDocumentSyncOptions = {
+    copy(openClose = Option(openClose))
+  }
+  def withChange(change: Option[Long]): TextDocumentSyncOptions = {
+    copy(change = change)
+  }
+  def withChange(change: Long): TextDocumentSyncOptions = {
+    copy(change = Option(change))
+  }
+  def withWillSave(willSave: Option[Boolean]): TextDocumentSyncOptions = {
+    copy(willSave = willSave)
+  }
+  def withWillSave(willSave: Boolean): TextDocumentSyncOptions = {
+    copy(willSave = Option(willSave))
+  }
+  def withWillSaveWaitUntil(willSaveWaitUntil: Option[Boolean]): TextDocumentSyncOptions = {
+    copy(willSaveWaitUntil = willSaveWaitUntil)
+  }
+  def withWillSaveWaitUntil(willSaveWaitUntil: Boolean): TextDocumentSyncOptions = {
+    copy(willSaveWaitUntil = Option(willSaveWaitUntil))
+  }
+  def withSave(save: Option[sbt.internal.langserver.SaveOptions]): TextDocumentSyncOptions = {
+    copy(save = save)
+  }
+  def withSave(save: sbt.internal.langserver.SaveOptions): TextDocumentSyncOptions = {
+    copy(save = Option(save))
+  }
+}
+object TextDocumentSyncOptions {
+  
+  def apply(openClose: Option[Boolean], change: Option[Long], willSave: Option[Boolean], willSaveWaitUntil: Option[Boolean], save: Option[sbt.internal.langserver.SaveOptions]): TextDocumentSyncOptions = new TextDocumentSyncOptions(openClose, change, willSave, willSaveWaitUntil, save)
+  def apply(openClose: Boolean, change: Long, willSave: Boolean, willSaveWaitUntil: Boolean, save: sbt.internal.langserver.SaveOptions): TextDocumentSyncOptions = new TextDocumentSyncOptions(Option(openClose), Option(change), Option(willSave), Option(willSaveWaitUntil), Option(save))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/CancelRequestParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/CancelRequestParamsFormats.scala
new file mode 100644
index 000000000..711a11ec6
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/CancelRequestParamsFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CancelRequestParamsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val CancelRequestParamsFormat: JsonFormat[sbt.internal.langserver.CancelRequestParams] = new JsonFormat[sbt.internal.langserver.CancelRequestParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.CancelRequestParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val id = unbuilder.readField[String]("id")
+      unbuilder.endObject()
+      sbt.internal.langserver.CancelRequestParams(id)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.CancelRequestParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("id", obj.id)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ClientCapabilitiesFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ClientCapabilitiesFormats.scala
new file mode 100644
index 000000000..6289feb76
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ClientCapabilitiesFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ClientCapabilitiesFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ClientCapabilitiesFormat: JsonFormat[sbt.internal.langserver.ClientCapabilities] = new JsonFormat[sbt.internal.langserver.ClientCapabilities] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.ClientCapabilities = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.internal.langserver.ClientCapabilities()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.ClientCapabilities, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/DiagnosticFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/DiagnosticFormats.scala
new file mode 100644
index 000000000..6873fcf62
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/DiagnosticFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DiagnosticFormats { self: sbt.internal.langserver.codec.RangeFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val DiagnosticFormat: JsonFormat[sbt.internal.langserver.Diagnostic] = new JsonFormat[sbt.internal.langserver.Diagnostic] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Diagnostic = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val range = unbuilder.readField[sbt.internal.langserver.Range]("range")
+      val severity = unbuilder.readField[Option[Long]]("severity")
+      val code = unbuilder.readField[Option[String]]("code")
+      val source = unbuilder.readField[Option[String]]("source")
+      val message = unbuilder.readField[String]("message")
+      unbuilder.endObject()
+      sbt.internal.langserver.Diagnostic(range, severity, code, source, message)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.Diagnostic, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("range", obj.range)
+    builder.addField("severity", obj.severity)
+    builder.addField("code", obj.code)
+    builder.addField("source", obj.source)
+    builder.addField("message", obj.message)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeParamsFormats.scala
new file mode 100644
index 000000000..ae04579c0
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeParamsFormats.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InitializeParamsFormats { self: sbt.internal.util.codec.JValueFormats with sbt.internal.langserver.codec.ClientCapabilitiesFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val InitializeParamsFormat: JsonFormat[sbt.internal.langserver.InitializeParams] = new JsonFormat[sbt.internal.langserver.InitializeParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.InitializeParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val processId = unbuilder.readField[Option[Long]]("processId")
+      val rootPath = unbuilder.readField[Option[String]]("rootPath")
+      val rootUri = unbuilder.readField[Option[String]]("rootUri")
+      val initializationOptions = unbuilder.readField[Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]]("initializationOptions")
+      val capabilities = unbuilder.readField[Option[sbt.internal.langserver.ClientCapabilities]]("capabilities")
+      val trace = unbuilder.readField[Option[String]]("trace")
+      unbuilder.endObject()
+      sbt.internal.langserver.InitializeParams(processId, rootPath, rootUri, initializationOptions, capabilities, trace)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.InitializeParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("processId", obj.processId)
+    builder.addField("rootPath", obj.rootPath)
+    builder.addField("rootUri", obj.rootUri)
+    builder.addField("initializationOptions", obj.initializationOptions)
+    builder.addField("capabilities", obj.capabilities)
+    builder.addField("trace", obj.trace)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeResultFormats.scala
new file mode 100644
index 000000000..37b42fbd4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/InitializeResultFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InitializeResultFormats { self: sbt.internal.langserver.codec.ServerCapabilitiesFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val InitializeResultFormat: JsonFormat[sbt.internal.langserver.InitializeResult] = new JsonFormat[sbt.internal.langserver.InitializeResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.InitializeResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val capabilities = unbuilder.readField[sbt.internal.langserver.ServerCapabilities]("capabilities")
+      unbuilder.endObject()
+      sbt.internal.langserver.InitializeResult(capabilities)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.InitializeResult, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("capabilities", obj.capabilities)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/JsonProtocol.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/JsonProtocol.scala
new file mode 100644
index 000000000..68ae35cc6
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/JsonProtocol.scala
@@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+trait JsonProtocol extends sjsonnew.BasicJsonProtocol
+  with sbt.internal.langserver.codec.PositionFormats
+  with sbt.internal.langserver.codec.RangeFormats
+  with sbt.internal.langserver.codec.LocationFormats
+  with sbt.internal.langserver.codec.DiagnosticFormats
+  with sbt.internal.util.codec.JValueFormats
+  with sbt.internal.langserver.codec.ClientCapabilitiesFormats
+  with sbt.internal.langserver.codec.InitializeParamsFormats
+  with sbt.internal.langserver.codec.SaveOptionsFormats
+  with sbt.internal.langserver.codec.TextDocumentSyncOptionsFormats
+  with sbt.internal.langserver.codec.ServerCapabilitiesFormats
+  with sbt.internal.langserver.codec.InitializeResultFormats
+  with sbt.internal.langserver.codec.LogMessageParamsFormats
+  with sbt.internal.langserver.codec.PublishDiagnosticsParamsFormats
+  with sbt.internal.langserver.codec.SbtExecParamsFormats
+  with sbt.internal.langserver.codec.CancelRequestParamsFormats
+  with sbt.internal.langserver.codec.TextDocumentIdentifierFormats
+  with sbt.internal.langserver.codec.TextDocumentPositionParamsFormats
+  with sbt.internal.langserver.codec.TextDocumentPositionParamsInterfaceFormats
+object JsonProtocol extends JsonProtocol
\ No newline at end of file
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LocationFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LocationFormats.scala
new file mode 100644
index 000000000..04566a4cf
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LocationFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait LocationFormats { self: sbt.internal.langserver.codec.RangeFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val LocationFormat: JsonFormat[sbt.internal.langserver.Location] = new JsonFormat[sbt.internal.langserver.Location] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Location = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[String]("uri")
+      val range = unbuilder.readField[sbt.internal.langserver.Range]("range")
+      unbuilder.endObject()
+      sbt.internal.langserver.Location(uri, range)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.Location, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.addField("range", obj.range)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LogMessageParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LogMessageParamsFormats.scala
new file mode 100644
index 000000000..e175430cf
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/LogMessageParamsFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait LogMessageParamsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val LogMessageParamsFormat: JsonFormat[sbt.internal.langserver.LogMessageParams] = new JsonFormat[sbt.internal.langserver.LogMessageParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.LogMessageParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val `type` = unbuilder.readField[Long]("type")
+      val message = unbuilder.readField[String]("message")
+      unbuilder.endObject()
+      sbt.internal.langserver.LogMessageParams(`type`, message)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.LogMessageParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("type", obj.`type`)
+    builder.addField("message", obj.message)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PositionFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PositionFormats.scala
new file mode 100644
index 000000000..cea5633ec
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PositionFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PositionFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val PositionFormat: JsonFormat[sbt.internal.langserver.Position] = new JsonFormat[sbt.internal.langserver.Position] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Position = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val line = unbuilder.readField[Long]("line")
+      val character = unbuilder.readField[Long]("character")
+      unbuilder.endObject()
+      sbt.internal.langserver.Position(line, character)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.Position, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("line", obj.line)
+    builder.addField("character", obj.character)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PublishDiagnosticsParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PublishDiagnosticsParamsFormats.scala
new file mode 100644
index 000000000..a9730ce2f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/PublishDiagnosticsParamsFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PublishDiagnosticsParamsFormats { self: sbt.internal.langserver.codec.DiagnosticFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val PublishDiagnosticsParamsFormat: JsonFormat[sbt.internal.langserver.PublishDiagnosticsParams] = new JsonFormat[sbt.internal.langserver.PublishDiagnosticsParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.PublishDiagnosticsParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[String]("uri")
+      val diagnostics = unbuilder.readField[Vector[sbt.internal.langserver.Diagnostic]]("diagnostics")
+      unbuilder.endObject()
+      sbt.internal.langserver.PublishDiagnosticsParams(uri, diagnostics)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.PublishDiagnosticsParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.addField("diagnostics", obj.diagnostics)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/RangeFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/RangeFormats.scala
new file mode 100644
index 000000000..ed01eade5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/RangeFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait RangeFormats { self: sbt.internal.langserver.codec.PositionFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val RangeFormat: JsonFormat[sbt.internal.langserver.Range] = new JsonFormat[sbt.internal.langserver.Range] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.Range = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val start = unbuilder.readField[sbt.internal.langserver.Position]("start")
+      val end = unbuilder.readField[sbt.internal.langserver.Position]("end")
+      unbuilder.endObject()
+      sbt.internal.langserver.Range(start, end)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.Range, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("start", obj.start)
+    builder.addField("end", obj.end)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SaveOptionsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SaveOptionsFormats.scala
new file mode 100644
index 000000000..b41864707
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SaveOptionsFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SaveOptionsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val SaveOptionsFormat: JsonFormat[sbt.internal.langserver.SaveOptions] = new JsonFormat[sbt.internal.langserver.SaveOptions] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.SaveOptions = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val includeText = unbuilder.readField[Option[Boolean]]("includeText")
+      unbuilder.endObject()
+      sbt.internal.langserver.SaveOptions(includeText)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.SaveOptions, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("includeText", obj.includeText)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SbtExecParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SbtExecParamsFormats.scala
new file mode 100644
index 000000000..c69f37a76
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/SbtExecParamsFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SbtExecParamsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val SbtExecParamsFormat: JsonFormat[sbt.internal.langserver.SbtExecParams] = new JsonFormat[sbt.internal.langserver.SbtExecParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.SbtExecParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val commandLine = unbuilder.readField[String]("commandLine")
+      unbuilder.endObject()
+      sbt.internal.langserver.SbtExecParams(commandLine)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.SbtExecParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("commandLine", obj.commandLine)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ServerCapabilitiesFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ServerCapabilitiesFormats.scala
new file mode 100644
index 000000000..b980c95fe
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/ServerCapabilitiesFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ServerCapabilitiesFormats { self: sbt.internal.langserver.codec.TextDocumentSyncOptionsFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ServerCapabilitiesFormat: JsonFormat[sbt.internal.langserver.ServerCapabilities] = new JsonFormat[sbt.internal.langserver.ServerCapabilities] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.ServerCapabilities = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val textDocumentSync = unbuilder.readField[Option[sbt.internal.langserver.TextDocumentSyncOptions]]("textDocumentSync")
+      val hoverProvider = unbuilder.readField[Option[Boolean]]("hoverProvider")
+      val definitionProvider = unbuilder.readField[Option[Boolean]]("definitionProvider")
+      unbuilder.endObject()
+      sbt.internal.langserver.ServerCapabilities(textDocumentSync, hoverProvider, definitionProvider)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.ServerCapabilities, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("textDocumentSync", obj.textDocumentSync)
+    builder.addField("hoverProvider", obj.hoverProvider)
+    builder.addField("definitionProvider", obj.definitionProvider)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentIdentifierFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentIdentifierFormats.scala
new file mode 100644
index 000000000..cc4931539
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentIdentifierFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TextDocumentIdentifierFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TextDocumentIdentifierFormat: JsonFormat[sbt.internal.langserver.TextDocumentIdentifier] = new JsonFormat[sbt.internal.langserver.TextDocumentIdentifier] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentIdentifier = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[String]("uri")
+      unbuilder.endObject()
+      sbt.internal.langserver.TextDocumentIdentifier(uri)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.TextDocumentIdentifier, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentPositionParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentPositionParamsFormats.scala
new file mode 100644
index 000000000..f5aa877e3
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentPositionParamsFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TextDocumentPositionParamsFormats { self: sbt.internal.langserver.codec.TextDocumentIdentifierFormats with sbt.internal.langserver.codec.PositionFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TextDocumentPositionParamsFormat: JsonFormat[sbt.internal.langserver.TextDocumentPositionParams] = new JsonFormat[sbt.internal.langserver.TextDocumentPositionParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentPositionParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val textDocument = unbuilder.readField[sbt.internal.langserver.TextDocumentIdentifier]("textDocument")
+      val position = unbuilder.readField[sbt.internal.langserver.Position]("position")
+      unbuilder.endObject()
+      sbt.internal.langserver.TextDocumentPositionParams(textDocument, position)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.TextDocumentPositionParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("textDocument", obj.textDocument)
+    builder.addField("position", obj.position)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentPositionParamsInterfaceFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentPositionParamsInterfaceFormats.scala
new file mode 100644
index 000000000..3dff106a5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentPositionParamsInterfaceFormats.scala
@@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+
+import _root_.sjsonnew.JsonFormat
+trait TextDocumentPositionParamsInterfaceFormats { self: sbt.internal.langserver.codec.TextDocumentIdentifierFormats with sbt.internal.langserver.codec.PositionFormats with sjsonnew.BasicJsonProtocol with sbt.internal.langserver.codec.TextDocumentPositionParamsFormats =>
+implicit lazy val TextDocumentPositionParamsInterfaceFormat: JsonFormat[sbt.internal.langserver.TextDocumentPositionParamsInterface] = flatUnionFormat1[sbt.internal.langserver.TextDocumentPositionParamsInterface, sbt.internal.langserver.TextDocumentPositionParams]("type")
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentSyncOptionsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentSyncOptionsFormats.scala
new file mode 100644
index 000000000..fcb707f26
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/codec/TextDocumentSyncOptionsFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.langserver.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TextDocumentSyncOptionsFormats { self: sbt.internal.langserver.codec.SaveOptionsFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TextDocumentSyncOptionsFormat: JsonFormat[sbt.internal.langserver.TextDocumentSyncOptions] = new JsonFormat[sbt.internal.langserver.TextDocumentSyncOptions] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.langserver.TextDocumentSyncOptions = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val openClose = unbuilder.readField[Option[Boolean]]("openClose")
+      val change = unbuilder.readField[Option[Long]]("change")
+      val willSave = unbuilder.readField[Option[Boolean]]("willSave")
+      val willSaveWaitUntil = unbuilder.readField[Option[Boolean]]("willSaveWaitUntil")
+      val save = unbuilder.readField[Option[sbt.internal.langserver.SaveOptions]]("save")
+      unbuilder.endObject()
+      sbt.internal.langserver.TextDocumentSyncOptions(openClose, change, willSave, willSaveWaitUntil, save)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.langserver.TextDocumentSyncOptions, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("openClose", obj.openClose)
+    builder.addField("change", obj.change)
+    builder.addField("willSave", obj.willSave)
+    builder.addField("willSaveWaitUntil", obj.willSaveWaitUntil)
+    builder.addField("save", obj.save)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/InitializeOption.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/InitializeOption.scala
new file mode 100644
index 000000000..b900d641d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/InitializeOption.scala
@@ -0,0 +1,45 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+final class InitializeOption private (
+  val token: Option[String],
+  val skipAnalysis: Option[Boolean]) extends Serializable {
+  
+  private def this(token: Option[String]) = this(token, None)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: InitializeOption => (this.token == x.token) && (this.skipAnalysis == x.skipAnalysis)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.protocol.InitializeOption".##) + token.##) + skipAnalysis.##)
+  }
+  override def toString: String = {
+    "InitializeOption(" + token + ", " + skipAnalysis + ")"
+  }
+  private[this] def copy(token: Option[String] = token, skipAnalysis: Option[Boolean] = skipAnalysis): InitializeOption = {
+    new InitializeOption(token, skipAnalysis)
+  }
+  def withToken(token: Option[String]): InitializeOption = {
+    copy(token = token)
+  }
+  def withToken(token: String): InitializeOption = {
+    copy(token = Option(token))
+  }
+  def withSkipAnalysis(skipAnalysis: Option[Boolean]): InitializeOption = {
+    copy(skipAnalysis = skipAnalysis)
+  }
+  def withSkipAnalysis(skipAnalysis: Boolean): InitializeOption = {
+    copy(skipAnalysis = Option(skipAnalysis))
+  }
+}
+object InitializeOption {
+  
+  def apply(token: Option[String]): InitializeOption = new InitializeOption(token)
+  def apply(token: String): InitializeOption = new InitializeOption(Option(token))
+  def apply(token: Option[String], skipAnalysis: Option[Boolean]): InitializeOption = new InitializeOption(token, skipAnalysis)
+  def apply(token: String, skipAnalysis: Boolean): InitializeOption = new InitializeOption(Option(token), Option(skipAnalysis))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcMessage.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcMessage.scala
new file mode 100644
index 000000000..9ecee0954
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcMessage.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+/** A general message as defined by JSON-RPC. */
+abstract class JsonRpcMessage(
+  val jsonrpc: String) extends Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JsonRpcMessage => (this.jsonrpc == x.jsonrpc)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.internal.protocol.JsonRpcMessage".##) + jsonrpc.##)
+  }
+  override def toString: String = {
+    "JsonRpcMessage(" + jsonrpc + ")"
+  }
+}
+object JsonRpcMessage {
+  
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcNotificationMessage.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcNotificationMessage.scala
new file mode 100644
index 000000000..0049c9f52
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcNotificationMessage.scala
@@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+/**
+ * @param method The method to be invoked.
+ * @param params The method's params.
+ */
+final class JsonRpcNotificationMessage private (
+  jsonrpc: String,
+  val method: String,
+  val params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends sbt.internal.protocol.JsonRpcMessage(jsonrpc) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JsonRpcNotificationMessage => (this.jsonrpc == x.jsonrpc) && (this.method == x.method) && (this.params == x.params)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.protocol.JsonRpcNotificationMessage".##) + jsonrpc.##) + method.##) + params.##)
+  }
+  override def toString: String = {
+    s"""JsonRpcNotificationMessage($jsonrpc, $method, ${sbt.protocol.Serialization.compactPrintJsonOpt(params)})"""
+  }
+  private[this] def copy(jsonrpc: String = jsonrpc, method: String = method, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = params): JsonRpcNotificationMessage = {
+    new JsonRpcNotificationMessage(jsonrpc, method, params)
+  }
+  def withJsonrpc(jsonrpc: String): JsonRpcNotificationMessage = {
+    copy(jsonrpc = jsonrpc)
+  }
+  def withMethod(method: String): JsonRpcNotificationMessage = {
+    copy(method = method)
+  }
+  def withParams(params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): JsonRpcNotificationMessage = {
+    copy(params = params)
+  }
+  def withParams(params: sjsonnew.shaded.scalajson.ast.unsafe.JValue): JsonRpcNotificationMessage = {
+    copy(params = Option(params))
+  }
+}
+object JsonRpcNotificationMessage {
+  
+  def apply(jsonrpc: String, method: String, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): JsonRpcNotificationMessage = new JsonRpcNotificationMessage(jsonrpc, method, params)
+  def apply(jsonrpc: String, method: String, params: sjsonnew.shaded.scalajson.ast.unsafe.JValue): JsonRpcNotificationMessage = new JsonRpcNotificationMessage(jsonrpc, method, Option(params))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcRequestMessage.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcRequestMessage.scala
new file mode 100644
index 000000000..65e88637f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcRequestMessage.scala
@@ -0,0 +1,53 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+/**
+ * @param id The request id.
+ * @param method The method to be invoked.
+ * @param params The method's params.
+ */
+final class JsonRpcRequestMessage private (
+  jsonrpc: String,
+  val id: String,
+  val method: String,
+  val params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends sbt.internal.protocol.JsonRpcMessage(jsonrpc) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JsonRpcRequestMessage => (this.jsonrpc == x.jsonrpc) && (this.id == x.id) && (this.method == x.method) && (this.params == x.params)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.protocol.JsonRpcRequestMessage".##) + jsonrpc.##) + id.##) + method.##) + params.##)
+  }
+  override def toString: String = {
+    s"""JsonRpcRequestMessage($jsonrpc, $id, $method, ${sbt.protocol.Serialization.compactPrintJsonOpt(params)}})"""
+  }
+  private[this] def copy(jsonrpc: String = jsonrpc, id: String = id, method: String = method, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = params): JsonRpcRequestMessage = {
+    new JsonRpcRequestMessage(jsonrpc, id, method, params)
+  }
+  def withJsonrpc(jsonrpc: String): JsonRpcRequestMessage = {
+    copy(jsonrpc = jsonrpc)
+  }
+  def withId(id: String): JsonRpcRequestMessage = {
+    copy(id = id)
+  }
+  def withMethod(method: String): JsonRpcRequestMessage = {
+    copy(method = method)
+  }
+  def withParams(params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): JsonRpcRequestMessage = {
+    copy(params = params)
+  }
+  def withParams(params: sjsonnew.shaded.scalajson.ast.unsafe.JValue): JsonRpcRequestMessage = {
+    copy(params = Option(params))
+  }
+}
+object JsonRpcRequestMessage {
+  
+  def apply(jsonrpc: String, id: String, method: String, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): JsonRpcRequestMessage = new JsonRpcRequestMessage(jsonrpc, id, method, params)
+  def apply(jsonrpc: String, id: String, method: String, params: sjsonnew.shaded.scalajson.ast.unsafe.JValue): JsonRpcRequestMessage = new JsonRpcRequestMessage(jsonrpc, id, method, Option(params))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseError.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseError.scala
new file mode 100644
index 000000000..1bbffe652
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseError.scala
@@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+/**
+ * @param code A number indicating the error type that occurred.
+ * @param message A string providing a short description of the error.
+ * @param data A Primitive or Structured value that contains additional
+               information about the error. Can be omitted.
+ */
+final class JsonRpcResponseError private (
+  val code: Long,
+  val message: String,
+  val data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]) extends RuntimeException(message) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JsonRpcResponseError => (this.code == x.code) && (this.message == x.message) && (this.data == x.data)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.protocol.JsonRpcResponseError".##) + code.##) + message.##) + data.##)
+  }
+  override def toString: String = {
+    s"""JsonRpcResponseError($code, $message, ${sbt.protocol.Serialization.compactPrintJsonOpt(data)})"""
+  }
+  private[this] def copy(code: Long = code, message: String = message, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): JsonRpcResponseError = {
+    new JsonRpcResponseError(code, message, data)
+  }
+  def withCode(code: Long): JsonRpcResponseError = {
+    copy(code = code)
+  }
+  def withMessage(message: String): JsonRpcResponseError = {
+    copy(message = message)
+  }
+  def withData(data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): JsonRpcResponseError = {
+    copy(data = data)
+  }
+  def withData(data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): JsonRpcResponseError = {
+    copy(data = Option(data))
+  }
+}
+object JsonRpcResponseError {
+  def apply(code: Long, message: String): JsonRpcResponseError = new JsonRpcResponseError(code, message, None)
+  def apply(code: Long, message: String, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): JsonRpcResponseError = new JsonRpcResponseError(code, message, data)
+  def apply(code: Long, message: String, data: sjsonnew.shaded.scalajson.ast.unsafe.JValue): JsonRpcResponseError = new JsonRpcResponseError(code, message, Option(data))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseMessage.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseMessage.scala
new file mode 100644
index 000000000..cedaf048f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseMessage.scala
@@ -0,0 +1,57 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+/**
+ * @param id The request id.
+ * @param result The result of a request. This can be omitted in
+                 the case of an error.
+ * @param error The error object in case a request fails.
+ */
+final class JsonRpcResponseMessage private (
+  jsonrpc: String,
+  val id: String,
+  val result: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue],
+  val error: Option[sbt.internal.protocol.JsonRpcResponseError]) extends sbt.internal.protocol.JsonRpcMessage(jsonrpc) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: JsonRpcResponseMessage => (this.jsonrpc == x.jsonrpc) && (this.id == x.id) && (this.result == x.result) && (this.error == x.error)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.protocol.JsonRpcResponseMessage".##) + jsonrpc.##) + id.##) + result.##) + error.##)
+  }
+  override def toString: String = {
+    s"""JsonRpcResponseMessage($jsonrpc, $id, ${sbt.protocol.Serialization.compactPrintJsonOpt(result)}, $error)"""
+  }
+  private[this] def copy(jsonrpc: String = jsonrpc, id: String = id, result: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = result, error: Option[sbt.internal.protocol.JsonRpcResponseError] = error): JsonRpcResponseMessage = {
+    new JsonRpcResponseMessage(jsonrpc, id, result, error)
+  }
+  def withJsonrpc(jsonrpc: String): JsonRpcResponseMessage = {
+    copy(jsonrpc = jsonrpc)
+  }
+  def withId(id: String): JsonRpcResponseMessage = {
+    copy(id = id)
+  }
+  def withResult(result: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue]): JsonRpcResponseMessage = {
+    copy(result = result)
+  }
+  def withResult(result: sjsonnew.shaded.scalajson.ast.unsafe.JValue): JsonRpcResponseMessage = {
+    copy(result = Option(result))
+  }
+  def withError(error: Option[sbt.internal.protocol.JsonRpcResponseError]): JsonRpcResponseMessage = {
+    copy(error = error)
+  }
+  def withError(error: sbt.internal.protocol.JsonRpcResponseError): JsonRpcResponseMessage = {
+    copy(error = Option(error))
+  }
+}
+object JsonRpcResponseMessage {
+  
+  def apply(jsonrpc: String, id: String, result: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue], error: Option[sbt.internal.protocol.JsonRpcResponseError]): JsonRpcResponseMessage = new JsonRpcResponseMessage(jsonrpc, id, result, error)
+  def apply(jsonrpc: String, id: String, result: sjsonnew.shaded.scalajson.ast.unsafe.JValue, error: sbt.internal.protocol.JsonRpcResponseError): JsonRpcResponseMessage = new JsonRpcResponseMessage(jsonrpc, id, Option(result), Option(error))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/PortFile.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/PortFile.scala
new file mode 100644
index 000000000..318f2a2d5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/PortFile.scala
@@ -0,0 +1,52 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+/**
+ * This file should exist throughout the lifetime of the server.
+ * It can be used to find out the transport protocol (port number etc).
+ * @param uri URI of the sbt server.
+ */
+final class PortFile private (
+  val uri: String,
+  val tokenfilePath: Option[String],
+  val tokenfileUri: Option[String]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: PortFile => (this.uri == x.uri) && (this.tokenfilePath == x.tokenfilePath) && (this.tokenfileUri == x.tokenfileUri)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.internal.protocol.PortFile".##) + uri.##) + tokenfilePath.##) + tokenfileUri.##)
+  }
+  override def toString: String = {
+    "PortFile(" + uri + ", " + tokenfilePath + ", " + tokenfileUri + ")"
+  }
+  private[this] def copy(uri: String = uri, tokenfilePath: Option[String] = tokenfilePath, tokenfileUri: Option[String] = tokenfileUri): PortFile = {
+    new PortFile(uri, tokenfilePath, tokenfileUri)
+  }
+  def withUri(uri: String): PortFile = {
+    copy(uri = uri)
+  }
+  def withTokenfilePath(tokenfilePath: Option[String]): PortFile = {
+    copy(tokenfilePath = tokenfilePath)
+  }
+  def withTokenfilePath(tokenfilePath: String): PortFile = {
+    copy(tokenfilePath = Option(tokenfilePath))
+  }
+  def withTokenfileUri(tokenfileUri: Option[String]): PortFile = {
+    copy(tokenfileUri = tokenfileUri)
+  }
+  def withTokenfileUri(tokenfileUri: String): PortFile = {
+    copy(tokenfileUri = Option(tokenfileUri))
+  }
+}
+object PortFile {
+  
+  def apply(uri: String, tokenfilePath: Option[String], tokenfileUri: Option[String]): PortFile = new PortFile(uri, tokenfilePath, tokenfileUri)
+  def apply(uri: String, tokenfilePath: String, tokenfileUri: String): PortFile = new PortFile(uri, Option(tokenfilePath), Option(tokenfileUri))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/TokenFile.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/TokenFile.scala
new file mode 100644
index 000000000..1f5c3ae63
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/TokenFile.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol
+final class TokenFile private (
+  val uri: String,
+  val token: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TokenFile => (this.uri == x.uri) && (this.token == x.token)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.internal.protocol.TokenFile".##) + uri.##) + token.##)
+  }
+  override def toString: String = {
+    "TokenFile(" + uri + ", " + token + ")"
+  }
+  private[this] def copy(uri: String = uri, token: String = token): TokenFile = {
+    new TokenFile(uri, token)
+  }
+  def withUri(uri: String): TokenFile = {
+    copy(uri = uri)
+  }
+  def withToken(token: String): TokenFile = {
+    copy(token = token)
+  }
+}
+object TokenFile {
+  
+  def apply(uri: String, token: String): TokenFile = new TokenFile(uri, token)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/InitializeOptionFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/InitializeOptionFormats.scala
new file mode 100644
index 000000000..f7f3a09e7
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/InitializeOptionFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InitializeOptionFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val InitializeOptionFormat: JsonFormat[sbt.internal.protocol.InitializeOption] = new JsonFormat[sbt.internal.protocol.InitializeOption] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.InitializeOption = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val token = unbuilder.readField[Option[String]]("token")
+      val skipAnalysis = unbuilder.readField[Option[Boolean]]("skipAnalysis")
+      unbuilder.endObject()
+      sbt.internal.protocol.InitializeOption(token, skipAnalysis)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.protocol.InitializeOption, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("token", obj.token)
+    builder.addField("skipAnalysis", obj.skipAnalysis)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/PortFileFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/PortFileFormats.scala
new file mode 100644
index 000000000..52e100fd4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/PortFileFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PortFileFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val PortFileFormat: JsonFormat[sbt.internal.protocol.PortFile] = new JsonFormat[sbt.internal.protocol.PortFile] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.PortFile = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[String]("uri")
+      val tokenfilePath = unbuilder.readField[Option[String]]("tokenfilePath")
+      val tokenfileUri = unbuilder.readField[Option[String]]("tokenfileUri")
+      unbuilder.endObject()
+      sbt.internal.protocol.PortFile(uri, tokenfilePath, tokenfileUri)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.protocol.PortFile, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.addField("tokenfilePath", obj.tokenfilePath)
+    builder.addField("tokenfileUri", obj.tokenfileUri)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/TokenFileFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/TokenFileFormats.scala
new file mode 100644
index 000000000..23b28d271
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/codec/TokenFileFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TokenFileFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TokenFileFormat: JsonFormat[sbt.internal.protocol.TokenFile] = new JsonFormat[sbt.internal.protocol.TokenFile] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.protocol.TokenFile = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val uri = unbuilder.readField[String]("uri")
+      val token = unbuilder.readField[String]("token")
+      unbuilder.endObject()
+      sbt.internal.protocol.TokenFile(uri, token)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.protocol.TokenFile, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("uri", obj.uri)
+    builder.addField("token", obj.token)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/Attach.scala b/protocol/src/main/contraband-scala/sbt/protocol/Attach.scala
new file mode 100644
index 000000000..6ef22b160
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/Attach.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class Attach private (
+  val interactive: Boolean) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: Attach => (this.interactive == x.interactive)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.Attach".##) + interactive.##)
+  }
+  override def toString: String = {
+    "Attach(" + interactive + ")"
+  }
+  private[this] def copy(interactive: Boolean = interactive): Attach = {
+    new Attach(interactive)
+  }
+  def withInteractive(interactive: Boolean): Attach = {
+    copy(interactive = interactive)
+  }
+}
+object Attach {
+  
+  def apply(interactive: Boolean): Attach = new Attach(interactive)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/ChannelAcceptedEvent.scala b/protocol/src/main/contraband-scala/sbt/protocol/ChannelAcceptedEvent.scala
new file mode 100644
index 000000000..14fa116d9
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ChannelAcceptedEvent.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class ChannelAcceptedEvent private (
+  val channelName: String) extends sbt.protocol.EventMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ChannelAcceptedEvent => (this.channelName == x.channelName)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.ChannelAcceptedEvent".##) + channelName.##)
+  }
+  override def toString: String = {
+    "ChannelAcceptedEvent(" + channelName + ")"
+  }
+  private[this] def copy(channelName: String = channelName): ChannelAcceptedEvent = {
+    new ChannelAcceptedEvent(channelName)
+  }
+  def withChannelName(channelName: String): ChannelAcceptedEvent = {
+    copy(channelName = channelName)
+  }
+}
+object ChannelAcceptedEvent {
+  
+  def apply(channelName: String): ChannelAcceptedEvent = new ChannelAcceptedEvent(channelName)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/CommandMessage.scala b/protocol/src/main/contraband-scala/sbt/protocol/CommandMessage.scala
new file mode 100644
index 000000000..cdf3100c2
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/CommandMessage.scala
@@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+/** Message to invoke command. */
+abstract class CommandMessage() extends Serializable {
+
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: CommandMessage => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.CommandMessage".##)
+}
+override def toString: String = {
+  "CommandMessage()"
+}
+}
+object CommandMessage {
+  
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/CompletionParams.scala b/protocol/src/main/contraband-scala/sbt/protocol/CompletionParams.scala
new file mode 100644
index 000000000..e9db18230
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/CompletionParams.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class CompletionParams private (
+  val query: String,
+  val level: Option[Int]) extends Serializable {
+  
+  private def this(query: String) = this(query, None)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CompletionParams => (this.query == x.query) && (this.level == x.level)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.CompletionParams".##) + query.##) + level.##)
+  }
+  override def toString: String = {
+    "CompletionParams(" + query + ", " + level + ")"
+  }
+  private[this] def copy(query: String = query, level: Option[Int] = level): CompletionParams = {
+    new CompletionParams(query, level)
+  }
+  def withQuery(query: String): CompletionParams = {
+    copy(query = query)
+  }
+  def withLevel(level: Option[Int]): CompletionParams = {
+    copy(level = level)
+  }
+  def withLevel(level: Int): CompletionParams = {
+    copy(level = Option(level))
+  }
+}
+object CompletionParams {
+  
+  def apply(query: String): CompletionParams = new CompletionParams(query)
+  def apply(query: String, level: Option[Int]): CompletionParams = new CompletionParams(query, level)
+  def apply(query: String, level: Int): CompletionParams = new CompletionParams(query, Option(level))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/CompletionResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/CompletionResponse.scala
new file mode 100644
index 000000000..4692627de
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/CompletionResponse.scala
@@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class CompletionResponse private (
+  val items: Vector[String],
+  val cachedMainClassNames: Option[Boolean],
+  val cachedTestNames: Option[Boolean]) extends Serializable {
+  
+  private def this(items: Vector[String]) = this(items, None, None)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: CompletionResponse => (this.items == x.items) && (this.cachedMainClassNames == x.cachedMainClassNames) && (this.cachedTestNames == x.cachedTestNames)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.protocol.CompletionResponse".##) + items.##) + cachedMainClassNames.##) + cachedTestNames.##)
+  }
+  override def toString: String = {
+    "CompletionResponse(" + items + ", " + cachedMainClassNames + ", " + cachedTestNames + ")"
+  }
+  private[this] def copy(items: Vector[String] = items, cachedMainClassNames: Option[Boolean] = cachedMainClassNames, cachedTestNames: Option[Boolean] = cachedTestNames): CompletionResponse = {
+    new CompletionResponse(items, cachedMainClassNames, cachedTestNames)
+  }
+  def withItems(items: Vector[String]): CompletionResponse = {
+    copy(items = items)
+  }
+  def withCachedMainClassNames(cachedMainClassNames: Option[Boolean]): CompletionResponse = {
+    copy(cachedMainClassNames = cachedMainClassNames)
+  }
+  def withCachedMainClassNames(cachedMainClassNames: Boolean): CompletionResponse = {
+    copy(cachedMainClassNames = Option(cachedMainClassNames))
+  }
+  def withCachedTestNames(cachedTestNames: Option[Boolean]): CompletionResponse = {
+    copy(cachedTestNames = cachedTestNames)
+  }
+  def withCachedTestNames(cachedTestNames: Boolean): CompletionResponse = {
+    copy(cachedTestNames = Option(cachedTestNames))
+  }
+}
+object CompletionResponse {
+  
+  def apply(items: Vector[String]): CompletionResponse = new CompletionResponse(items)
+  def apply(items: Vector[String], cachedMainClassNames: Option[Boolean], cachedTestNames: Option[Boolean]): CompletionResponse = new CompletionResponse(items, cachedMainClassNames, cachedTestNames)
+  def apply(items: Vector[String], cachedMainClassNames: Boolean, cachedTestNames: Boolean): CompletionResponse = new CompletionResponse(items, Option(cachedMainClassNames), Option(cachedTestNames))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/EventMessage.scala b/protocol/src/main/contraband-scala/sbt/protocol/EventMessage.scala
new file mode 100644
index 000000000..09c52f2ef
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/EventMessage.scala
@@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+/** Message for events. */
+abstract class EventMessage() extends Serializable {
+
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: EventMessage => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.EventMessage".##)
+}
+override def toString: String = {
+  "EventMessage()"
+}
+}
+object EventMessage {
+  
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/ExecCommand.scala b/protocol/src/main/contraband-scala/sbt/protocol/ExecCommand.scala
new file mode 100644
index 000000000..e048099a7
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ExecCommand.scala
@@ -0,0 +1,42 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+/** Command to execute sbt command. */
+final class ExecCommand private (
+  val commandLine: String,
+  val execId: Option[String]) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  private def this(commandLine: String) = this(commandLine, None)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ExecCommand => (this.commandLine == x.commandLine) && (this.execId == x.execId)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.ExecCommand".##) + commandLine.##) + execId.##)
+  }
+  override def toString: String = {
+    "ExecCommand(" + commandLine + ", " + execId + ")"
+  }
+  private[this] def copy(commandLine: String = commandLine, execId: Option[String] = execId): ExecCommand = {
+    new ExecCommand(commandLine, execId)
+  }
+  def withCommandLine(commandLine: String): ExecCommand = {
+    copy(commandLine = commandLine)
+  }
+  def withExecId(execId: Option[String]): ExecCommand = {
+    copy(execId = execId)
+  }
+  def withExecId(execId: String): ExecCommand = {
+    copy(execId = Option(execId))
+  }
+}
+object ExecCommand {
+  
+  def apply(commandLine: String): ExecCommand = new ExecCommand(commandLine)
+  def apply(commandLine: String, execId: Option[String]): ExecCommand = new ExecCommand(commandLine, execId)
+  def apply(commandLine: String, execId: String): ExecCommand = new ExecCommand(commandLine, Option(execId))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/ExecStatusEvent.scala b/protocol/src/main/contraband-scala/sbt/protocol/ExecStatusEvent.scala
new file mode 100644
index 000000000..ad51b00b4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ExecStatusEvent.scala
@@ -0,0 +1,71 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+/** Status event. */
+final class ExecStatusEvent private (
+  val status: String,
+  val channelName: Option[String],
+  val execId: Option[String],
+  val commandQueue: Vector[String],
+  val exitCode: Option[Long],
+  val message: Option[String]) extends sbt.protocol.EventMessage() with Serializable {
+  
+  private def this(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String]) = this(status, channelName, execId, commandQueue, None, None)
+  private def this(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String], exitCode: Option[Long]) = this(status, channelName, execId, commandQueue, exitCode, None)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ExecStatusEvent => (this.status == x.status) && (this.channelName == x.channelName) && (this.execId == x.execId) && (this.commandQueue == x.commandQueue) && (this.exitCode == x.exitCode) && (this.message == x.message)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.protocol.ExecStatusEvent".##) + status.##) + channelName.##) + execId.##) + commandQueue.##) + exitCode.##) + message.##)
+  }
+  override def toString: String = {
+    "ExecStatusEvent(" + status + ", " + channelName + ", " + execId + ", " + commandQueue + ", " + exitCode + ", " + message + ")"
+  }
+  private[this] def copy(status: String = status, channelName: Option[String] = channelName, execId: Option[String] = execId, commandQueue: Vector[String] = commandQueue, exitCode: Option[Long] = exitCode, message: Option[String] = message): ExecStatusEvent = {
+    new ExecStatusEvent(status, channelName, execId, commandQueue, exitCode, message)
+  }
+  def withStatus(status: String): ExecStatusEvent = {
+    copy(status = status)
+  }
+  def withChannelName(channelName: Option[String]): ExecStatusEvent = {
+    copy(channelName = channelName)
+  }
+  def withChannelName(channelName: String): ExecStatusEvent = {
+    copy(channelName = Option(channelName))
+  }
+  def withExecId(execId: Option[String]): ExecStatusEvent = {
+    copy(execId = execId)
+  }
+  def withExecId(execId: String): ExecStatusEvent = {
+    copy(execId = Option(execId))
+  }
+  def withCommandQueue(commandQueue: Vector[String]): ExecStatusEvent = {
+    copy(commandQueue = commandQueue)
+  }
+  def withExitCode(exitCode: Option[Long]): ExecStatusEvent = {
+    copy(exitCode = exitCode)
+  }
+  def withExitCode(exitCode: Long): ExecStatusEvent = {
+    copy(exitCode = Option(exitCode))
+  }
+  def withMessage(message: Option[String]): ExecStatusEvent = {
+    copy(message = message)
+  }
+  def withMessage(message: String): ExecStatusEvent = {
+    copy(message = Option(message))
+  }
+}
+object ExecStatusEvent {
+  
+  def apply(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String]): ExecStatusEvent = new ExecStatusEvent(status, channelName, execId, commandQueue)
+  def apply(status: String, channelName: String, execId: String, commandQueue: Vector[String]): ExecStatusEvent = new ExecStatusEvent(status, Option(channelName), Option(execId), commandQueue)
+  def apply(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String], exitCode: Option[Long]): ExecStatusEvent = new ExecStatusEvent(status, channelName, execId, commandQueue, exitCode)
+  def apply(status: String, channelName: String, execId: String, commandQueue: Vector[String], exitCode: Long): ExecStatusEvent = new ExecStatusEvent(status, Option(channelName), Option(execId), commandQueue, Option(exitCode))
+  def apply(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String], exitCode: Option[Long], message: Option[String]): ExecStatusEvent = new ExecStatusEvent(status, channelName, execId, commandQueue, exitCode, message)
+  def apply(status: String, channelName: String, execId: String, commandQueue: Vector[String], exitCode: Long, message: String): ExecStatusEvent = new ExecStatusEvent(status, Option(channelName), Option(execId), commandQueue, Option(exitCode), Option(message))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/ExecutionEvent.scala b/protocol/src/main/contraband-scala/sbt/protocol/ExecutionEvent.scala
new file mode 100644
index 000000000..1574b19f9
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ExecutionEvent.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+/** Execution event. */
+final class ExecutionEvent private (
+  val success: String,
+  val commandLine: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ExecutionEvent => (this.success == x.success) && (this.commandLine == x.commandLine)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.ExecutionEvent".##) + success.##) + commandLine.##)
+  }
+  override def toString: String = {
+    "ExecutionEvent(" + success + ", " + commandLine + ")"
+  }
+  private[this] def copy(success: String = success, commandLine: String = commandLine): ExecutionEvent = {
+    new ExecutionEvent(success, commandLine)
+  }
+  def withSuccess(success: String): ExecutionEvent = {
+    copy(success = success)
+  }
+  def withCommandLine(commandLine: String): ExecutionEvent = {
+    copy(commandLine = commandLine)
+  }
+}
+object ExecutionEvent {
+  
+  def apply(success: String, commandLine: String): ExecutionEvent = new ExecutionEvent(success, commandLine)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/InitCommand.scala b/protocol/src/main/contraband-scala/sbt/protocol/InitCommand.scala
new file mode 100644
index 000000000..ddfe85f45
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/InitCommand.scala
@@ -0,0 +1,52 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class InitCommand private (
+  val token: Option[String],
+  val execId: Option[String],
+  val skipAnalysis: Option[Boolean]) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  private def this(token: Option[String], execId: Option[String]) = this(token, execId, None)
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: InitCommand => (this.token == x.token) && (this.execId == x.execId) && (this.skipAnalysis == x.skipAnalysis)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.protocol.InitCommand".##) + token.##) + execId.##) + skipAnalysis.##)
+  }
+  override def toString: String = {
+    "InitCommand(" + token + ", " + execId + ", " + skipAnalysis + ")"
+  }
+  private[this] def copy(token: Option[String] = token, execId: Option[String] = execId, skipAnalysis: Option[Boolean] = skipAnalysis): InitCommand = {
+    new InitCommand(token, execId, skipAnalysis)
+  }
+  def withToken(token: Option[String]): InitCommand = {
+    copy(token = token)
+  }
+  def withToken(token: String): InitCommand = {
+    copy(token = Option(token))
+  }
+  def withExecId(execId: Option[String]): InitCommand = {
+    copy(execId = execId)
+  }
+  def withExecId(execId: String): InitCommand = {
+    copy(execId = Option(execId))
+  }
+  def withSkipAnalysis(skipAnalysis: Option[Boolean]): InitCommand = {
+    copy(skipAnalysis = skipAnalysis)
+  }
+  def withSkipAnalysis(skipAnalysis: Boolean): InitCommand = {
+    copy(skipAnalysis = Option(skipAnalysis))
+  }
+}
+object InitCommand {
+  
+  def apply(token: Option[String], execId: Option[String]): InitCommand = new InitCommand(token, execId)
+  def apply(token: String, execId: String): InitCommand = new InitCommand(Option(token), Option(execId))
+  def apply(token: Option[String], execId: Option[String], skipAnalysis: Option[Boolean]): InitCommand = new InitCommand(token, execId, skipAnalysis)
+  def apply(token: String, execId: String, skipAnalysis: Boolean): InitCommand = new InitCommand(Option(token), Option(execId), Option(skipAnalysis))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/LogEvent.scala b/protocol/src/main/contraband-scala/sbt/protocol/LogEvent.scala
new file mode 100644
index 000000000..40ce5afc1
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/LogEvent.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+/** Log event. */
+final class LogEvent private (
+  val level: String,
+  val message: String) extends sbt.protocol.EventMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: LogEvent => (this.level == x.level) && (this.message == x.message)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.LogEvent".##) + level.##) + message.##)
+  }
+  override def toString: String = {
+    "LogEvent(" + level + ", " + message + ")"
+  }
+  private[this] def copy(level: String = level, message: String = message): LogEvent = {
+    new LogEvent(level, message)
+  }
+  def withLevel(level: String): LogEvent = {
+    copy(level = level)
+  }
+  def withMessage(message: String): LogEvent = {
+    copy(message = message)
+  }
+}
+object LogEvent {
+  
+  def apply(level: String, message: String): LogEvent = new LogEvent(level, message)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/SettingQuery.scala b/protocol/src/main/contraband-scala/sbt/protocol/SettingQuery.scala
new file mode 100644
index 000000000..306fbc5cc
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/SettingQuery.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class SettingQuery private (
+  val setting: String) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SettingQuery => (this.setting == x.setting)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.SettingQuery".##) + setting.##)
+  }
+  override def toString: String = {
+    "SettingQuery(" + setting + ")"
+  }
+  private[this] def copy(setting: String = setting): SettingQuery = {
+    new SettingQuery(setting)
+  }
+  def withSetting(setting: String): SettingQuery = {
+    copy(setting = setting)
+  }
+}
+object SettingQuery {
+  
+  def apply(setting: String): SettingQuery = new SettingQuery(setting)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryFailure.scala b/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryFailure.scala
new file mode 100644
index 000000000..3cea10f5c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryFailure.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class SettingQueryFailure private (
+  val message: String) extends sbt.protocol.SettingQueryResponse() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SettingQueryFailure => (this.message == x.message)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.SettingQueryFailure".##) + message.##)
+  }
+  override def toString: String = {
+    "SettingQueryFailure(" + message + ")"
+  }
+  private[this] def copy(message: String = message): SettingQueryFailure = {
+    new SettingQueryFailure(message)
+  }
+  def withMessage(message: String): SettingQueryFailure = {
+    copy(message = message)
+  }
+}
+object SettingQueryFailure {
+  
+  def apply(message: String): SettingQueryFailure = new SettingQueryFailure(message)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryResponse.scala
new file mode 100644
index 000000000..e57883b92
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryResponse.scala
@@ -0,0 +1,25 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+abstract class SettingQueryResponse() extends sbt.protocol.EventMessage() with Serializable {
+
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: SettingQueryResponse => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.SettingQueryResponse".##)
+}
+override def toString: String = {
+  "SettingQueryResponse()"
+}
+}
+object SettingQueryResponse {
+  
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/SettingQuerySuccess.scala b/protocol/src/main/contraband-scala/sbt/protocol/SettingQuerySuccess.scala
new file mode 100644
index 000000000..bde80f5f5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/SettingQuerySuccess.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class SettingQuerySuccess private (
+  val value: sjsonnew.shaded.scalajson.ast.unsafe.JValue,
+  val contentType: String) extends sbt.protocol.SettingQueryResponse() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: SettingQuerySuccess => (this.value == x.value) && (this.contentType == x.contentType)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.SettingQuerySuccess".##) + value.##) + contentType.##)
+  }
+  override def toString: String = {
+    "SettingQuerySuccess(" + value + ", " + contentType + ")"
+  }
+  private[this] def copy(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue = value, contentType: String = contentType): SettingQuerySuccess = {
+    new SettingQuerySuccess(value, contentType)
+  }
+  def withValue(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue): SettingQuerySuccess = {
+    copy(value = value)
+  }
+  def withContentType(contentType: String): SettingQuerySuccess = {
+    copy(contentType = contentType)
+  }
+}
+object SettingQuerySuccess {
+  
+  def apply(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue, contentType: String): SettingQuerySuccess = new SettingQuerySuccess(value, contentType)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalAttributesQuery.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalAttributesQuery.scala
new file mode 100644
index 000000000..652705219
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalAttributesQuery.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalAttributesQuery private () extends sbt.protocol.CommandMessage() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TerminalAttributesQuery => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.TerminalAttributesQuery".##)
+}
+override def toString: String = {
+  "TerminalAttributesQuery()"
+}
+private[this] def copy(): TerminalAttributesQuery = {
+  new TerminalAttributesQuery()
+}
+
+}
+object TerminalAttributesQuery {
+  
+  def apply(): TerminalAttributesQuery = new TerminalAttributesQuery()
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalAttributesResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalAttributesResponse.scala
new file mode 100644
index 000000000..c6032e10f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalAttributesResponse.scala
@@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalAttributesResponse private (
+  val iflag: String,
+  val oflag: String,
+  val cflag: String,
+  val lflag: String,
+  val cchars: String) extends sbt.protocol.EventMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalAttributesResponse => (this.iflag == x.iflag) && (this.oflag == x.oflag) && (this.cflag == x.cflag) && (this.lflag == x.lflag) && (this.cchars == x.cchars)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.protocol.TerminalAttributesResponse".##) + iflag.##) + oflag.##) + cflag.##) + lflag.##) + cchars.##)
+  }
+  override def toString: String = {
+    "TerminalAttributesResponse(" + iflag + ", " + oflag + ", " + cflag + ", " + lflag + ", " + cchars + ")"
+  }
+  private[this] def copy(iflag: String = iflag, oflag: String = oflag, cflag: String = cflag, lflag: String = lflag, cchars: String = cchars): TerminalAttributesResponse = {
+    new TerminalAttributesResponse(iflag, oflag, cflag, lflag, cchars)
+  }
+  def withIflag(iflag: String): TerminalAttributesResponse = {
+    copy(iflag = iflag)
+  }
+  def withOflag(oflag: String): TerminalAttributesResponse = {
+    copy(oflag = oflag)
+  }
+  def withCflag(cflag: String): TerminalAttributesResponse = {
+    copy(cflag = cflag)
+  }
+  def withLflag(lflag: String): TerminalAttributesResponse = {
+    copy(lflag = lflag)
+  }
+  def withCchars(cchars: String): TerminalAttributesResponse = {
+    copy(cchars = cchars)
+  }
+}
+object TerminalAttributesResponse {
+  
+  def apply(iflag: String, oflag: String, cflag: String, lflag: String, cchars: String): TerminalAttributesResponse = new TerminalAttributesResponse(iflag, oflag, cflag, lflag, cchars)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalCapabilitiesQuery.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalCapabilitiesQuery.scala
new file mode 100644
index 000000000..5f70ed5e7
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalCapabilitiesQuery.scala
@@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalCapabilitiesQuery private (
+  val boolean: Option[String],
+  val numeric: Option[String],
+  val string: Option[String]) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalCapabilitiesQuery => (this.boolean == x.boolean) && (this.numeric == x.numeric) && (this.string == x.string)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.protocol.TerminalCapabilitiesQuery".##) + boolean.##) + numeric.##) + string.##)
+  }
+  override def toString: String = {
+    "TerminalCapabilitiesQuery(" + boolean + ", " + numeric + ", " + string + ")"
+  }
+  private[this] def copy(boolean: Option[String] = boolean, numeric: Option[String] = numeric, string: Option[String] = string): TerminalCapabilitiesQuery = {
+    new TerminalCapabilitiesQuery(boolean, numeric, string)
+  }
+  def withBoolean(boolean: Option[String]): TerminalCapabilitiesQuery = {
+    copy(boolean = boolean)
+  }
+  def withBoolean(boolean: String): TerminalCapabilitiesQuery = {
+    copy(boolean = Option(boolean))
+  }
+  def withNumeric(numeric: Option[String]): TerminalCapabilitiesQuery = {
+    copy(numeric = numeric)
+  }
+  def withNumeric(numeric: String): TerminalCapabilitiesQuery = {
+    copy(numeric = Option(numeric))
+  }
+  def withString(string: Option[String]): TerminalCapabilitiesQuery = {
+    copy(string = string)
+  }
+  def withString(string: String): TerminalCapabilitiesQuery = {
+    copy(string = Option(string))
+  }
+}
+object TerminalCapabilitiesQuery {
+  
+  def apply(boolean: Option[String], numeric: Option[String], string: Option[String]): TerminalCapabilitiesQuery = new TerminalCapabilitiesQuery(boolean, numeric, string)
+  def apply(boolean: String, numeric: String, string: String): TerminalCapabilitiesQuery = new TerminalCapabilitiesQuery(Option(boolean), Option(numeric), Option(string))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalCapabilitiesResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalCapabilitiesResponse.scala
new file mode 100644
index 000000000..e9af177ce
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalCapabilitiesResponse.scala
@@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalCapabilitiesResponse private (
+  val boolean: Option[Boolean],
+  val numeric: Option[Int],
+  val string: Option[String]) extends sbt.protocol.EventMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalCapabilitiesResponse => (this.boolean == x.boolean) && (this.numeric == x.numeric) && (this.string == x.string)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.protocol.TerminalCapabilitiesResponse".##) + boolean.##) + numeric.##) + string.##)
+  }
+  override def toString: String = {
+    "TerminalCapabilitiesResponse(" + boolean + ", " + numeric + ", " + string + ")"
+  }
+  private[this] def copy(boolean: Option[Boolean] = boolean, numeric: Option[Int] = numeric, string: Option[String] = string): TerminalCapabilitiesResponse = {
+    new TerminalCapabilitiesResponse(boolean, numeric, string)
+  }
+  def withBoolean(boolean: Option[Boolean]): TerminalCapabilitiesResponse = {
+    copy(boolean = boolean)
+  }
+  def withBoolean(boolean: Boolean): TerminalCapabilitiesResponse = {
+    copy(boolean = Option(boolean))
+  }
+  def withNumeric(numeric: Option[Int]): TerminalCapabilitiesResponse = {
+    copy(numeric = numeric)
+  }
+  def withNumeric(numeric: Int): TerminalCapabilitiesResponse = {
+    copy(numeric = Option(numeric))
+  }
+  def withString(string: Option[String]): TerminalCapabilitiesResponse = {
+    copy(string = string)
+  }
+  def withString(string: String): TerminalCapabilitiesResponse = {
+    copy(string = Option(string))
+  }
+}
+object TerminalCapabilitiesResponse {
+  
+  def apply(boolean: Option[Boolean], numeric: Option[Int], string: Option[String]): TerminalCapabilitiesResponse = new TerminalCapabilitiesResponse(boolean, numeric, string)
+  def apply(boolean: Boolean, numeric: Int, string: String): TerminalCapabilitiesResponse = new TerminalCapabilitiesResponse(Option(boolean), Option(numeric), Option(string))
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalGetSizeQuery.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalGetSizeQuery.scala
new file mode 100644
index 000000000..f37c708c7
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalGetSizeQuery.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalGetSizeQuery private () extends sbt.protocol.CommandMessage() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TerminalGetSizeQuery => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.TerminalGetSizeQuery".##)
+}
+override def toString: String = {
+  "TerminalGetSizeQuery()"
+}
+private[this] def copy(): TerminalGetSizeQuery = {
+  new TerminalGetSizeQuery()
+}
+
+}
+object TerminalGetSizeQuery {
+  
+  def apply(): TerminalGetSizeQuery = new TerminalGetSizeQuery()
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalGetSizeResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalGetSizeResponse.scala
new file mode 100644
index 000000000..9aedd98ff
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalGetSizeResponse.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalGetSizeResponse private (
+  val width: Int,
+  val height: Int) extends sbt.protocol.EventMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalGetSizeResponse => (this.width == x.width) && (this.height == x.height)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.TerminalGetSizeResponse".##) + width.##) + height.##)
+  }
+  override def toString: String = {
+    "TerminalGetSizeResponse(" + width + ", " + height + ")"
+  }
+  private[this] def copy(width: Int = width, height: Int = height): TerminalGetSizeResponse = {
+    new TerminalGetSizeResponse(width, height)
+  }
+  def withWidth(width: Int): TerminalGetSizeResponse = {
+    copy(width = width)
+  }
+  def withHeight(height: Int): TerminalGetSizeResponse = {
+    copy(height = height)
+  }
+}
+object TerminalGetSizeResponse {
+  
+  def apply(width: Int, height: Int): TerminalGetSizeResponse = new TerminalGetSizeResponse(width, height)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalPropertiesResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalPropertiesResponse.scala
new file mode 100644
index 000000000..2ff7799f7
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalPropertiesResponse.scala
@@ -0,0 +1,52 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalPropertiesResponse private (
+  val width: Int,
+  val height: Int,
+  val isAnsiSupported: Boolean,
+  val isColorEnabled: Boolean,
+  val isSupershellEnabled: Boolean,
+  val isEchoEnabled: Boolean) extends sbt.protocol.EventMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalPropertiesResponse => (this.width == x.width) && (this.height == x.height) && (this.isAnsiSupported == x.isAnsiSupported) && (this.isColorEnabled == x.isColorEnabled) && (this.isSupershellEnabled == x.isSupershellEnabled) && (this.isEchoEnabled == x.isEchoEnabled)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.protocol.TerminalPropertiesResponse".##) + width.##) + height.##) + isAnsiSupported.##) + isColorEnabled.##) + isSupershellEnabled.##) + isEchoEnabled.##)
+  }
+  override def toString: String = {
+    "TerminalPropertiesResponse(" + width + ", " + height + ", " + isAnsiSupported + ", " + isColorEnabled + ", " + isSupershellEnabled + ", " + isEchoEnabled + ")"
+  }
+  private[this] def copy(width: Int = width, height: Int = height, isAnsiSupported: Boolean = isAnsiSupported, isColorEnabled: Boolean = isColorEnabled, isSupershellEnabled: Boolean = isSupershellEnabled, isEchoEnabled: Boolean = isEchoEnabled): TerminalPropertiesResponse = {
+    new TerminalPropertiesResponse(width, height, isAnsiSupported, isColorEnabled, isSupershellEnabled, isEchoEnabled)
+  }
+  def withWidth(width: Int): TerminalPropertiesResponse = {
+    copy(width = width)
+  }
+  def withHeight(height: Int): TerminalPropertiesResponse = {
+    copy(height = height)
+  }
+  def withIsAnsiSupported(isAnsiSupported: Boolean): TerminalPropertiesResponse = {
+    copy(isAnsiSupported = isAnsiSupported)
+  }
+  def withIsColorEnabled(isColorEnabled: Boolean): TerminalPropertiesResponse = {
+    copy(isColorEnabled = isColorEnabled)
+  }
+  def withIsSupershellEnabled(isSupershellEnabled: Boolean): TerminalPropertiesResponse = {
+    copy(isSupershellEnabled = isSupershellEnabled)
+  }
+  def withIsEchoEnabled(isEchoEnabled: Boolean): TerminalPropertiesResponse = {
+    copy(isEchoEnabled = isEchoEnabled)
+  }
+}
+object TerminalPropertiesResponse {
+  
+  def apply(width: Int, height: Int, isAnsiSupported: Boolean, isColorEnabled: Boolean, isSupershellEnabled: Boolean, isEchoEnabled: Boolean): TerminalPropertiesResponse = new TerminalPropertiesResponse(width, height, isAnsiSupported, isColorEnabled, isSupershellEnabled, isEchoEnabled)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetAttributesCommand.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetAttributesCommand.scala
new file mode 100644
index 000000000..dcbe4cdd4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetAttributesCommand.scala
@@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetAttributesCommand private (
+  val iflag: String,
+  val oflag: String,
+  val cflag: String,
+  val lflag: String,
+  val cchars: String) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalSetAttributesCommand => (this.iflag == x.iflag) && (this.oflag == x.oflag) && (this.cflag == x.cflag) && (this.lflag == x.lflag) && (this.cchars == x.cchars)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.protocol.TerminalSetAttributesCommand".##) + iflag.##) + oflag.##) + cflag.##) + lflag.##) + cchars.##)
+  }
+  override def toString: String = {
+    "TerminalSetAttributesCommand(" + iflag + ", " + oflag + ", " + cflag + ", " + lflag + ", " + cchars + ")"
+  }
+  private[this] def copy(iflag: String = iflag, oflag: String = oflag, cflag: String = cflag, lflag: String = lflag, cchars: String = cchars): TerminalSetAttributesCommand = {
+    new TerminalSetAttributesCommand(iflag, oflag, cflag, lflag, cchars)
+  }
+  def withIflag(iflag: String): TerminalSetAttributesCommand = {
+    copy(iflag = iflag)
+  }
+  def withOflag(oflag: String): TerminalSetAttributesCommand = {
+    copy(oflag = oflag)
+  }
+  def withCflag(cflag: String): TerminalSetAttributesCommand = {
+    copy(cflag = cflag)
+  }
+  def withLflag(lflag: String): TerminalSetAttributesCommand = {
+    copy(lflag = lflag)
+  }
+  def withCchars(cchars: String): TerminalSetAttributesCommand = {
+    copy(cchars = cchars)
+  }
+}
+object TerminalSetAttributesCommand {
+  
+  def apply(iflag: String, oflag: String, cflag: String, lflag: String, cchars: String): TerminalSetAttributesCommand = new TerminalSetAttributesCommand(iflag, oflag, cflag, lflag, cchars)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetAttributesResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetAttributesResponse.scala
new file mode 100644
index 000000000..bf22b6e10
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetAttributesResponse.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetAttributesResponse private () extends sbt.protocol.EventMessage() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TerminalSetAttributesResponse => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.TerminalSetAttributesResponse".##)
+}
+override def toString: String = {
+  "TerminalSetAttributesResponse()"
+}
+private[this] def copy(): TerminalSetAttributesResponse = {
+  new TerminalSetAttributesResponse()
+}
+
+}
+object TerminalSetAttributesResponse {
+  
+  def apply(): TerminalSetAttributesResponse = new TerminalSetAttributesResponse()
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetEchoCommand.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetEchoCommand.scala
new file mode 100644
index 000000000..aea0387d8
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetEchoCommand.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetEchoCommand private (
+  val toggle: Boolean) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalSetEchoCommand => (this.toggle == x.toggle)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.TerminalSetEchoCommand".##) + toggle.##)
+  }
+  override def toString: String = {
+    "TerminalSetEchoCommand(" + toggle + ")"
+  }
+  private[this] def copy(toggle: Boolean = toggle): TerminalSetEchoCommand = {
+    new TerminalSetEchoCommand(toggle)
+  }
+  def withToggle(toggle: Boolean): TerminalSetEchoCommand = {
+    copy(toggle = toggle)
+  }
+}
+object TerminalSetEchoCommand {
+  
+  def apply(toggle: Boolean): TerminalSetEchoCommand = new TerminalSetEchoCommand(toggle)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetEchoResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetEchoResponse.scala
new file mode 100644
index 000000000..979b1205e
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetEchoResponse.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetEchoResponse private () extends sbt.protocol.EventMessage() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TerminalSetEchoResponse => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.TerminalSetEchoResponse".##)
+}
+override def toString: String = {
+  "TerminalSetEchoResponse()"
+}
+private[this] def copy(): TerminalSetEchoResponse = {
+  new TerminalSetEchoResponse()
+}
+
+}
+object TerminalSetEchoResponse {
+  
+  def apply(): TerminalSetEchoResponse = new TerminalSetEchoResponse()
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetRawModeCommand.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetRawModeCommand.scala
new file mode 100644
index 000000000..299124161
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetRawModeCommand.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetRawModeCommand private (
+  val toggle: Boolean) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalSetRawModeCommand => (this.toggle == x.toggle)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.TerminalSetRawModeCommand".##) + toggle.##)
+  }
+  override def toString: String = {
+    "TerminalSetRawModeCommand(" + toggle + ")"
+  }
+  private[this] def copy(toggle: Boolean = toggle): TerminalSetRawModeCommand = {
+    new TerminalSetRawModeCommand(toggle)
+  }
+  def withToggle(toggle: Boolean): TerminalSetRawModeCommand = {
+    copy(toggle = toggle)
+  }
+}
+object TerminalSetRawModeCommand {
+  
+  def apply(toggle: Boolean): TerminalSetRawModeCommand = new TerminalSetRawModeCommand(toggle)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetRawModeResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetRawModeResponse.scala
new file mode 100644
index 000000000..9cc4e7f79
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetRawModeResponse.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetRawModeResponse private () extends sbt.protocol.EventMessage() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TerminalSetRawModeResponse => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.TerminalSetRawModeResponse".##)
+}
+override def toString: String = {
+  "TerminalSetRawModeResponse()"
+}
+private[this] def copy(): TerminalSetRawModeResponse = {
+  new TerminalSetRawModeResponse()
+}
+
+}
+object TerminalSetRawModeResponse {
+  
+  def apply(): TerminalSetRawModeResponse = new TerminalSetRawModeResponse()
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetSizeCommand.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetSizeCommand.scala
new file mode 100644
index 000000000..f51f5ae16
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetSizeCommand.scala
@@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetSizeCommand private (
+  val width: Int,
+  val height: Int) extends sbt.protocol.CommandMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TerminalSetSizeCommand => (this.width == x.width) && (this.height == x.height)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.TerminalSetSizeCommand".##) + width.##) + height.##)
+  }
+  override def toString: String = {
+    "TerminalSetSizeCommand(" + width + ", " + height + ")"
+  }
+  private[this] def copy(width: Int = width, height: Int = height): TerminalSetSizeCommand = {
+    new TerminalSetSizeCommand(width, height)
+  }
+  def withWidth(width: Int): TerminalSetSizeCommand = {
+    copy(width = width)
+  }
+  def withHeight(height: Int): TerminalSetSizeCommand = {
+    copy(height = height)
+  }
+}
+object TerminalSetSizeCommand {
+  
+  def apply(width: Int, height: Int): TerminalSetSizeCommand = new TerminalSetSizeCommand(width, height)
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetSizeResponse.scala b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetSizeResponse.scala
new file mode 100644
index 000000000..5465dc037
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/TerminalSetSizeResponse.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol
+final class TerminalSetSizeResponse private () extends sbt.protocol.EventMessage() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TerminalSetSizeResponse => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.TerminalSetSizeResponse".##)
+}
+override def toString: String = {
+  "TerminalSetSizeResponse()"
+}
+private[this] def copy(): TerminalSetSizeResponse = {
+  new TerminalSetSizeResponse()
+}
+
+}
+object TerminalSetSizeResponse {
+  
+  def apply(): TerminalSetSizeResponse = new TerminalSetSizeResponse()
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/AttachFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/AttachFormats.scala
new file mode 100644
index 000000000..a8be3f15e
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/AttachFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait AttachFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val AttachFormat: JsonFormat[sbt.protocol.Attach] = new JsonFormat[sbt.protocol.Attach] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.Attach = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val interactive = unbuilder.readField[Boolean]("interactive")
+      unbuilder.endObject()
+      sbt.protocol.Attach(interactive)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.Attach, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("interactive", obj.interactive)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/ChannelAcceptedEventFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/ChannelAcceptedEventFormats.scala
new file mode 100644
index 000000000..196a154f0
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/ChannelAcceptedEventFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ChannelAcceptedEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ChannelAcceptedEventFormat: JsonFormat[sbt.protocol.ChannelAcceptedEvent] = new JsonFormat[sbt.protocol.ChannelAcceptedEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ChannelAcceptedEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val channelName = unbuilder.readField[String]("channelName")
+      unbuilder.endObject()
+      sbt.protocol.ChannelAcceptedEvent(channelName)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.ChannelAcceptedEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("channelName", obj.channelName)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/CommandMessageFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/CommandMessageFormats.scala
new file mode 100644
index 000000000..6f95b6f48
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/CommandMessageFormats.scala
@@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+
+import _root_.sjsonnew.JsonFormat
+trait CommandMessageFormats { self: sjsonnew.BasicJsonProtocol with sbt.protocol.codec.InitCommandFormats with sbt.protocol.codec.ExecCommandFormats with sbt.protocol.codec.SettingQueryFormats with sbt.protocol.codec.AttachFormats with sbt.protocol.codec.TerminalCapabilitiesQueryFormats with sbt.protocol.codec.TerminalSetAttributesCommandFormats with sbt.protocol.codec.TerminalAttributesQueryFormats with sbt.protocol.codec.TerminalGetSizeQueryFormats with sbt.protocol.codec.TerminalSetSizeCommandFormats with sbt.protocol.codec.TerminalSetEchoCommandFormats with sbt.protocol.codec.TerminalSetRawModeCommandFormats =>
+implicit lazy val CommandMessageFormat: JsonFormat[sbt.protocol.CommandMessage] = flatUnionFormat11[sbt.protocol.CommandMessage, sbt.protocol.InitCommand, sbt.protocol.ExecCommand, sbt.protocol.SettingQuery, sbt.protocol.Attach, sbt.protocol.TerminalCapabilitiesQuery, sbt.protocol.TerminalSetAttributesCommand, sbt.protocol.TerminalAttributesQuery, sbt.protocol.TerminalGetSizeQuery, sbt.protocol.TerminalSetSizeCommand, sbt.protocol.TerminalSetEchoCommand, sbt.protocol.TerminalSetRawModeCommand]("type")
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionParamsFormats.scala
new file mode 100644
index 000000000..0c9ee5848
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionParamsFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CompletionParamsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val CompletionParamsFormat: JsonFormat[sbt.protocol.CompletionParams] = new JsonFormat[sbt.protocol.CompletionParams] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.CompletionParams = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val query = unbuilder.readField[String]("query")
+      val level = unbuilder.readField[Option[Int]]("level")
+      unbuilder.endObject()
+      sbt.protocol.CompletionParams(query, level)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.CompletionParams, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("query", obj.query)
+    builder.addField("level", obj.level)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionResponseFormats.scala
new file mode 100644
index 000000000..c9716abf0
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/CompletionResponseFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CompletionResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val CompletionResponseFormat: JsonFormat[sbt.protocol.CompletionResponse] = new JsonFormat[sbt.protocol.CompletionResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.CompletionResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val items = unbuilder.readField[Vector[String]]("items")
+      val cachedMainClassNames = unbuilder.readField[Option[Boolean]]("cachedMainClassNames")
+      val cachedTestNames = unbuilder.readField[Option[Boolean]]("cachedTestNames")
+      unbuilder.endObject()
+      sbt.protocol.CompletionResponse(items, cachedMainClassNames, cachedTestNames)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.CompletionResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("items", obj.items)
+    builder.addField("cachedMainClassNames", obj.cachedMainClassNames)
+    builder.addField("cachedTestNames", obj.cachedTestNames)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/EventMessageFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/EventMessageFormats.scala
new file mode 100644
index 000000000..b52b1b365
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/EventMessageFormats.scala
@@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+
+import _root_.sjsonnew.JsonFormat
+trait EventMessageFormats { self: sjsonnew.BasicJsonProtocol with sbt.protocol.codec.ChannelAcceptedEventFormats with sbt.protocol.codec.LogEventFormats with sbt.protocol.codec.ExecStatusEventFormats with sbt.internal.util.codec.JValueFormats with sbt.protocol.codec.SettingQuerySuccessFormats with sbt.protocol.codec.SettingQueryFailureFormats with sbt.protocol.codec.TerminalPropertiesResponseFormats with sbt.protocol.codec.TerminalCapabilitiesResponseFormats with sbt.protocol.codec.TerminalSetAttributesResponseFormats with sbt.protocol.codec.TerminalAttributesResponseFormats with sbt.protocol.codec.TerminalGetSizeResponseFormats with sbt.protocol.codec.TerminalSetSizeResponseFormats with sbt.protocol.codec.TerminalSetEchoResponseFormats with sbt.protocol.codec.TerminalSetRawModeResponseFormats =>
+implicit lazy val EventMessageFormat: JsonFormat[sbt.protocol.EventMessage] = flatUnionFormat13[sbt.protocol.EventMessage, sbt.protocol.ChannelAcceptedEvent, sbt.protocol.LogEvent, sbt.protocol.ExecStatusEvent, sbt.protocol.SettingQuerySuccess, sbt.protocol.SettingQueryFailure, sbt.protocol.TerminalPropertiesResponse, sbt.protocol.TerminalCapabilitiesResponse, sbt.protocol.TerminalSetAttributesResponse, sbt.protocol.TerminalAttributesResponse, sbt.protocol.TerminalGetSizeResponse, sbt.protocol.TerminalSetSizeResponse, sbt.protocol.TerminalSetEchoResponse, sbt.protocol.TerminalSetRawModeResponse]("type")
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecCommandFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecCommandFormats.scala
new file mode 100644
index 000000000..e25e56c52
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecCommandFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ExecCommandFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ExecCommandFormat: JsonFormat[sbt.protocol.ExecCommand] = new JsonFormat[sbt.protocol.ExecCommand] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecCommand = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val commandLine = unbuilder.readField[String]("commandLine")
+      val execId = unbuilder.readField[Option[String]]("execId")
+      unbuilder.endObject()
+      sbt.protocol.ExecCommand(commandLine, execId)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.ExecCommand, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("commandLine", obj.commandLine)
+    builder.addField("execId", obj.execId)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecStatusEventFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecStatusEventFormats.scala
new file mode 100644
index 000000000..293d276e1
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecStatusEventFormats.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ExecStatusEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ExecStatusEventFormat: JsonFormat[sbt.protocol.ExecStatusEvent] = new JsonFormat[sbt.protocol.ExecStatusEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecStatusEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val status = unbuilder.readField[String]("status")
+      val channelName = unbuilder.readField[Option[String]]("channelName")
+      val execId = unbuilder.readField[Option[String]]("execId")
+      val commandQueue = unbuilder.readField[Vector[String]]("commandQueue")
+      val exitCode = unbuilder.readField[Option[Long]]("exitCode")
+      val message = unbuilder.readField[Option[String]]("message")
+      unbuilder.endObject()
+      sbt.protocol.ExecStatusEvent(status, channelName, execId, commandQueue, exitCode, message)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.ExecStatusEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("status", obj.status)
+    builder.addField("channelName", obj.channelName)
+    builder.addField("execId", obj.execId)
+    builder.addField("commandQueue", obj.commandQueue)
+    builder.addField("exitCode", obj.exitCode)
+    builder.addField("message", obj.message)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecutionEventFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecutionEventFormats.scala
new file mode 100644
index 000000000..544bd893c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecutionEventFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ExecutionEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ExecutionEventFormat: JsonFormat[sbt.protocol.ExecutionEvent] = new JsonFormat[sbt.protocol.ExecutionEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.ExecutionEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val success = unbuilder.readField[String]("success")
+      val commandLine = unbuilder.readField[String]("commandLine")
+      unbuilder.endObject()
+      sbt.protocol.ExecutionEvent(success, commandLine)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.ExecutionEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("success", obj.success)
+    builder.addField("commandLine", obj.commandLine)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/InitCommandFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/InitCommandFormats.scala
new file mode 100644
index 000000000..827b6dc7c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/InitCommandFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InitCommandFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val InitCommandFormat: JsonFormat[sbt.protocol.InitCommand] = new JsonFormat[sbt.protocol.InitCommand] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.InitCommand = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val token = unbuilder.readField[Option[String]]("token")
+      val execId = unbuilder.readField[Option[String]]("execId")
+      val skipAnalysis = unbuilder.readField[Option[Boolean]]("skipAnalysis")
+      unbuilder.endObject()
+      sbt.protocol.InitCommand(token, execId, skipAnalysis)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.InitCommand, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("token", obj.token)
+    builder.addField("execId", obj.execId)
+    builder.addField("skipAnalysis", obj.skipAnalysis)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/JsonProtocol.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/JsonProtocol.scala
new file mode 100644
index 000000000..2df56d1ad
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/JsonProtocol.scala
@@ -0,0 +1,39 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+trait JsonProtocol extends sjsonnew.BasicJsonProtocol
+  with sbt.protocol.codec.InitCommandFormats
+  with sbt.protocol.codec.ExecCommandFormats
+  with sbt.protocol.codec.SettingQueryFormats
+  with sbt.protocol.codec.AttachFormats
+  with sbt.protocol.codec.TerminalCapabilitiesQueryFormats
+  with sbt.protocol.codec.TerminalSetAttributesCommandFormats
+  with sbt.protocol.codec.TerminalAttributesQueryFormats
+  with sbt.protocol.codec.TerminalGetSizeQueryFormats
+  with sbt.protocol.codec.TerminalSetSizeCommandFormats
+  with sbt.protocol.codec.TerminalSetEchoCommandFormats
+  with sbt.protocol.codec.TerminalSetRawModeCommandFormats
+  with sbt.protocol.codec.CommandMessageFormats
+  with sbt.protocol.codec.CompletionParamsFormats
+  with sbt.protocol.codec.ChannelAcceptedEventFormats
+  with sbt.protocol.codec.LogEventFormats
+  with sbt.protocol.codec.ExecStatusEventFormats
+  with sbt.internal.util.codec.JValueFormats
+  with sbt.protocol.codec.SettingQuerySuccessFormats
+  with sbt.protocol.codec.SettingQueryFailureFormats
+  with sbt.protocol.codec.TerminalPropertiesResponseFormats
+  with sbt.protocol.codec.TerminalCapabilitiesResponseFormats
+  with sbt.protocol.codec.TerminalSetAttributesResponseFormats
+  with sbt.protocol.codec.TerminalAttributesResponseFormats
+  with sbt.protocol.codec.TerminalGetSizeResponseFormats
+  with sbt.protocol.codec.TerminalSetSizeResponseFormats
+  with sbt.protocol.codec.TerminalSetEchoResponseFormats
+  with sbt.protocol.codec.TerminalSetRawModeResponseFormats
+  with sbt.protocol.codec.EventMessageFormats
+  with sbt.protocol.codec.SettingQueryResponseFormats
+  with sbt.protocol.codec.CompletionResponseFormats
+  with sbt.protocol.codec.ExecutionEventFormats
+object JsonProtocol extends JsonProtocol
\ No newline at end of file
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/LogEventFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/LogEventFormats.scala
new file mode 100644
index 000000000..17b78e340
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/LogEventFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait LogEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val LogEventFormat: JsonFormat[sbt.protocol.LogEvent] = new JsonFormat[sbt.protocol.LogEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.LogEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val level = unbuilder.readField[String]("level")
+      val message = unbuilder.readField[String]("message")
+      unbuilder.endObject()
+      sbt.protocol.LogEvent(level, message)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.LogEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("level", obj.level)
+    builder.addField("message", obj.message)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFailureFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFailureFormats.scala
new file mode 100644
index 000000000..b28439366
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFailureFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SettingQueryFailureFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val SettingQueryFailureFormat: JsonFormat[sbt.protocol.SettingQueryFailure] = new JsonFormat[sbt.protocol.SettingQueryFailure] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQueryFailure = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val message = unbuilder.readField[String]("message")
+      unbuilder.endObject()
+      sbt.protocol.SettingQueryFailure(message)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.SettingQueryFailure, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("message", obj.message)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFormats.scala
new file mode 100644
index 000000000..60ad0738b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SettingQueryFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val SettingQueryFormat: JsonFormat[sbt.protocol.SettingQuery] = new JsonFormat[sbt.protocol.SettingQuery] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQuery = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val setting = unbuilder.readField[String]("setting")
+      unbuilder.endObject()
+      sbt.protocol.SettingQuery(setting)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.SettingQuery, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("setting", obj.setting)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryResponseFormats.scala
new file mode 100644
index 000000000..b991a5011
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQueryResponseFormats.scala
@@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+
+import _root_.sjsonnew.JsonFormat
+trait SettingQueryResponseFormats { self: sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol with sbt.protocol.codec.SettingQuerySuccessFormats with sbt.protocol.codec.SettingQueryFailureFormats =>
+implicit lazy val SettingQueryResponseFormat: JsonFormat[sbt.protocol.SettingQueryResponse] = flatUnionFormat2[sbt.protocol.SettingQueryResponse, sbt.protocol.SettingQuerySuccess, sbt.protocol.SettingQueryFailure]("type")
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQuerySuccessFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQuerySuccessFormats.scala
new file mode 100644
index 000000000..51f1c623b
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQuerySuccessFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SettingQuerySuccessFormats { self: sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SettingQuerySuccessFormat: JsonFormat[sbt.protocol.SettingQuerySuccess] = new JsonFormat[sbt.protocol.SettingQuerySuccess] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.SettingQuerySuccess = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val value = unbuilder.readField[sjsonnew.shaded.scalajson.ast.unsafe.JValue]("value")
+      val contentType = unbuilder.readField[String]("contentType")
+      unbuilder.endObject()
+      sbt.protocol.SettingQuerySuccess(value, contentType)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.SettingQuerySuccess, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("value", obj.value)
+    builder.addField("contentType", obj.contentType)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalAttributesQueryFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalAttributesQueryFormats.scala
new file mode 100644
index 000000000..a91e08aa5
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalAttributesQueryFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalAttributesQueryFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalAttributesQueryFormat: JsonFormat[sbt.protocol.TerminalAttributesQuery] = new JsonFormat[sbt.protocol.TerminalAttributesQuery] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalAttributesQuery = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.protocol.TerminalAttributesQuery()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalAttributesQuery, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalAttributesResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalAttributesResponseFormats.scala
new file mode 100644
index 000000000..e117c0389
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalAttributesResponseFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalAttributesResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalAttributesResponseFormat: JsonFormat[sbt.protocol.TerminalAttributesResponse] = new JsonFormat[sbt.protocol.TerminalAttributesResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalAttributesResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val iflag = unbuilder.readField[String]("iflag")
+      val oflag = unbuilder.readField[String]("oflag")
+      val cflag = unbuilder.readField[String]("cflag")
+      val lflag = unbuilder.readField[String]("lflag")
+      val cchars = unbuilder.readField[String]("cchars")
+      unbuilder.endObject()
+      sbt.protocol.TerminalAttributesResponse(iflag, oflag, cflag, lflag, cchars)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalAttributesResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("iflag", obj.iflag)
+    builder.addField("oflag", obj.oflag)
+    builder.addField("cflag", obj.cflag)
+    builder.addField("lflag", obj.lflag)
+    builder.addField("cchars", obj.cchars)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalCapabilitiesQueryFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalCapabilitiesQueryFormats.scala
new file mode 100644
index 000000000..a26886a46
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalCapabilitiesQueryFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalCapabilitiesQueryFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalCapabilitiesQueryFormat: JsonFormat[sbt.protocol.TerminalCapabilitiesQuery] = new JsonFormat[sbt.protocol.TerminalCapabilitiesQuery] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalCapabilitiesQuery = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val boolean = unbuilder.readField[Option[String]]("boolean")
+      val numeric = unbuilder.readField[Option[String]]("numeric")
+      val string = unbuilder.readField[Option[String]]("string")
+      unbuilder.endObject()
+      sbt.protocol.TerminalCapabilitiesQuery(boolean, numeric, string)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalCapabilitiesQuery, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("boolean", obj.boolean)
+    builder.addField("numeric", obj.numeric)
+    builder.addField("string", obj.string)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalCapabilitiesResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalCapabilitiesResponseFormats.scala
new file mode 100644
index 000000000..eff1f27f4
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalCapabilitiesResponseFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalCapabilitiesResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalCapabilitiesResponseFormat: JsonFormat[sbt.protocol.TerminalCapabilitiesResponse] = new JsonFormat[sbt.protocol.TerminalCapabilitiesResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalCapabilitiesResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val boolean = unbuilder.readField[Option[Boolean]]("boolean")
+      val numeric = unbuilder.readField[Option[Int]]("numeric")
+      val string = unbuilder.readField[Option[String]]("string")
+      unbuilder.endObject()
+      sbt.protocol.TerminalCapabilitiesResponse(boolean, numeric, string)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalCapabilitiesResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("boolean", obj.boolean)
+    builder.addField("numeric", obj.numeric)
+    builder.addField("string", obj.string)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalGetSizeQueryFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalGetSizeQueryFormats.scala
new file mode 100644
index 000000000..9989ad96c
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalGetSizeQueryFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalGetSizeQueryFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalGetSizeQueryFormat: JsonFormat[sbt.protocol.TerminalGetSizeQuery] = new JsonFormat[sbt.protocol.TerminalGetSizeQuery] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalGetSizeQuery = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.protocol.TerminalGetSizeQuery()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalGetSizeQuery, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalGetSizeResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalGetSizeResponseFormats.scala
new file mode 100644
index 000000000..c5c489a8d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalGetSizeResponseFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalGetSizeResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalGetSizeResponseFormat: JsonFormat[sbt.protocol.TerminalGetSizeResponse] = new JsonFormat[sbt.protocol.TerminalGetSizeResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalGetSizeResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val width = unbuilder.readField[Int]("width")
+      val height = unbuilder.readField[Int]("height")
+      unbuilder.endObject()
+      sbt.protocol.TerminalGetSizeResponse(width, height)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalGetSizeResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("width", obj.width)
+    builder.addField("height", obj.height)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalPropertiesResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalPropertiesResponseFormats.scala
new file mode 100644
index 000000000..ee4712e0d
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalPropertiesResponseFormats.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalPropertiesResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalPropertiesResponseFormat: JsonFormat[sbt.protocol.TerminalPropertiesResponse] = new JsonFormat[sbt.protocol.TerminalPropertiesResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalPropertiesResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val width = unbuilder.readField[Int]("width")
+      val height = unbuilder.readField[Int]("height")
+      val isAnsiSupported = unbuilder.readField[Boolean]("isAnsiSupported")
+      val isColorEnabled = unbuilder.readField[Boolean]("isColorEnabled")
+      val isSupershellEnabled = unbuilder.readField[Boolean]("isSupershellEnabled")
+      val isEchoEnabled = unbuilder.readField[Boolean]("isEchoEnabled")
+      unbuilder.endObject()
+      sbt.protocol.TerminalPropertiesResponse(width, height, isAnsiSupported, isColorEnabled, isSupershellEnabled, isEchoEnabled)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalPropertiesResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("width", obj.width)
+    builder.addField("height", obj.height)
+    builder.addField("isAnsiSupported", obj.isAnsiSupported)
+    builder.addField("isColorEnabled", obj.isColorEnabled)
+    builder.addField("isSupershellEnabled", obj.isSupershellEnabled)
+    builder.addField("isEchoEnabled", obj.isEchoEnabled)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetAttributesCommandFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetAttributesCommandFormats.scala
new file mode 100644
index 000000000..021c9c226
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetAttributesCommandFormats.scala
@@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetAttributesCommandFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetAttributesCommandFormat: JsonFormat[sbt.protocol.TerminalSetAttributesCommand] = new JsonFormat[sbt.protocol.TerminalSetAttributesCommand] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetAttributesCommand = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val iflag = unbuilder.readField[String]("iflag")
+      val oflag = unbuilder.readField[String]("oflag")
+      val cflag = unbuilder.readField[String]("cflag")
+      val lflag = unbuilder.readField[String]("lflag")
+      val cchars = unbuilder.readField[String]("cchars")
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetAttributesCommand(iflag, oflag, cflag, lflag, cchars)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetAttributesCommand, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("iflag", obj.iflag)
+    builder.addField("oflag", obj.oflag)
+    builder.addField("cflag", obj.cflag)
+    builder.addField("lflag", obj.lflag)
+    builder.addField("cchars", obj.cchars)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetAttributesResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetAttributesResponseFormats.scala
new file mode 100644
index 000000000..af4f3611a
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetAttributesResponseFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetAttributesResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetAttributesResponseFormat: JsonFormat[sbt.protocol.TerminalSetAttributesResponse] = new JsonFormat[sbt.protocol.TerminalSetAttributesResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetAttributesResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetAttributesResponse()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetAttributesResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetEchoCommandFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetEchoCommandFormats.scala
new file mode 100644
index 000000000..13ac39d98
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetEchoCommandFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetEchoCommandFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetEchoCommandFormat: JsonFormat[sbt.protocol.TerminalSetEchoCommand] = new JsonFormat[sbt.protocol.TerminalSetEchoCommand] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetEchoCommand = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val toggle = unbuilder.readField[Boolean]("toggle")
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetEchoCommand(toggle)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetEchoCommand, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("toggle", obj.toggle)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetEchoResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetEchoResponseFormats.scala
new file mode 100644
index 000000000..9bc022b3a
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetEchoResponseFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetEchoResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetEchoResponseFormat: JsonFormat[sbt.protocol.TerminalSetEchoResponse] = new JsonFormat[sbt.protocol.TerminalSetEchoResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetEchoResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetEchoResponse()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetEchoResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetRawModeCommandFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetRawModeCommandFormats.scala
new file mode 100644
index 000000000..08712cd50
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetRawModeCommandFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetRawModeCommandFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetRawModeCommandFormat: JsonFormat[sbt.protocol.TerminalSetRawModeCommand] = new JsonFormat[sbt.protocol.TerminalSetRawModeCommand] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetRawModeCommand = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val toggle = unbuilder.readField[Boolean]("toggle")
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetRawModeCommand(toggle)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetRawModeCommand, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("toggle", obj.toggle)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetRawModeResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetRawModeResponseFormats.scala
new file mode 100644
index 000000000..2395b7dc2
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetRawModeResponseFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetRawModeResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetRawModeResponseFormat: JsonFormat[sbt.protocol.TerminalSetRawModeResponse] = new JsonFormat[sbt.protocol.TerminalSetRawModeResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetRawModeResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetRawModeResponse()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetRawModeResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetSizeCommandFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetSizeCommandFormats.scala
new file mode 100644
index 000000000..56fc296a1
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetSizeCommandFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetSizeCommandFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetSizeCommandFormat: JsonFormat[sbt.protocol.TerminalSetSizeCommand] = new JsonFormat[sbt.protocol.TerminalSetSizeCommand] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetSizeCommand = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val width = unbuilder.readField[Int]("width")
+      val height = unbuilder.readField[Int]("height")
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetSizeCommand(width, height)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetSizeCommand, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("width", obj.width)
+    builder.addField("height", obj.height)
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetSizeResponseFormats.scala b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetSizeResponseFormats.scala
new file mode 100644
index 000000000..1da62ae6f
--- /dev/null
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/TerminalSetSizeResponseFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TerminalSetSizeResponseFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TerminalSetSizeResponseFormat: JsonFormat[sbt.protocol.TerminalSetSizeResponse] = new JsonFormat[sbt.protocol.TerminalSetSizeResponse] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.TerminalSetSizeResponse = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.protocol.TerminalSetSizeResponse()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.TerminalSetSizeResponse, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/protocol/src/main/contraband/bsp.contra b/protocol/src/main/contraband/bsp.contra
new file mode 100644
index 000000000..4741cb738
--- /dev/null
+++ b/protocol/src/main/contraband/bsp.contra
@@ -0,0 +1,637 @@
+package sbt.internal.bsp
+@target(Scala)
+@codecPackage("sbt.internal.bsp.codec")
+@fullCodec("JsonProtocol")
+
+## Build target
+type BuildTarget {
+  ## The target’s unique identifier
+  id: sbt.internal.bsp.BuildTargetIdentifier!
+
+  ## A human readable name for this target.
+  ## May be presented in the user interface.
+  ## Should be unique if possible.
+  ## The id.uri is used if None.
+  displayName: String
+
+  ## The directory where this target belongs to. Multiple build targets are allowed to map
+  ## to the same base directory, and a build target is not required to have a base directory.
+  ## A base directory does not determine the sources of a target, see buildTarget/sources.
+  baseDirectory: java.net.URI
+
+  ## Free-form string tags to categorize or label this build target.
+  ## For example, can be used by the client to:
+  ## - customize how the target should be translated into the client's project model.
+  ## - group together different but related targets in the user interface.
+  ## - display icons or colors in the user interface.
+  ## Pre-defined tags are listed in `BuildTargetTag` but clients and servers
+  ## are free to define new tags for custom purposes.
+  tags: [String]
+
+  ## The capabilities of this build target.
+  capabilities: sbt.internal.bsp.BuildTargetCapabilities!
+
+  ## The set of languages that this target contains.
+  ## The ID string for each language is defined in the LSP.
+  languageIds: [String]
+
+  ## The direct upstream build target dependencies of this build target
+  dependencies: [sbt.internal.bsp.BuildTargetIdentifier]
+
+  ## Kind of data to expect in the `data` field. If this field is not set, the kind of data is not specified.
+  dataKind: String
+
+  ## Language-specific metadata about this target.
+  ## See ScalaBuildTarget as an example.
+  data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+## Build Target Identifier
+type BuildTargetIdentifier {
+  ## The target's Uri
+  uri: java.net.URI!
+}
+
+type BuildTargetCapabilities {
+  ## This target can be compiled by the BSP server.
+  canCompile: Boolean!
+
+  ## This target can be tested by the BSP server.
+  canTest: Boolean!
+
+  ## This target can be run by the BSP server.
+  canRun: Boolean!
+}
+
+type DebugSessionAddress {
+  ## The target's Uri
+  uri: java.net.URI!
+}
+
+type DebugSessionParams {
+  ## A sequence of build targets affected by the debugging action.
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+
+  ## The kind of data to expect in the `data` field.
+  dataKind: String
+
+  ## A language-agnostic JSON object interpreted by the server.
+  data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+type TaskId {
+  ## A unique identifier
+  id: String!
+
+  ## The parent task ids, if any. A non-empty parents field means
+  ## this task is a sub-task of every parent task.
+  parents: [String]
+}
+
+type TextDocumentIdentifier {
+  ## The file's Uri
+  uri: java.net.URI!
+}
+
+## Position in a text document expressed as zero-based line and zero-based character offset.
+## A position is between two characters like an 'insert' cursor in a editor.
+type Position {
+  ## Line position in a document (zero-based).
+  line: Long!
+
+  ## Character offset on a line in a document (zero-based).
+  character: Long!
+}
+
+## A range in a text document expressed as (zero-based) start and end positions. A range is comparable to a selection in an editor.
+## Therefore the end position is exclusive.
+type Range {
+  ## The range's start position.
+  start: sbt.internal.bsp.Position!
+
+  ## The range's end position.
+  end: sbt.internal.bsp.Position!
+}
+
+## Represents a diagnostic, such as a compiler error or warning.
+## Diagnostic objects are only valid in the scope of a resource.
+type Diagnostic {
+  ## The range at which the message applies.
+  range: sbt.internal.bsp.Range!
+
+  ## The diagnostic's severity. Can be omitted. If omitted it is up to the
+  ## client to interpret diagnostics as error, warning, info or hint.
+  severity: Long
+
+  ## The diagnostic's code. Can be omitted.
+  code: String
+
+  ## A human-readable string describing the source of this
+  ## diagnostic, e.g. 'typescript' or 'super lint'.
+  source: String
+
+  ## The diagnostic's message.
+  message: String!
+}
+
+## Initialize Build Request
+type InitializeBuildParams {
+  ## Name of the client
+  displayName: String!
+
+  ## The version of the client
+  version: String!
+
+  ## The BSP version that the client speaks
+  bspVersion: String!
+
+  ## The rootUri of the workspace
+  rootUri: java.net.URI!
+
+  ## The capabilities of the client
+  capabilities: sbt.internal.bsp.BuildClientCapabilities!
+
+  ## Additional metadata about the client
+  data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+type BuildClientCapabilities {
+  ## The languages that this client supports.
+  ## The ID strings for each language is defined in the LSP.
+  ## The server must never respond with build targets for other
+  ## languages than those that appear in this list.
+  languageIds: [String]
+}
+
+type InitializeBuildResult {
+  ## Name of the server
+  displayName: String!
+
+  ## The version of the server
+  version: String!
+
+  ## The BSP version that the server speaks
+  bspVersion: String!
+
+  ## The capabilities of the build server
+  capabilities: sbt.internal.bsp.BuildServerCapabilities!
+
+  ## Additional metadata about the server
+  data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+type BuildServerCapabilities {
+  ## The languages the server supports compilation via method buildTarget/compile.
+  compileProvider: sbt.internal.bsp.CompileProvider
+
+  ## The languages the server supports test execution via method buildTarget/test
+  testProvider: sbt.internal.bsp.TestProvider
+
+  # The languages the server supports run via method buildTarget/run
+  runProvider: sbt.internal.bsp.RunProvider
+
+  # The server can provide a list of targets that contain a
+  # single text document via the method buildTarget/inverseSources
+  # inverseSourcesProvider: Boolean
+
+  ## The server provides sources for library dependencies
+  ## via method buildTarget/dependencySources
+  dependencySourcesProvider: Boolean
+
+  # The server provides all the resource dependencies
+  # via method buildTarget/resources
+  # resourcesProvider: Boolean
+
+  ## Reloading the workspace state through workspace/reload is supported
+  canReload: Boolean
+
+  # The server sends notifications to the client on build
+  # target change events via buildTarget/didChange
+  # buildTargetChangedProvider: Boolean
+}
+
+type CompileProvider {
+  languageIds: [String]
+}
+
+type TestProvider {
+  languageIds: [String]
+}
+
+type RunProvider {
+  languageIds: [String]
+}
+
+## Publish Diagnostics
+type PublishDiagnosticsParams {
+  ## The document where the diagnostics are published.
+  textDocument: sbt.internal.bsp.TextDocumentIdentifier!
+
+  ## The build target where the diagnostics origin.
+  ## It is valid for one text to belong to multiple build targets,
+  ## for example sources that are compiled against multiple platforms (JVM, JavaScript).
+  buildTarget: sbt.internal.bsp.BuildTargetIdentifier!
+
+  ## The request id that originated this notification
+  originId: String
+
+  ## The diagnostics to be published by the client
+  diagnostics: [sbt.internal.bsp.Diagnostic]
+
+  ## Whether the client should clear the previous diagnostics
+  ## mapped to the same `textDocument` and buildTarget
+  reset: Boolean!
+}
+
+## Workspace Build Targets response
+type WorkspaceBuildTargetsResult {
+  ## The build targets in this workspace that
+  ## contain sources with the given language ids.
+  targets: [sbt.internal.bsp.BuildTarget]
+}
+
+## Build Target Sources Request
+type SourcesParams {
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+}
+
+## Build Target Sources response
+type SourcesResult {
+  items: [sbt.internal.bsp.SourcesItem]
+}
+
+type SourcesItem {
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+  ## The text documents or and directories that belong to this build target.
+  sources: [sbt.internal.bsp.SourceItem]
+}
+
+type SourceItem {
+  ## Either a text document or a directory. A directory entry must end with a forward
+  ## slash "/" and a directory entry implies that every nested text document within the
+  ## directory belongs to this source item.
+  ##
+  uri: java.net.URI!
+
+  ## Type of file of the source item, such as whether it is file or directory.
+  kind: Int!
+
+  ## Indicates if this source is automatically generated by the build and is not
+  ## intended to be manually edited by the user.
+  generated: Boolean!
+}
+
+## Dependency Sources Request
+type DependencySourcesParams {
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+}
+
+## Dependency Sources Result
+type DependencySourcesResult {
+  items: [sbt.internal.bsp.DependencySourcesItem]
+}
+
+type DependencySourcesItem {
+  target: sbt.internal.bsp.BuildTargetIdentifier
+
+  ## List of resources containing source files of the target's dependencies.
+  ## Can be source files, jar files, zip files, or directories
+  sources: [java.net.URI]
+}
+
+## Task Notifications
+
+type TaskStartParams {
+    ## Unique id of the task with optional reference to parent task id.
+    taskId: sbt.internal.bsp.TaskId!
+
+    ## Optional timestamp of when the event started in milliseconds since Epoch.
+    eventTime: Long
+
+    ## Optional message describing the task.
+    message: String
+
+    ## Kind of data to expect in the `data` field.
+    dataKind: String
+
+    ## Optional metadata about the task.
+    data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+type TaskFinishParams {
+    ## Unique id of the task with optional reference to parent task id.
+    taskId: sbt.internal.bsp.TaskId!
+
+    ## Optional timestamp of when the event started in milliseconds since Epoch.
+    eventTime: Long
+
+    ## Optional message describing the task.
+    message: String
+
+    ## Task completion status: 1 -> success, 2 -> error, 3 -> cancelled
+    status: Int!
+
+    ## Kind of data to expect in the `data` field.
+    dataKind: String
+
+    ## Optional metadata about the task.
+    data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+## Compile Request
+type CompileParams {
+  ## A sequence of build targets to compile
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+  
+  ## An optional unique identifier generated by the client to identify this request.
+  ## The server may include this id in triggered notifications or response.
+  originId: String
+  
+  ## Optional arguments to the compilation process
+  arguments: [String]
+}
+
+## Compile Response
+type BspCompileResult {
+  ## An optional request id to know the origin of this report.
+  originId: String
+  
+  ## A status code for the execution.
+  statusCode: Int!
+
+  # Kind of data to expect in the `data` field.
+  # If this field is not set, the kind of data is not specified.
+  # dataKind: String
+
+  # A field containing language-specific information, like products
+  # of compilation or compiler-specific metadata the client needs to know.
+  # data: any
+}
+
+## Compile Notifications
+
+type CompileTask {
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+}
+
+type CompileReport {
+  ## The build target that was compiled
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+
+  ## An optional request id to know the origin of this report
+  originId: String
+
+  ## The total number of reported errors compiling this target.
+  errors: Int!
+
+  ## The total number of reported warnings compiling the target.
+  warnings: Int!
+
+  ## The total number of milliseconds it took to compile the target.
+  time: Int
+}
+
+## Test Request
+## The test build target request is sent from the client to the server to test the given list of build targets.
+## The server communicates during the initialize handshake whether this method is supported or not.
+type TestParams {
+  ## A sequence of build targets to test.
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+
+  ## An option identifier generated by the client to identify this request.
+  ## The server may include this id in triggered notifications or responses.
+  originId: String
+
+  ## Optional arguments to the test execution engine.
+  arguments: [String]
+
+  ## Kind of data to expect in the `data` field.
+  ## If this field is not set, the kind of data is not specified.
+  dataKind: String
+
+  ## Language-specific metadata for this test execution.
+  data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+## Test Result
+type TestResult {
+  ## An optional request id to know the origin of this report.
+  originId: String
+
+  ## A status code for the execution.
+  statusCode: Int!
+
+  # Kind of data to expect in the `data` field.
+  # If this field is not set, the kind of data is not specified.
+  # dataKind: String
+
+  # data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+## Run Request
+## The run request is sent from the client to the server to run a build target.
+## The server communicates during the initialize handshake whether this method is supported or not.
+## An empty run request is valid.
+type RunParams {
+  ## The build target to run.
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+
+  ## An option identifier gnerated by the client to identify this request.
+  ## The server may include this id in triggered notifications or responses.
+  originId: String
+
+  ## Optional arguments to the executed application.
+  arguments: [String]
+
+  ## Kind of data to expect in the data field.
+  ## If this field is not set, the kind of data is not specified.
+  dataKind: String
+
+  ## Language-specific metadata for this execution.
+  data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+}
+
+## Run Result
+type RunResult {
+  ## An optional request id to know the origin of this report.
+  originId: String
+
+  ## A status code for the execution.
+  statusCode: Int!
+}
+
+
+# Scala Extension
+
+## Contains scala-specific metadata for compiling a target containing Scala sources.
+## This metadata is embedded in the data: Option[Json] field of the BuildTarget definition,
+## when the dataKind field contains "scala".
+type ScalaBuildTarget {
+  ## The Scala organization that is used for a target.
+  scalaOrganization: String!
+
+  ## The scala version to compile this target
+  scalaVersion: String!
+
+  ## The binary version of scalaVersion.
+  ## For example, 2.12 if scalaVersion is 2.12.4.
+  scalaBinaryVersion: String!
+
+  ## The target platform for this target
+  platform: Int!
+
+  ## A sequence of Scala jars such as scala-library, scala-compiler and scala-reflect.
+  jars: [String]!
+}
+
+# sbt Extension
+
+## Contains sbt-specific metadata for providing editor support for sbt build files.
+## This metadata is embedded in the data: Option[Json] field of the BuildTarget definition
+## when the dataKind field contains "sbt".
+type SbtBuildTarget {
+  ## The sbt version. Useful to support version-dependent syntax.
+  sbtVersion: String!
+
+  ## A sequence of Scala imports that are automatically imported in the sbt build files.
+  autoImports: [String]!
+
+  ## The Scala build target describing the scala
+  ## version and scala jars used by this sbt version.
+  scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget!
+
+  ## An optional parent if the target has an sbt meta project.
+  parent: sbt.internal.bsp.BuildTargetIdentifier
+
+  ## The inverse of parent, list of targets that have this build target
+  ## defined as their parent. It can contain normal project targets or
+  ## sbt build targets if this target represents an sbt meta-meta build.
+  children: [sbt.internal.bsp.BuildTargetIdentifier]!
+}
+
+## Scalac options
+## The build target scalac options request is sent from the client to the server
+## to query for the list of compiler options necessary to compile in a given list of targets.
+type ScalacOptionsParams {
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+}
+
+type ScalacOptionsResult {
+  items: [sbt.internal.bsp.ScalacOptionsItem]
+}
+
+type ScalacOptionsItem {
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+
+  ## Additional arguments to the compiler.
+  ## For example, -deprecation.
+  options: [String]
+
+  ## The dependency classpath for this target, must be
+  ## identical to what is passed as arguments to
+  ## the -classpath flag in the command line interface
+  ## of scalac.
+  classpath: [java.net.URI]
+
+  ## The output directory for classfiles produced by this target
+  classDirectory: java.net.URI
+}
+
+## https://build-server-protocol.github.io/docs/server-discovery.html
+type BspConnectionDetails {
+  ## The name of the build tool
+  name: String!
+
+  ## The version of the build tool
+  version: String!
+
+  ## The bsp version of the build tool
+  bspVersion: String!
+
+  ## A collection of languages supported by this BSP server
+  languages: [String]
+
+  ## Command arguments runnable via system processes to start a BSP server
+  argv: [String]
+}
+
+## Metals metadata in the initialization request
+type MetalsMetadata {
+  ## The semanticdb plugin version that should be enabled for Metals code navigation
+  semanticdbVersion: String!
+
+  ## The list of scala versions that are supported by Metals
+  supportedScalaVersions: [String]
+}
+
+## Scala Test Params
+## ScalaTestParams contains scala-specific metadata for testing Scala targets.
+## This metadata is embedded in the data field of the buildTarget/test request
+## when the dataKind field contains "scala-test".
+type ScalaTestParams {
+  testClasses: [sbt.internal.bsp.ScalaTestClassesItem]
+}
+
+## Scala Test Class Request
+## The build target scala test options request is sent from the client to the server
+## to query for the list of fully qualified names of test clases in a given list of targets.
+type ScalaTestClassesParams {
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+
+  ## An optional number uniquely identifying a client request.
+  originId: String
+}
+
+type ScalaTestClassesResult {
+  items: [sbt.internal.bsp.ScalaTestClassesItem]
+
+  ## An optional id of the request that triggered this result.
+  originId: String
+}
+
+type ScalaTestClassesItem {
+  ## The build target that contains the test classes.
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+
+  ## The fully qualified names of the test classes in this target
+  classes: [String]
+}
+
+## Scala Main Class Request
+## The build target main classes request is sent from the client to the server
+## to query for the list of main classes that can be fed as arguments to buildTarget/run.
+type ScalaMainClassesParams {
+  targets: [sbt.internal.bsp.BuildTargetIdentifier]
+
+  ## An optional number uniquely identifying a client request.
+  originId: String
+}
+
+type ScalaMainClassesResult {
+  items: [sbt.internal.bsp.ScalaMainClassesItem]
+
+  ## An optional id of the request that triggered this result.
+  originId: String
+}
+
+type ScalaMainClassesItem {
+  ## The build target that contains the test classes.
+  target: sbt.internal.bsp.BuildTargetIdentifier!
+
+  ## The main class items
+  classes: [sbt.internal.bsp.ScalaMainClass]
+}
+
+type ScalaMainClass {
+  ## The main class to run.
+  class: String!
+
+  ## The user arguments to the main entrypoint.
+  arguments: [String]
+
+  ## The jvm options for the application.
+  jvmOptions: [String]
+
+  ## Additional environment variables for the application.
+  environmentVariables: [String]
+}
diff --git a/protocol/src/main/contraband/jsonrpc.contra b/protocol/src/main/contraband/jsonrpc.contra
new file mode 100644
index 000000000..983f6e747
--- /dev/null
+++ b/protocol/src/main/contraband/jsonrpc.contra
@@ -0,0 +1,79 @@
+package sbt.internal.protocol
+@target(Scala)
+
+## A general message as defined by JSON-RPC.
+interface JsonRpcMessage 
+@generateCodec(false)
+{
+  jsonrpc: String!
+}
+
+type JsonRpcRequestMessage implements JsonRpcMessage 
+@generateCodec(false)
+{
+  jsonrpc: String!
+
+  ## The request id.
+  id: String!
+
+  ## The method to be invoked.
+  method: String!
+
+  ## The method's params.
+  params: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+  #xtostring s"""JsonRpcRequestMessage($jsonrpc, $id, $method, ${sbt.protocol.Serialization.compactPrintJsonOpt(params)}})"""
+}
+
+type JsonRpcResponseMessage implements JsonRpcMessage
+@generateCodec(false)
+{
+  jsonrpc: String!
+
+  ## The request id.
+  id: String!
+
+  ## The result of a request. This can be omitted in
+  ## the case of an error.
+  result: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+  ## The error object in case a request fails.
+  error: sbt.internal.protocol.JsonRpcResponseError
+
+  #xtostring s"""JsonRpcResponseMessage($jsonrpc, $id, ${sbt.protocol.Serialization.compactPrintJsonOpt(result)}, $error)"""
+}
+
+type JsonRpcResponseError
+@generateCodec(false)
+{
+  ## A number indicating the error type that occurred.
+  code: Long!
+
+  ## A string providing a short description of the error.
+  message: String!
+
+  ## A Primitive or Structured value that contains additional
+  ## information about the error. Can be omitted.
+  data: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+  #xinterface RuntimeException(message)
+
+  #xtostring s"""JsonRpcResponseError($code, $message, ${sbt.protocol.Serialization.compactPrintJsonOpt(data)})"""
+
+  #xcompanion def apply(code: Long, message: String): JsonRpcResponseError = new JsonRpcResponseError(code, message, None)
+
+}
+
+type JsonRpcNotificationMessage implements JsonRpcMessage
+@generateCodec(false)
+{
+  jsonrpc: String!
+
+  ## The method to be invoked.
+  method: String!
+
+  ## The method's params.
+  params: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+  #xtostring s"""JsonRpcNotificationMessage($jsonrpc, $method, ${sbt.protocol.Serialization.compactPrintJsonOpt(params)})"""
+}
diff --git a/protocol/src/main/contraband/lsp.contra b/protocol/src/main/contraband/lsp.contra
new file mode 100644
index 000000000..343157d38
--- /dev/null
+++ b/protocol/src/main/contraband/lsp.contra
@@ -0,0 +1,160 @@
+package sbt.internal.langserver
+@target(Scala)
+@codecPackage("sbt.internal.langserver.codec")
+@fullCodec("JsonProtocol")
+
+# Basic structure
+
+## Position in a text document expressed as zero-based line and zero-based character offset.
+## A position is between two characters like an 'insert' cursor in a editor.
+type Position {
+  ## Line position in a document (zero-based).
+  line: Long!
+
+  ## Character offset on a line in a document (zero-based).
+  character: Long!
+}
+
+## A range in a text document expressed as (zero-based) start and end positions. A range is comparable to a selection in an editor.
+## Therefore the end position is exclusive.
+type Range {
+  ## The range's start position.
+  start: sbt.internal.langserver.Position!
+
+  ## The range's end position.
+  end: sbt.internal.langserver.Position!
+}
+
+## Represents a location inside a resource, such as a line inside a text file.
+type Location {
+  uri: String!
+  range: sbt.internal.langserver.Range!
+}
+
+## Represents a diagnostic, such as a compiler error or warning.
+## Diagnostic objects are only valid in the scope of a resource.
+type Diagnostic {
+  ## The range at which the message applies.
+  range: sbt.internal.langserver.Range!
+
+  ## The diagnostic's severity. Can be omitted. If omitted it is up to the
+  ## client to interpret diagnostics as error, warning, info or hint.
+  severity: Long
+
+  ## The diagnostic's code. Can be omitted.
+  code: String
+
+  ## A human-readable string describing the source of this
+  ## diagnostic, e.g. 'typescript' or 'super lint'.
+  source: String
+
+  ## The diagnostic's message.
+  message: String!
+}
+
+# initialize request
+# https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md#initialize-request
+
+type InitializeParams {
+  processId: Long
+
+  ## The rootPath of the workspace.
+  rootPath: String
+
+  rootUri: String
+
+  initializationOptions: sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+  capabilities: sbt.internal.langserver.ClientCapabilities
+
+  trace: String
+}
+
+type ClientCapabilities {
+}
+
+type InitializeResult {
+  ## The capabilities the language server provides.
+  capabilities: sbt.internal.langserver.ServerCapabilities!
+}
+
+type ServerCapabilities {
+  textDocumentSync: sbt.internal.langserver.TextDocumentSyncOptions
+
+  ## The server provides hover support.
+  hoverProvider: Boolean
+
+  ## Goto definition
+  definitionProvider: Boolean
+}
+
+type TextDocumentSyncOptions {
+  openClose: Boolean
+  change: Long
+  willSave: Boolean
+  willSaveWaitUntil: Boolean
+  save: sbt.internal.langserver.SaveOptions
+}
+
+type SaveOptions {
+  ## The client is supposed to include the content on save.
+  includeText: Boolean
+}
+
+# LogMessage Notification
+
+type LogMessageParams {
+  ## The message type.
+  type: Long!
+
+  ## The actual message
+  message: String!
+}
+
+# Document
+
+# PublishDiagnostics Notification https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md#textDocument_publishDiagnostics
+
+## Diagnostics notification are sent from the server to the client to signal results of validation runs.
+type PublishDiagnosticsParams {
+  ## The URI for which diagnostic information is reported.
+  uri: String!
+
+  ## An array of diagnostic information items.
+  diagnostics: [sbt.internal.langserver.Diagnostic]
+}
+
+# sbt extension
+
+## Command to execute sbt command.
+type SbtExecParams {
+  commandLine: String!
+}
+
+## Id for a cancel request
+type CancelRequestParams {
+  id: String!
+}
+
+## Goto definition params model
+interface TextDocumentPositionParamsInterface {
+	## The text document.
+	textDocument: sbt.internal.langserver.TextDocumentIdentifier!
+
+	## The position inside the text document.
+	position: sbt.internal.langserver.Position!
+}
+
+type TextDocumentPositionParams implements TextDocumentPositionParamsInterface {
+  ## The text document.
+  textDocument: sbt.internal.langserver.TextDocumentIdentifier!
+
+  ## The position inside the text document.
+  position: sbt.internal.langserver.Position!
+}
+
+## Text documents are identified using a URI. On the protocol level, URIs are passed as strings.
+type TextDocumentIdentifier {
+	## The text document's URI.
+	uri: String!
+}
diff --git a/protocol/src/main/contraband/portfile.contra b/protocol/src/main/contraband/portfile.contra
new file mode 100644
index 000000000..2e138c315
--- /dev/null
+++ b/protocol/src/main/contraband/portfile.contra
@@ -0,0 +1,22 @@
+package sbt.internal.protocol
+@target(Scala)
+@codecPackage("sbt.internal.protocol.codec")
+
+## This file should exist throughout the lifetime of the server.
+## It can be used to find out the transport protocol (port number etc).
+type PortFile {
+  ## URI of the sbt server.
+  uri: String!
+  tokenfilePath: String
+  tokenfileUri: String
+}
+
+type TokenFile {
+  uri: String!
+  token: String!
+}
+
+type InitializeOption {
+  token: String
+  skipAnalysis: Boolean @since("1.4.0")
+}
diff --git a/protocol/src/main/contraband/server.contra b/protocol/src/main/contraband/server.contra
new file mode 100644
index 000000000..18ec0a0d2
--- /dev/null
+++ b/protocol/src/main/contraband/server.contra
@@ -0,0 +1,151 @@
+package sbt.protocol
+@target(Scala)
+@codecPackage("sbt.protocol.codec")
+@fullCodec("JsonProtocol")
+
+## Message to invoke command.
+interface CommandMessage {
+}
+
+type InitCommand implements CommandMessage {
+  token: String
+  execId: String
+  skipAnalysis: Boolean @since("1.4.0")
+}
+
+## Command to execute sbt command.
+type ExecCommand implements CommandMessage {
+  commandLine: String!
+  execId: String @since("0.0.1")
+}
+
+type SettingQuery implements CommandMessage {
+  setting: String!
+}
+
+type Attach implements CommandMessage {
+  interactive: Boolean!
+}
+
+type CompletionParams {
+  query: String!
+  level: Int @since("1.4.0")
+}
+
+## Message for events.
+interface EventMessage {
+}
+
+type ChannelAcceptedEvent implements EventMessage {
+  channelName: String!
+}
+
+## Log event.
+type LogEvent implements EventMessage {
+  level: String!
+  message: String!
+}
+
+## Status event.
+type ExecStatusEvent implements EventMessage {
+  status: String!
+  channelName: String
+  execId: String
+  commandQueue: [String]
+  exitCode: Long @since("1.1.2")
+  message: String @since("1.4.0")
+}
+
+interface SettingQueryResponse implements EventMessage {}
+
+type SettingQuerySuccess implements SettingQueryResponse {
+  value: sjsonnew.shaded.scalajson.ast.unsafe.JValue!
+  contentType: String!
+}
+
+type SettingQueryFailure implements SettingQueryResponse {
+  message: String!
+}
+
+type CompletionResponse {
+  items: [String]
+  cachedMainClassNames: Boolean @since("1.4.0")
+  cachedTestNames: Boolean @since("1.4.0")
+}
+
+# enum Status {
+#  Ready
+#  Processing
+# }
+
+## Execution event.
+type ExecutionEvent {
+  success: String!
+  commandLine: String!
+}
+
+type TerminalPropertiesResponse implements EventMessage {
+  width: Int!
+  height: Int!
+  isAnsiSupported: Boolean!
+  isColorEnabled: Boolean!
+  isSupershellEnabled: Boolean!
+  isEchoEnabled: Boolean!
+}
+
+type TerminalCapabilitiesQuery implements CommandMessage {
+  boolean: String
+  numeric: String
+  string: String
+}
+
+type TerminalCapabilitiesResponse implements EventMessage {
+  boolean: Boolean
+  numeric: Int
+  string: String
+}
+
+type TerminalSetAttributesCommand implements CommandMessage {
+  iflag: String!,
+  oflag: String!,
+  cflag: String!,
+  lflag: String!,
+  cchars: String!,
+}
+
+type TerminalSetAttributesResponse implements EventMessage {}
+
+type TerminalAttributesQuery implements CommandMessage {}
+
+type TerminalAttributesResponse implements EventMessage {
+  iflag: String!,
+  oflag: String!,
+  cflag: String!,
+  lflag: String!,
+  cchars: String!,
+}
+
+type TerminalGetSizeQuery implements CommandMessage {}
+type TerminalGetSizeResponse implements EventMessage {
+  width: Int!
+  height: Int!
+}
+
+type TerminalSetSizeCommand implements CommandMessage {
+  width: Int!
+  height: Int!
+}
+
+type TerminalSetSizeResponse implements EventMessage {}
+
+type TerminalSetEchoCommand implements CommandMessage {
+  toggle: Boolean!
+}
+
+type TerminalSetEchoResponse implements EventMessage {}
+
+type TerminalSetRawModeCommand implements CommandMessage {
+  toggle: Boolean!
+}
+
+type TerminalSetRawModeResponse implements EventMessage {}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala
new file mode 100644
index 000000000..9b21dd31e
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala
@@ -0,0 +1,46 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.bsp
+
+import java.io.File
+
+import sbt.internal.bsp
+import sbt.io.IO
+import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Converter }
+
+object BuildServerConnection {
+  final val name = "sbt"
+  final val bspVersion = "2.0.0-M5"
+  final val languages = Vector("scala")
+
+  private final val SbtLaunchJar = "sbt-launch(-.*)?\\.jar".r
+
+  private[sbt] def writeConnectionFile(sbtVersion: String, baseDir: File): Unit = {
+    import bsp.codec.JsonProtocol._
+    val bspConnectionFile = new File(baseDir, ".bsp/sbt.json")
+    val javaHome = System.getProperty("java.home")
+    val classPath = System.getProperty("java.class.path")
+    val sbtLaunchJar = classPath
+      .split(File.pathSeparator)
+      .find(jar => SbtLaunchJar.findFirstIn(jar).nonEmpty)
+      .map(_.replaceAllLiterally(" ", "%20"))
+    val argv =
+      Vector(
+        s"$javaHome/bin/java",
+        "-Xms100m",
+        "-Xmx100m",
+        "-classpath",
+        classPath,
+        "xsbt.boot.Boot",
+        "-bsp"
+      ) ++ sbtLaunchJar.map(jar => s"--sbt-launch-jar=$jar")
+    val details = BspConnectionDetails(name, sbtVersion, bspVersion, languages, argv)
+    val json = Converter.toJson(details).get
+    IO.write(bspConnectionFile, CompactPrinter(json), append = false)
+  }
+}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildServerTasks.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildServerTasks.scala
new file mode 100644
index 000000000..9a8737bf7
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildServerTasks.scala
@@ -0,0 +1,15 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.bsp
+
+import java.util.concurrent.atomic.AtomicInteger
+
+object BuildServerTasks {
+  private val idGenerator = new AtomicInteger(0)
+  def uniqueId: String = idGenerator.getAndIncrement().toString
+}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildTargetName.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetName.scala
new file mode 100644
index 000000000..1c3307542
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetName.scala
@@ -0,0 +1,17 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.bsp
+
+object BuildTargetName {
+  def fromScope(project: String, config: String): String = {
+    config match {
+      case "compile" => project
+      case _         => s"$project-$config"
+    }
+  }
+}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildTargetTag.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetTag.scala
new file mode 100644
index 000000000..e522fb482
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/BuildTargetTag.scala
@@ -0,0 +1,24 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.bsp
+
+// https://build-server-protocol.github.io/docs/specification.html#build-target
+object BuildTargetTag {
+  val test: String = "test"
+  val application: String = "application"
+  val library: String = "library"
+  val integrationTest: String = "integration-test"
+  val benchmark: String = "benchmark"
+  val noIDE: String = "no-ide"
+
+  def fromConfig(config: String): Vector[String] = config match {
+    case "test"    => Vector(test)
+    case "compile" => Vector(library)
+    case _         => Vector.empty
+  }
+}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/DiagnosticSeverity.scala b/protocol/src/main/scala/sbt/internal/bsp/DiagnosticSeverity.scala
new file mode 100644
index 000000000..6f7797421
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/DiagnosticSeverity.scala
@@ -0,0 +1,31 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.bsp
+
+object DiagnosticSeverity {
+
+  /**
+   * Reports an error.
+   */
+  val Error = 1L
+
+  /**
+   * Reports a warning.
+   */
+  val Warning = 2L
+
+  /**
+   * Reports an information.
+   */
+  val Information = 3L
+
+  /**
+   * Reports a hint.
+   */
+  val Hint = 4L
+}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/ScalaPlatform.scala b/protocol/src/main/scala/sbt/internal/bsp/ScalaPlatform.scala
new file mode 100644
index 000000000..ea1efffb5
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/ScalaPlatform.scala
@@ -0,0 +1,16 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package bsp
+
+object ScalaPlatform {
+  val JVM = 1
+  val JS = 2
+  val Native = 3
+}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/SourceItemKind.scala b/protocol/src/main/scala/sbt/internal/bsp/SourceItemKind.scala
new file mode 100644
index 000000000..f9dd7e6b3
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/SourceItemKind.scala
@@ -0,0 +1,19 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package bsp
+
+object SourceItemKind {
+
+  /** The source item references a normal file.  */
+  val File: Int = 1
+
+  /** The source item references a directory. */
+  val Directory: Int = 2
+}
diff --git a/protocol/src/main/scala/sbt/internal/bsp/StatusCode.scala b/protocol/src/main/scala/sbt/internal/bsp/StatusCode.scala
new file mode 100644
index 000000000..a5b75971f
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/bsp/StatusCode.scala
@@ -0,0 +1,14 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.bsp
+
+object StatusCode {
+  final val Success: Int = 1
+  final val Error: Int = 2
+  final val Cancelled: Int = 3
+}
diff --git a/protocol/src/main/scala/sbt/internal/langserver/DiagnosticSeverity.scala b/protocol/src/main/scala/sbt/internal/langserver/DiagnosticSeverity.scala
new file mode 100644
index 000000000..e13bb3081
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/langserver/DiagnosticSeverity.scala
@@ -0,0 +1,33 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package langserver
+
+object DiagnosticSeverity {
+
+  /**
+   * Reports an error.
+   */
+  val Error = 1L
+
+  /**
+   * Reports a warning.
+   */
+  val Warning = 2L
+
+  /**
+   * Reports an information.
+   */
+  val Information = 3L
+
+  /**
+   * Reports a hint.
+   */
+  val Hint = 4L
+}
diff --git a/protocol/src/main/scala/sbt/internal/langserver/ErrorCodes.scala b/protocol/src/main/scala/sbt/internal/langserver/ErrorCodes.scala
new file mode 100644
index 000000000..74611035a
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/langserver/ErrorCodes.scala
@@ -0,0 +1,48 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package langserver
+
+/** Holds the error codes for the LSP implementation here. */
+object ErrorCodes {
+  // this is essentially a lookup table encoded in Scala,
+  // so heavy usage of vertical alignment is beneficial
+  // format: off
+
+  // Defined by the JSON-RPC 2.0 Specification
+  // https://www.jsonrpc.org/specification#error_object
+  //
+  // The error codes from and including -32768 to -32000 are reserved for pre-defined errors.
+  // Any code within this range, but not defined explicitly below is reserved for future use.
+  //
+  // The error codes are nearly the same as those suggested for XML-RPC at the following url:
+  // http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php
+  //
+  val ParseError     = -32700L       // Invalid JSON was received by the server.
+                                     // An error occurred on the server while parsing the JSON text.
+  val InvalidRequest = -32600L       // The JSON sent is not a valid Request object.
+  val MethodNotFound = -32601L       // The method does not exist / is not available.
+  val InvalidParams  = -32602L       // Invalid method parameter(s).
+  val InternalError  = -32603L       // Internal JSON-RPC error.
+
+
+  // The range -32000 to -32099 are reserved for implementation-defined server-errors.
+  val serverErrorStart = -32099L     // from LSP's spec code snippet
+  val serverErrorEnd   = -32000L     // from LSP's spec code snippet
+
+  val UnknownServerError   = -32001L // Defined by LSP
+  val ServerNotInitialized = -32002L // Defined by LSP
+
+
+  // The remainder of the space is available for application defined errors.
+  val RequestCancelled = -32800L     // Defined by LSP
+  val UnknownError     = -33000L     // A generic error, unknown if the user or server is at fault.
+
+  // format: on
+}
diff --git a/protocol/src/main/scala/sbt/internal/langserver/MessageType.scala b/protocol/src/main/scala/sbt/internal/langserver/MessageType.scala
new file mode 100644
index 000000000..2597fb1d1
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/langserver/MessageType.scala
@@ -0,0 +1,34 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package langserver
+
+object MessageType {
+
+  /** An error message. */
+  val Error = 1L
+
+  /** A warning message. */
+  val Warning = 2L
+
+  /** An information message. */
+  val Info = 3L
+
+  /** A log message. */
+  val Log = 4L
+
+  def fromLevelString(level: String): Long = {
+    level.toLowerCase match {
+      case "info"  => Info
+      case "warn"  => Warning
+      case "error" => Error
+      case _       => Log
+    }
+  }
+}
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRPCProtocol.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRPCProtocol.scala
new file mode 100644
index 000000000..06a8fe423
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRPCProtocol.scala
@@ -0,0 +1,17 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.protocol.codec
+trait JsonRPCProtocol
+    extends sbt.internal.util.codec.JValueFormats
+    with sjsonnew.BasicJsonProtocol
+    with sbt.internal.protocol.codec.JsonRpcRequestMessageFormats
+    with sbt.internal.protocol.codec.JsonRpcResponseErrorFormats
+    with sbt.internal.protocol.codec.JsonRpcResponseMessageFormats
+    with sbt.internal.protocol.codec.JsonRpcNotificationMessageFormats
+
+object JsonRPCProtocol extends JsonRPCProtocol
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcNotificationMessageFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcNotificationMessageFormats.scala
new file mode 100644
index 000000000..07a8b1f64
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcNotificationMessageFormats.scala
@@ -0,0 +1,47 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.protocol.codec
+
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+trait JsonRpcNotificationMessageFormats {
+  self: sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+  implicit lazy val JsonRpcNotificationMessageFormat
+      : JsonFormat[sbt.internal.protocol.JsonRpcNotificationMessage] =
+    new JsonFormat[sbt.internal.protocol.JsonRpcNotificationMessage] {
+      override def read[J](
+          jsOpt: Option[J],
+          unbuilder: Unbuilder[J]
+      ): sbt.internal.protocol.JsonRpcNotificationMessage = {
+        jsOpt match {
+          case Some(js) =>
+            unbuilder.beginObject(js)
+            val jsonrpc = unbuilder.readField[String]("jsonrpc")
+            val method = unbuilder.readField[String]("method")
+            val params = unbuilder.lookupField("params") map {
+              case x: JValue => x
+            }
+            unbuilder.endObject()
+            sbt.internal.protocol.JsonRpcNotificationMessage(jsonrpc, method, params)
+          case None =>
+            deserializationError("Expected JsObject but found None")
+        }
+      }
+      override def write[J](
+          obj: sbt.internal.protocol.JsonRpcNotificationMessage,
+          builder: Builder[J]
+      ): Unit = {
+        builder.beginObject()
+        builder.addField("jsonrpc", obj.jsonrpc)
+        builder.addField("method", obj.method)
+        builder.addField("params", obj.params)
+        builder.endObject()
+      }
+    }
+}
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala
new file mode 100644
index 000000000..829b8d2a4
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala
@@ -0,0 +1,56 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.protocol.codec
+
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+import sjsonnew.{ Builder, DeserializationException, JsonFormat, Unbuilder, deserializationError }
+
+trait JsonRpcRequestMessageFormats {
+  self: sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+  implicit lazy val JsonRpcRequestMessageFormat
+      : JsonFormat[sbt.internal.protocol.JsonRpcRequestMessage] =
+    new JsonFormat[sbt.internal.protocol.JsonRpcRequestMessage] {
+      override def read[J](
+          jsOpt: Option[J],
+          unbuilder: Unbuilder[J]
+      ): sbt.internal.protocol.JsonRpcRequestMessage = {
+        jsOpt match {
+          case Some(js) =>
+            unbuilder.beginObject(js)
+            val jsonrpc = unbuilder.readField[String]("jsonrpc")
+            val id = try {
+              unbuilder.readField[String]("id")
+            } catch {
+              case _: DeserializationException => {
+                val prefix = "\u2668" // Append prefix to show the original type was Number
+                prefix + unbuilder.readField[Long]("id").toString
+              }
+            }
+            val method = unbuilder.readField[String]("method")
+            val params = unbuilder.lookupField("params") map {
+              case x: JValue => x
+            }
+            unbuilder.endObject()
+            sbt.internal.protocol.JsonRpcRequestMessage(jsonrpc, id, method, params)
+          case None =>
+            deserializationError("Expected JsObject but found None")
+        }
+      }
+      override def write[J](
+          obj: sbt.internal.protocol.JsonRpcRequestMessage,
+          builder: Builder[J]
+      ): Unit = {
+        builder.beginObject()
+        builder.addField("jsonrpc", obj.jsonrpc)
+        builder.addField("id", obj.id)
+        builder.addField("method", obj.method)
+        builder.addField("params", obj.params)
+        builder.endObject()
+      }
+    }
+}
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseErrorFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseErrorFormats.scala
new file mode 100644
index 000000000..6d54a55ab
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseErrorFormats.scala
@@ -0,0 +1,47 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.protocol.codec
+
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+
+trait JsonRpcResponseErrorFormats {
+  self: sbt.internal.util.codec.JValueFormats with sjsonnew.BasicJsonProtocol =>
+  implicit lazy val JsonRpcResponseErrorFormat
+      : JsonFormat[sbt.internal.protocol.JsonRpcResponseError] =
+    new JsonFormat[sbt.internal.protocol.JsonRpcResponseError] {
+      override def read[J](
+          jsOpt: Option[J],
+          unbuilder: Unbuilder[J]
+      ): sbt.internal.protocol.JsonRpcResponseError = {
+        jsOpt match {
+          case Some(js) =>
+            unbuilder.beginObject(js)
+            val code = unbuilder.readField[Long]("code")
+            val message = unbuilder.readField[String]("message")
+            val data = unbuilder.lookupField("data") map {
+              case x: JValue => x
+            }
+            unbuilder.endObject()
+            sbt.internal.protocol.JsonRpcResponseError(code, message, data)
+          case None =>
+            deserializationError("Expected JsObject but found None")
+        }
+      }
+      override def write[J](
+          obj: sbt.internal.protocol.JsonRpcResponseError,
+          builder: Builder[J]
+      ): Unit = {
+        builder.beginObject()
+        builder.addField("code", obj.code)
+        builder.addField("message", obj.message)
+        builder.addField("data", obj.data)
+        builder.endObject()
+      }
+    }
+}
diff --git a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala
new file mode 100644
index 000000000..c93b31e22
--- /dev/null
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala
@@ -0,0 +1,89 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.protocol.codec
+
+import _root_.sjsonnew.{
+  Builder,
+  DeserializationException,
+  JsonFormat,
+  Unbuilder,
+  deserializationError
+}
+import sjsonnew.shaded.scalajson.ast.unsafe._
+
+trait JsonRpcResponseMessageFormats {
+  self: sbt.internal.util.codec.JValueFormats
+    with sbt.internal.protocol.codec.JsonRpcResponseErrorFormats
+    with sjsonnew.BasicJsonProtocol =>
+  implicit lazy val JsonRpcResponseMessageFormat
+      : JsonFormat[sbt.internal.protocol.JsonRpcResponseMessage] =
+    new JsonFormat[sbt.internal.protocol.JsonRpcResponseMessage] {
+      override def read[J](
+          jsOpt: Option[J],
+          unbuilder: Unbuilder[J]
+      ): sbt.internal.protocol.JsonRpcResponseMessage = {
+        jsOpt match {
+          case Some(js) =>
+            unbuilder.beginObject(js)
+            val jsonrpc = unbuilder.readField[String]("jsonrpc")
+            val id = try {
+              unbuilder.readField[String]("id")
+            } catch {
+              case _: DeserializationException =>
+                unbuilder.readField[Long]("id").toString
+            }
+
+            val result = unbuilder.lookupField("result") map {
+              case x: JValue => x
+            }
+
+            val error =
+              unbuilder.readField[Option[sbt.internal.protocol.JsonRpcResponseError]]("error")
+
+            unbuilder.endObject()
+            sbt.internal.protocol.JsonRpcResponseMessage(jsonrpc, id, result, error)
+          case None =>
+            deserializationError("Expected JsObject but found None")
+        }
+      }
+      override def write[J](
+          obj: sbt.internal.protocol.JsonRpcResponseMessage,
+          builder: Builder[J]
+      ): Unit = {
+        // Parse given id to Long or String judging by prefix
+        def parseId(str: String): Either[Long, String] = {
+          if (str.startsWith("\u2668")) Left(str.substring(1).toLong)
+          else Right(str)
+        }
+        def parseResult(jValue: JValue): JValue = jValue match {
+          case JObject(jFields) =>
+            val replaced = jFields map {
+              case field @ JField("execId", JString(str)) =>
+                parseId(str) match {
+                  case Right(strId) => field.copy(value = JString(strId))
+                  case Left(longId) => field.copy(value = JNumber(longId))
+                }
+              case other =>
+                other
+            }
+            JObject(replaced)
+          case other =>
+            other
+        }
+        builder.beginObject()
+        builder.addField("jsonrpc", obj.jsonrpc)
+        parseId(obj.id) match {
+          case Right(strId) => builder.addField("id", strId)
+          case Left(longId) => builder.addField("id", longId)
+        }
+        builder.addField("result", obj.result map parseResult)
+        builder.addField("error", obj.error)
+        builder.endObject()
+      }
+    }
+}
diff --git a/protocol/src/main/scala/sbt/protocol/ClientSocket.scala b/protocol/src/main/scala/sbt/protocol/ClientSocket.scala
new file mode 100644
index 000000000..165148f2a
--- /dev/null
+++ b/protocol/src/main/scala/sbt/protocol/ClientSocket.scala
@@ -0,0 +1,47 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package protocol
+
+import java.io.File
+import java.net.{ Socket, URI, InetAddress }
+import sjsonnew.BasicJsonProtocol
+import sjsonnew.support.scalajson.unsafe.{ Parser, Converter }
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+import sbt.internal.protocol.{ PortFile, TokenFile }
+import sbt.internal.protocol.codec.{ PortFileFormats, TokenFileFormats }
+import sbt.internal.util.Util.isWindows
+import org.scalasbt.ipcsocket._
+
+object ClientSocket {
+  private lazy val fileFormats = new BasicJsonProtocol with PortFileFormats with TokenFileFormats {}
+
+  def socket(portfile: File): (Socket, Option[String]) = socket(portfile, false)
+  def socket(portfile: File, useJNI: Boolean): (Socket, Option[String]) = {
+    import fileFormats._
+    val json: JValue = Parser.parseFromString(sbt.io.IO.read(portfile)).get
+    val p = Converter.fromJson[PortFile](json).get
+    val uri = new URI(p.uri)
+    // println(uri)
+    val token = p.tokenfilePath map { tp =>
+      val tokeFile = new File(tp)
+      val json: JValue = Parser.parseFromFile(tokeFile).get
+      val t = Converter.fromJson[TokenFile](json).get
+      t.token
+    }
+    val sk = uri.getScheme match {
+      case "local" => localSocket(uri.getSchemeSpecificPart, useJNI)
+      case "tcp"   => new Socket(InetAddress.getByName(uri.getHost), uri.getPort)
+      case _       => sys.error(s"Unsupported uri: $uri")
+    }
+    (sk, token)
+  }
+  def localSocket(name: String, useJNI: Boolean): Socket =
+    if (isWindows) new Win32NamedPipeSocket(s"\\\\.\\pipe\\$name", useJNI)
+    else new UnixDomainSocket(name, useJNI)
+}
diff --git a/protocol/src/main/scala/sbt/protocol/Serialization.scala b/protocol/src/main/scala/sbt/protocol/Serialization.scala
new file mode 100644
index 000000000..4b8537702
--- /dev/null
+++ b/protocol/src/main/scala/sbt/protocol/Serialization.scala
@@ -0,0 +1,245 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package protocol
+
+import sjsonnew.{ JsonFormat, JsonWriter }
+import sjsonnew.support.scalajson.unsafe.{ Parser, Converter, CompactPrinter }
+import sjsonnew.shaded.scalajson.ast.unsafe.{ JValue, JObject, JString }
+import java.nio.ByteBuffer
+import java.util.UUID
+import scala.util.{ Success, Failure }
+import sbt.internal.util.StringEvent
+import sbt.internal.protocol.{
+  JsonRpcMessage,
+  JsonRpcRequestMessage,
+  JsonRpcResponseMessage,
+  JsonRpcNotificationMessage
+}
+
+object Serialization {
+  private[sbt] val VsCode = "application/vscode-jsonrpc; charset=utf-8"
+  val readSystemIn = "sbt/readSystemIn"
+  val cancelReadSystemIn = "sbt/cancelReadSystemIn"
+  val systemIn = "sbt/systemIn"
+  val systemOut = "sbt/systemOut"
+  val systemErr = "sbt/systemErr"
+  val systemOutFlush = "sbt/systemOutFlush"
+  val systemErrFlush = "sbt/systemErrFlush"
+  val terminalPropertiesQuery = "sbt/terminalPropertiesQuery"
+  val terminalPropertiesResponse = "sbt/terminalPropertiesResponse"
+  val terminalCapabilities = "sbt/terminalCapabilities"
+  val terminalCapabilitiesResponse = "sbt/terminalCapabilitiesResponse"
+  val attach = "sbt/attach"
+  val attachResponse = "sbt/attachResponse"
+  val cancelRequest = "sbt/cancelRequest"
+  val promptChannel = "sbt/promptChannel"
+  val setTerminalAttributes = "sbt/setTerminalAttributes"
+  val getTerminalAttributes = "sbt/getTerminalAttributes"
+  val terminalGetSize = "sbt/terminalGetSize"
+  val terminalSetSize = "sbt/terminalSetSize"
+  val terminalSetEcho = "sbt/terminalSetEcho"
+  val terminalSetRawMode = "sbt/terminalSetRawMode"
+  val CancelAll = "__CancelAll"
+
+  @deprecated("unused", since = "1.4.0")
+  def serializeEvent[A: JsonFormat](event: A): Array[Byte] = {
+    val json: JValue = Converter.toJson[A](event).get
+    CompactPrinter(json).getBytes("UTF-8")
+  }
+
+  @deprecated("unused", since = "1.4.0")
+  def serializeCommand(command: CommandMessage): Array[Byte] = {
+    import codec.JsonProtocol._
+    val json: JValue = Converter.toJson[CommandMessage](command).get
+    CompactPrinter(json).getBytes("UTF-8")
+  }
+
+  private[sbt] def serializeCommandAsJsonMessage(command: CommandMessage): String = {
+    import sjsonnew.BasicJsonProtocol._
+
+    command match {
+      case x: InitCommand =>
+        val execId = x.execId.getOrElse(UUID.randomUUID.toString)
+        val analysis = s""""skipAnalysis" : ${x.skipAnalysis.getOrElse(false)}"""
+        val opt = x.token match {
+          case Some(t) =>
+            val json: JValue = Converter.toJson[String](t).get
+            val v = CompactPrinter(json)
+            s"""{ "token": $v, $analysis }"""
+          case None => s"{ $analysis }"
+        }
+        s"""{ "jsonrpc": "2.0", "id": "$execId", "method": "initialize", "params": { "initializationOptions": $opt } }"""
+      case x: ExecCommand =>
+        val execId = x.execId.getOrElse(UUID.randomUUID.toString)
+        val json: JValue = Converter.toJson[String](x.commandLine).get
+        val v = CompactPrinter(json)
+        s"""{ "jsonrpc": "2.0", "id": "$execId", "method": "sbt/exec", "params": { "commandLine": $v } }"""
+      case x: SettingQuery =>
+        val execId = UUID.randomUUID.toString
+        val json: JValue = Converter.toJson[String](x.setting).get
+        val v = CompactPrinter(json)
+        s"""{ "jsonrpc": "2.0", "id": "$execId", "method": "sbt/setting", "params": { "setting": $v } }"""
+
+      case x: Attach =>
+        val execId = UUID.randomUUID.toString
+        val json: JValue = Converter.toJson[Boolean](x.interactive).get
+        val v = CompactPrinter(json)
+        s"""{ "jsonrpc": "2.0", "id": "$execId", "method": "$attach", "params": { "interactive": $v } }"""
+
+    }
+  }
+
+  def serializeEventMessage(event: EventMessage): Array[Byte] = {
+    import codec.JsonProtocol._
+    val json: JValue = Converter.toJson[EventMessage](event).get
+    CompactPrinter(json).getBytes("UTF-8")
+  }
+
+  /** This formats the message according to JSON-RPC. https://www.jsonrpc.org/specification */
+  private[sbt] def serializeResponseMessage(message: JsonRpcResponseMessage): Array[Byte] = {
+    import sbt.internal.protocol.codec.JsonRPCProtocol._
+    serializeResponse(message)
+  }
+
+  /** This formats the message according to JSON-RPC. https://www.jsonrpc.org/specification */
+  private[sbt] def serializeRequestMessage(message: JsonRpcRequestMessage): Array[Byte] = {
+    import sbt.internal.protocol.codec.JsonRPCProtocol._
+    serializeResponse(message)
+  }
+
+  /** This formats the message according to JSON-RPC. https://www.jsonrpc.org/specification */
+  private[sbt] def serializeNotificationMessage(
+      message: JsonRpcNotificationMessage,
+  ): Array[Byte] = {
+    import sbt.internal.protocol.codec.JsonRPCProtocol._
+    serializeResponse(message)
+  }
+
+  private[sbt] def serializeResponse[A: JsonWriter](message: A): Array[Byte] = {
+    val json: JValue = Converter.toJson[A](message).get
+    val body = CompactPrinter(json)
+    val bodyLength = body.getBytes("UTF-8").length
+
+    Iterator(
+      s"Content-Length: $bodyLength",
+      s"Content-Type: $VsCode",
+      "",
+      body
+    ).mkString("\r\n").getBytes("UTF-8")
+  }
+
+  /**
+   * @return A command or an invalid input description
+   */
+  @deprecated("unused", since = "1.4.0")
+  def deserializeCommand(bytes: Seq[Byte]): Either[String, CommandMessage] = {
+    val buffer = ByteBuffer.wrap(bytes.toArray)
+    Parser.parseFromByteBuffer(buffer) match {
+      case Success(json) =>
+        import codec.JsonProtocol._
+        Converter.fromJson[CommandMessage](json) match {
+          case Success(command) => Right(command)
+          case Failure(e)       => Left(e.getMessage)
+        }
+      case Failure(e) =>
+        Left(s"Parse error: ${e.getMessage}")
+    }
+  }
+
+  /**
+   * @return A command or an invalid input description
+   */
+  @deprecated("unused", since = "1.4.0")
+  def deserializeEvent(bytes: Seq[Byte]): Either[String, Any] = {
+    val buffer = ByteBuffer.wrap(bytes.toArray)
+    Parser.parseFromByteBuffer(buffer) match {
+      case Success(json) =>
+        detectType(json) match {
+          case Some("StringEvent") =>
+            import sbt.internal.util.codec.JsonProtocol._
+            Converter.fromJson[StringEvent](json) match {
+              case Success(event) => Right(event)
+              case Failure(e)     => Left(e.getMessage)
+            }
+          case _ =>
+            import codec.JsonProtocol._
+            Converter.fromJson[EventMessage](json) match {
+              case Success(event) => Right(event)
+              case Failure(e)     => Left(e.getMessage)
+            }
+        }
+      case Failure(e) =>
+        Left(s"Parse error: ${e.getMessage}")
+    }
+  }
+
+  def detectType(json: JValue): Option[String] =
+    json match {
+      case JObject(fields) =>
+        (fields find { _.field == "type" } map { _.value }) match {
+          case Some(JString(value)) => Some(value)
+          case _                    => None
+        }
+      case _ => None
+    }
+
+  /**
+   * @return A command or an invalid input description
+   */
+  @deprecated("unused", since = "1.4.0")
+  def deserializeEventMessage(bytes: Seq[Byte]): Either[String, EventMessage] = {
+    val buffer = ByteBuffer.wrap(bytes.toArray)
+    Parser.parseFromByteBuffer(buffer) match {
+      case Success(json) =>
+        import codec.JsonProtocol._
+        Converter.fromJson[EventMessage](json) match {
+          case Success(event) => Right(event)
+          case Failure(e)     => Left(e.getMessage)
+        }
+      case Failure(e) =>
+        Left(s"Parse error: ${e.getMessage}")
+    }
+  }
+
+  private[sbt] def deserializeJsonMessage(bytes: Seq[Byte]): Either[String, JsonRpcMessage] = {
+    val buffer = ByteBuffer.wrap(bytes.toArray)
+    Parser.parseFromByteBuffer(buffer) match {
+      case Success(json @ JObject(fields)) =>
+        import sbt.internal.protocol.codec.JsonRPCProtocol._
+        if ((fields find { _.field == "method" }).isDefined) {
+          if ((fields find { _.field == "id" }).isDefined)
+            Converter.fromJson[JsonRpcRequestMessage](json) match {
+              case Success(request) => Right(request)
+              case Failure(e)       => Left(s"conversion error: ${e.getMessage}")
+            }
+          else
+            Converter.fromJson[JsonRpcNotificationMessage](json) match {
+              case Success(notification) => Right(notification)
+              case Failure(e)            => Left(s"conversion error: ${e.getMessage}")
+            }
+        } else if ((fields find { _.field == "id" }).isDefined)
+          Converter.fromJson[JsonRpcResponseMessage](json) match {
+            case Success(res) => Right(res)
+            case Failure(e)   => Left(s"conversion error: ${e.getMessage}")
+          }
+        else Left(s"expected JSON-RPC object but found ${new String(bytes.toArray, "UTF-8")}")
+      case Success(json) =>
+        Left(s"expected JSON object but found ${new String(bytes.toArray, "UTF-8")}")
+      case Failure(e) =>
+        Left(s"parse error: ${e.getMessage}")
+    }
+  }
+
+  private[sbt] def compactPrintJsonOpt(jsonOpt: Option[JValue]): String = {
+    jsonOpt match {
+      case Some(x) => CompactPrinter(x)
+      case _       => ""
+    }
+  }
+}
diff --git a/reset.sh b/reset.sh
index ec3465425..ce973dfb9 100755
--- a/reset.sh
+++ b/reset.sh
@@ -1,3 +1,3 @@
 #!/bin/bash
 
-rm -rf ~/.sbt/boot/scala-2.11.8/org.scala-sbt/sbt/1.0.0-SNAPSHOT/
+rm -rf ~/.sbt/boot/scala-2.12.3/org.scala-sbt/sbt/1.0.3-SNAPSHOT/
diff --git a/run/NOTICE b/run/NOTICE
index 27f7f6161..40d55bd9b 100644
--- a/run/NOTICE
+++ b/run/NOTICE
@@ -1,11 +1,12 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008 Mark Harrah
- *
- * Partially based on exit trapping in Nailgun by Pete Kirkham,
- * copyright 2004, Martian Software, Inc
- * licensed under Apache 2.0 License.
- */
+sbt: Run Component
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under BSD-3-Clause license (see LICENSE)
+
+Partially based on exit trapping in Nailgun by Pete Kirkham,
+copyright 2004, Martian Software, Inc
+licensed under Apache 2.0 License.
 
 Portions based on code by Pete Kirkham in Nailgun
 Copyright 2004, Martian Software, Inc
-Licensed under the Apache License, Version 2.0 (see licenses/LICENSE_Apache)
\ No newline at end of file
+Licensed under the Apache License, Version 2.0 (see licenses/LICENSE_Apache)
diff --git a/run/src/main/contraband-scala/sbt/ForkOptions.scala b/run/src/main/contraband-scala/sbt/ForkOptions.scala
new file mode 100644
index 000000000..6f083bc93
--- /dev/null
+++ b/run/src/main/contraband-scala/sbt/ForkOptions.scala
@@ -0,0 +1,81 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt
+/**
+ * Configures forking.
+ * @param javaHome The Java installation to use.  If not defined, the Java home for the current process is used.
+ * @param outputStrategy Configures the forked standard output and error streams.
+                         If not defined, StdoutOutput is used, which maps the forked output to the output of
+                         this process and the forked error to the error stream of the forking process.
+ * @param bootJars The Vector of jars to put on the forked boot classpath.  By default, this is empty.
+ * @param workingDirectory The directory to use as the working directory for the forked process.
+                           By default, this is the working directory of the forking process.
+ * @param runJVMOptions The options to prepend to all user-specified arguments.  By default, this is empty.
+ * @param connectInput If true, the standard input of the forked process is connected to the standard input of this process.  Otherwise, it is connected to an empty input stream.
+                       Connecting input streams can be problematic, especially on versions before Java 7.
+ * @param envVars The environment variables to provide to the forked process.  By default, none are provided.
+ */
+final class ForkOptions private (
+  val javaHome: Option[java.io.File],
+  val outputStrategy: Option[sbt.OutputStrategy],
+  val bootJars: Vector[java.io.File],
+  val workingDirectory: Option[java.io.File],
+  val runJVMOptions: Vector[String],
+  val connectInput: Boolean,
+  val envVars: scala.collection.immutable.Map[String, String]) extends Serializable {
+  
+  private def this() = this(None, None, Vector(), None, Vector(), false, Map())
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: ForkOptions => (this.javaHome == x.javaHome) && (this.outputStrategy == x.outputStrategy) && (this.bootJars == x.bootJars) && (this.workingDirectory == x.workingDirectory) && (this.runJVMOptions == x.runJVMOptions) && (this.connectInput == x.connectInput) && (this.envVars == x.envVars)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.ForkOptions".##) + javaHome.##) + outputStrategy.##) + bootJars.##) + workingDirectory.##) + runJVMOptions.##) + connectInput.##) + envVars.##)
+  }
+  override def toString: String = {
+    "ForkOptions(" + javaHome + ", " + outputStrategy + ", " + bootJars + ", " + workingDirectory + ", " + runJVMOptions + ", " + connectInput + ", " + envVars + ")"
+  }
+  private[this] def copy(javaHome: Option[java.io.File] = javaHome, outputStrategy: Option[sbt.OutputStrategy] = outputStrategy, bootJars: Vector[java.io.File] = bootJars, workingDirectory: Option[java.io.File] = workingDirectory, runJVMOptions: Vector[String] = runJVMOptions, connectInput: Boolean = connectInput, envVars: scala.collection.immutable.Map[String, String] = envVars): ForkOptions = {
+    new ForkOptions(javaHome, outputStrategy, bootJars, workingDirectory, runJVMOptions, connectInput, envVars)
+  }
+  def withJavaHome(javaHome: Option[java.io.File]): ForkOptions = {
+    copy(javaHome = javaHome)
+  }
+  def withJavaHome(javaHome: java.io.File): ForkOptions = {
+    copy(javaHome = Option(javaHome))
+  }
+  def withOutputStrategy(outputStrategy: Option[sbt.OutputStrategy]): ForkOptions = {
+    copy(outputStrategy = outputStrategy)
+  }
+  def withOutputStrategy(outputStrategy: sbt.OutputStrategy): ForkOptions = {
+    copy(outputStrategy = Option(outputStrategy))
+  }
+  def withBootJars(bootJars: Vector[java.io.File]): ForkOptions = {
+    copy(bootJars = bootJars)
+  }
+  def withWorkingDirectory(workingDirectory: Option[java.io.File]): ForkOptions = {
+    copy(workingDirectory = workingDirectory)
+  }
+  def withWorkingDirectory(workingDirectory: java.io.File): ForkOptions = {
+    copy(workingDirectory = Option(workingDirectory))
+  }
+  def withRunJVMOptions(runJVMOptions: Vector[String]): ForkOptions = {
+    copy(runJVMOptions = runJVMOptions)
+  }
+  def withConnectInput(connectInput: Boolean): ForkOptions = {
+    copy(connectInput = connectInput)
+  }
+  def withEnvVars(envVars: scala.collection.immutable.Map[String, String]): ForkOptions = {
+    copy(envVars = envVars)
+  }
+}
+object ForkOptions {
+  
+  def apply(): ForkOptions = new ForkOptions()
+  def apply(javaHome: Option[java.io.File], outputStrategy: Option[sbt.OutputStrategy], bootJars: Vector[java.io.File], workingDirectory: Option[java.io.File], runJVMOptions: Vector[String], connectInput: Boolean, envVars: scala.collection.immutable.Map[String, String]): ForkOptions = new ForkOptions(javaHome, outputStrategy, bootJars, workingDirectory, runJVMOptions, connectInput, envVars)
+  def apply(javaHome: java.io.File, outputStrategy: sbt.OutputStrategy, bootJars: Vector[java.io.File], workingDirectory: java.io.File, runJVMOptions: Vector[String], connectInput: Boolean, envVars: scala.collection.immutable.Map[String, String]): ForkOptions = new ForkOptions(Option(javaHome), Option(outputStrategy), bootJars, Option(workingDirectory), runJVMOptions, connectInput, envVars)
+}
diff --git a/run/src/main/contraband/run.contra b/run/src/main/contraband/run.contra
new file mode 100644
index 000000000..0cb61c7c3
--- /dev/null
+++ b/run/src/main/contraband/run.contra
@@ -0,0 +1,30 @@
+package sbt
+@target(Scala)
+
+## Configures forking.
+type ForkOptions {
+  ## The Java installation to use.  If not defined, the Java home for the current process is used.
+  javaHome: java.io.File @since("0.1.0")
+
+  ## Configures the forked standard output and error streams.
+  ## If not defined, StdoutOutput is used, which maps the forked output to the output of
+  ## this process and the forked error to the error stream of the forking process.
+  outputStrategy: sbt.OutputStrategy @since("0.1.0")
+
+  ## The Vector of jars to put on the forked boot classpath.  By default, this is empty.
+  bootJars: [java.io.File] @since("0.1.0")
+
+  ## The directory to use as the working directory for the forked process.
+  ## By default, this is the working directory of the forking process.
+  workingDirectory: java.io.File @since("0.1.0")
+
+  ## The options to prepend to all user-specified arguments.  By default, this is empty.
+  runJVMOptions: [String] @since("0.1.0")
+
+  ## If true, the standard input of the forked process is connected to the standard input of this process.  Otherwise, it is connected to an empty input stream.
+  ## Connecting input streams can be problematic, especially on versions before Java 7.
+  connectInput: Boolean! = false @since("0.1.0")
+
+  ## The environment variables to provide to the forked process.  By default, none are provided.
+  envVars: StringStringMap! = raw"Map()" @since("0.1.0")
+}
diff --git a/run/src/main/scala/sbt/Fork.scala b/run/src/main/scala/sbt/Fork.scala
index 917872424..9745c28a6 100644
--- a/run/src/main/scala/sbt/Fork.scala
+++ b/run/src/main/scala/sbt/Fork.scala
@@ -1,60 +1,30 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009  Mark Harrah, Vesa Vilhonen
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
-import java.io.{ File, OutputStream }
-import java.util.Locale
+import java.io.File
+import java.lang.ProcessBuilder.Redirect
 
-import sbt.util.Logger
 import scala.sys.process.Process
-
-/**
- * Configures forking.
- *
- * @param javaHome The Java installation to use.  If not defined, the Java home for the current process is used.
- * @param outputStrategy Configures the forked standard output and error streams.  If not defined, StdoutOutput is used, which maps the forked output to the output of this process and the forked error to the error stream of the forking process.
- * @param bootJars The list of jars to put on the forked boot classpath.  By default, this is empty.
- * @param workingDirectory The directory to use as the working directory for the forked process.  By default, this is the working directory of the forking process.
- * @param runJVMOptions The options to prepend to all user-specified arguments.  By default, this is empty.
- * @param connectInput If true, the standard input of the forked process is connected to the standard input of this process.  Otherwise, it is connected to an empty input stream.  Connecting input streams can be problematic, especially on versions before Java 7.
- * @param envVars The environment variables to provide to the forked process.  By default, none are provided.
- */
-final case class ForkOptions(javaHome: Option[File] = None, outputStrategy: Option[OutputStrategy] = None, bootJars: Seq[File] = Nil, workingDirectory: Option[File] = None, runJVMOptions: Seq[String] = Nil, connectInput: Boolean = false, envVars: Map[String, String] = Map.empty)
-
-/** Configures where the standard output and error streams from a forked process go.*/
-sealed abstract class OutputStrategy
-
-/**
- * Configures the forked standard output to go to standard output of this process and
- * for the forked standard error to go to the standard error of this process.
- */
-case object StdoutOutput extends OutputStrategy
-
-/**
- * Logs the forked standard output at the `info` level and the forked standard error at the `error` level.
- * The output is buffered until the process completes, at which point the logger flushes it (to the screen, for example).
- */
-case class BufferedOutput(logger: Logger) extends OutputStrategy
-
-/** Logs the forked standard output at the `info` level and the forked standard error at the `error` level. */
-case class LoggedOutput(logger: Logger) extends OutputStrategy
-
-/**
- * Configures the forked standard output to be sent to `output` and the forked standard error
- * to be sent to the standard error of this process.
- */
-case class CustomOutput(output: OutputStream) extends OutputStrategy
+import OutputStrategy._
+import sbt.internal.util.Util
+import Util.{ AnyOps, none }
 
 import java.lang.{ ProcessBuilder => JProcessBuilder }
 
 /**
- * Represents a commad that can be forked.
+ * Represents a command that can be forked.
  *
  * @param commandName The java-like binary to fork.  This is expected to exist in bin/ of the Java home directory.
  * @param runnerClass If Some, this will be prepended to the `arguments` passed to the `apply` or `fork` methods.
  */
 final class Fork(val commandName: String, val runnerClass: Option[String]) {
+
   /**
    * Forks the configured process, waits for it to complete, and returns the exit code.
    * The command executed is the `commandName` defined for this Fork instance.
@@ -69,33 +39,45 @@ final class Fork(val commandName: String, val runnerClass: Option[String]) {
    * It is configured according to `config`.
    * If `runnerClass` is defined for this Fork instance, it is prepended to `arguments` to define the arguments passed to the forked command.
    */
-  def fork(config: ForkOptions, arguments: Seq[String]): Process =
-    {
-      import config.{ envVars => env, _ }
-      val executable = Fork.javaCommand(javaHome, commandName).getAbsolutePath
-      val preOptions = makeOptions(runJVMOptions, bootJars, arguments)
-      val (classpathEnv, options) = Fork.fitClasspath(preOptions)
-      val command = (executable +: options).toArray
-      val builder = new JProcessBuilder(command: _*)
-      workingDirectory.foreach(wd => builder.directory(wd))
-      val environment = builder.environment
-      for ((key, value) <- env)
-        environment.put(key, value)
-      for (cpenv <- classpathEnv)
-        // overriding, not appending, is correct due to the specified priorities of -classpath and CLASSPATH
-        environment.put(Fork.ClasspathEnvKey, cpenv)
-      outputStrategy.getOrElse(StdoutOutput) match {
-        case StdoutOutput           => Process(builder).run(connectInput)
-        case BufferedOutput(logger) => logger.buffer { Process(builder).run(logger, connectInput) }
-        case LoggedOutput(logger)   => Process(builder).run(logger, connectInput)
-        case CustomOutput(output)   => (Process(builder) #> output).run(connectInput)
-      }
+  def fork(config: ForkOptions, arguments: Seq[String]): Process = {
+    import config.{ envVars => env, _ }
+    val executable = Fork.javaCommand(javaHome, commandName).getAbsolutePath
+    val preOptions = makeOptions(runJVMOptions, bootJars, arguments)
+    val (classpathEnv, options) = Fork.fitClasspath(preOptions)
+    val command = executable +: options
+
+    val environment: List[(String, String)] = env.toList ++
+      (classpathEnv map { value =>
+        Fork.ClasspathEnvKey -> value
+      })
+    val jpb = new JProcessBuilder(command.toArray: _*)
+    workingDirectory foreach (jpb directory _)
+    environment foreach { case (k, v) => jpb.environment.put(k, v) }
+    if (connectInput) {
+      jpb.redirectInput(Redirect.INHERIT)
+      ()
     }
-  private[this] def makeOptions(jvmOptions: Seq[String], bootJars: Iterable[File], arguments: Seq[String]): Seq[String] =
-    {
-      val boot = if (bootJars.isEmpty) None else Some("-Xbootclasspath/a:" + bootJars.map(_.getAbsolutePath).mkString(File.pathSeparator))
-      jvmOptions ++ boot.toList ++ runnerClass.toList ++ arguments
+    val process = Process(jpb)
+
+    outputStrategy.getOrElse(StdoutOutput: OutputStrategy) match {
+      case StdoutOutput => process.run(connectInput = false)
+      case out: BufferedOutput =>
+        out.logger.buffer { process.run(out.logger, connectInput = false) }
+      case out: LoggedOutput => process.run(out.logger, connectInput = false)
+      case out: CustomOutput => (process #> out.output).run(connectInput = false)
     }
+  }
+  private[this] def makeOptions(
+      jvmOptions: Seq[String],
+      bootJars: Iterable[File],
+      arguments: Seq[String]
+  ): Seq[String] = {
+    val boot =
+      if (bootJars.isEmpty) none[String]
+      else
+        ("-Xbootclasspath/a:" + bootJars.map(_.getAbsolutePath).mkString(File.pathSeparator)).some
+    jvmOptions ++ boot.toList ++ runnerClass.toList ++ arguments
+  }
 }
 object Fork {
   private val ScalacMainClass = "scala.tools.nsc.Main"
@@ -110,31 +92,30 @@ object Fork {
   private val ClasspathEnvKey = "CLASSPATH"
   private[this] val ClasspathOptionLong = "-classpath"
   private[this] val ClasspathOptionShort = "-cp"
-  private[this] def isClasspathOption(s: String) = s == ClasspathOptionLong || s == ClasspathOptionShort
+  private[this] def isClasspathOption(s: String) =
+    s == ClasspathOptionLong || s == ClasspathOptionShort
+
   /** Maximum length of classpath string before passing the classpath in an environment variable instead of an option. */
   private[this] val MaxConcatenatedOptionLength = 5000
 
   private def fitClasspath(options: Seq[String]): (Option[String], Seq[String]) =
-    if (isWindows && optionsTooLong(options))
+    if (Util.isWindows && optionsTooLong(options))
       convertClasspathToEnv(options)
     else
       (None, options)
   private[this] def optionsTooLong(options: Seq[String]): Boolean =
     options.mkString(" ").length > MaxConcatenatedOptionLength
 
-  private[this] val isWindows: Boolean = System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("windows")
-  private[this] def convertClasspathToEnv(options: Seq[String]): (Option[String], Seq[String]) =
-    {
-      val (preCP, cpAndPost) = options.span(opt => !isClasspathOption(opt))
-      val postCP = cpAndPost.drop(2)
-      val classpathOption = cpAndPost.drop(1).headOption
-      val newOptions = if (classpathOption.isDefined) preCP ++ postCP else options
-      (classpathOption, newOptions)
-    }
+  private[this] def convertClasspathToEnv(options: Seq[String]): (Option[String], Seq[String]) = {
+    val (preCP, cpAndPost) = options.span(opt => !isClasspathOption(opt))
+    val postCP = cpAndPost.drop(2)
+    val classpathOption = cpAndPost.drop(1).headOption
+    val newOptions = if (classpathOption.isDefined) preCP ++ postCP else options
+    (classpathOption, newOptions)
+  }
 
-  private def javaCommand(javaHome: Option[File], name: String): File =
-    {
-      val home = javaHome.getOrElse(new File(System.getProperty("java.home")))
-      new File(new File(home, "bin"), name)
-    }
+  private def javaCommand(javaHome: Option[File], name: String): File = {
+    val home = javaHome.getOrElse(new File(System.getProperty("java.home")))
+    new File(new File(home, "bin"), name)
+  }
 }
diff --git a/run/src/main/scala/sbt/OutputStrategy.scala b/run/src/main/scala/sbt/OutputStrategy.scala
new file mode 100644
index 000000000..35b114b88
--- /dev/null
+++ b/run/src/main/scala/sbt/OutputStrategy.scala
@@ -0,0 +1,104 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import sbt.util.Logger
+import java.io.OutputStream
+
+/** Configures where the standard output and error streams from a forked process go.*/
+sealed abstract class OutputStrategy
+
+object OutputStrategy {
+
+  /**
+   * Configures the forked standard output to go to standard output of this process and
+   * for the forked standard error to go to the standard error of this process.
+   */
+  case object StdoutOutput extends OutputStrategy
+
+  /**
+   * Logs the forked standard output at the `info` level and the forked standard error at
+   * the `error` level. The output is buffered until the process completes, at which point
+   * the logger flushes it (to the screen, for example).
+   */
+  final class BufferedOutput private (val logger: Logger) extends OutputStrategy with Serializable {
+    override def equals(o: Any): Boolean = o match {
+      case x: BufferedOutput => (this.logger == x.logger)
+      case _                 => false
+    }
+    override def hashCode: Int = {
+      37 * (17 + logger.##) + "BufferedOutput".##
+    }
+    override def toString: String = {
+      "BufferedOutput(" + logger + ")"
+    }
+    private[this] def copy(logger: Logger = logger): BufferedOutput = {
+      new BufferedOutput(logger)
+    }
+    def withLogger(logger: Logger): BufferedOutput = {
+      copy(logger = logger)
+    }
+  }
+  object BufferedOutput {
+    def apply(logger: Logger): BufferedOutput = new BufferedOutput(logger)
+  }
+
+  /**
+   * Logs the forked standard output at the `info` level and the forked standard error at
+   * the `error` level.
+   */
+  final class LoggedOutput private (val logger: Logger) extends OutputStrategy with Serializable {
+    override def equals(o: Any): Boolean = o match {
+      case x: LoggedOutput => (this.logger == x.logger)
+      case _               => false
+    }
+    override def hashCode: Int = {
+      37 * (17 + logger.##) + "LoggedOutput".##
+    }
+    override def toString: String = {
+      "LoggedOutput(" + logger + ")"
+    }
+    private[this] def copy(logger: Logger = logger): LoggedOutput = {
+      new LoggedOutput(logger)
+    }
+    def withLogger(logger: Logger): LoggedOutput = {
+      copy(logger = logger)
+    }
+  }
+  object LoggedOutput {
+    def apply(logger: Logger): LoggedOutput = new LoggedOutput(logger)
+  }
+
+  /**
+   * Configures the forked standard output to be sent to `output` and the forked standard error
+   * to be sent to the standard error of this process.
+   */
+  final class CustomOutput private (val output: OutputStream)
+      extends OutputStrategy
+      with Serializable {
+    override def equals(o: Any): Boolean = o match {
+      case x: CustomOutput => (this.output == x.output)
+      case _               => false
+    }
+    override def hashCode: Int = {
+      37 * (17 + output.##) + "CustomOutput".##
+    }
+    override def toString: String = {
+      "CustomOutput(" + output + ")"
+    }
+    private[this] def copy(output: OutputStream = output): CustomOutput = {
+      new CustomOutput(output)
+    }
+    def withOutput(output: OutputStream): CustomOutput = {
+      copy(output = output)
+    }
+  }
+  object CustomOutput {
+    def apply(output: OutputStream): CustomOutput = new CustomOutput(output)
+  }
+}
diff --git a/run/src/main/scala/sbt/Run.scala b/run/src/main/scala/sbt/Run.scala
index ebca78787..5d5e9307f 100644
--- a/run/src/main/scala/sbt/Run.scala
+++ b/run/src/main/scala/sbt/Run.scala
@@ -1,100 +1,187 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009  Mark Harrah, Vesa Vilhonen
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
-import java.lang.reflect.{ Method, Modifier }
-import Modifier.{ isPublic, isStatic }
-import sbt.internal.inc.classpath.ClasspathUtilities
+import java.lang.reflect.Method
+import java.lang.reflect.Modifier.{ isPublic, isStatic }
+
 import sbt.internal.inc.ScalaInstance
-
+import sbt.internal.inc.classpath.{ ClasspathFilter, ClasspathUtil }
+import sbt.internal.util.MessageOnlyException
 import sbt.io.Path
-
 import sbt.util.Logger
 
-trait ScalaRun {
-  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Option[String]
+import scala.sys.process.Process
+import scala.util.control.NonFatal
+import scala.util.{ Failure, Success, Try }
+
+sealed trait ScalaRun {
+  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Try[Unit]
 }
 class ForkRun(config: ForkOptions) extends ScalaRun {
-  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Option[String] =
-    {
-      log.info("Running " + mainClass + " " + options.mkString(" "))
-
-      val scalaOptions = classpathOption(classpath) ::: mainClass :: options.toList
-      val configLogged = if (config.outputStrategy.isDefined) config else config.copy(outputStrategy = Some(LoggedOutput(log)))
-      // fork with Java because Scala introduces an extra class loader (#702)
-      val process = Fork.java.fork(configLogged, scalaOptions)
-      def cancel() = {
-        log.warn("Run canceled.")
-        process.destroy()
-        1
-      }
-      val exitCode = try process.exitValue() catch { case e: InterruptedException => cancel() }
-      processExitCode(exitCode, "runner")
-    }
-  private def classpathOption(classpath: Seq[File]) = "-classpath" :: Path.makeString(classpath) :: Nil
-  private def processExitCode(exitCode: Int, label: String) =
-    {
-      if (exitCode == 0)
-        None
+  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Try[Unit] = {
+    def processExitCode(exitCode: Int, label: String): Try[Unit] =
+      if (exitCode == 0) Success(())
       else
-        Some("Nonzero exit code returned from " + label + ": " + exitCode)
+        Failure(
+          new MessageOnlyException(
+            s"""Nonzero exit code returned from $label: $exitCode""".stripMargin
+          )
+        )
+    val process = fork(mainClass, classpath, options, log)
+    def cancel() = {
+      log.warn("Run canceled.")
+      process.destroy()
+      1
     }
-}
-class Run(instance: ScalaInstance, trapExit: Boolean, nativeTmp: File) extends ScalaRun {
-  /** Runs the class 'mainClass' using the given classpath and options using the scala runner.*/
-  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger) =
-    {
-      log.info("Running " + mainClass + " " + options.mkString(" "))
-
-      def execute() =
-        try { run0(mainClass, classpath, options, log) }
-        catch { case e: java.lang.reflect.InvocationTargetException => throw e.getCause }
-      def directExecute() = try { execute(); None } catch { case e: Exception => log.trace(e); Some(e.toString) }
-
-      if (trapExit) Run.executeTrapExit(execute(), log) else directExecute()
-    }
-  private def run0(mainClassName: String, classpath: Seq[File], options: Seq[String], log: Logger): Unit = {
-    log.debug("  Classpath:\n\t" + classpath.mkString("\n\t"))
-    val loader = ClasspathUtilities.makeLoader(classpath, instance, nativeTmp)
-    val main = getMainMethod(mainClassName, loader)
-    invokeMain(loader, main, options)
+    val exitCode = try process.exitValue()
+    catch { case _: InterruptedException => cancel() }
+    processExitCode(exitCode, "runner")
   }
-  private def invokeMain(loader: ClassLoader, main: Method, options: Seq[String]): Unit = {
+
+  def fork(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Process = {
+    log.info(s"running (fork) $mainClass ${Run.runOptionsStr(options)}")
+
+    val scalaOptions = classpathOption(classpath) ::: mainClass :: options.toList
+    val configLogged =
+      if (config.outputStrategy.isDefined) config
+      else config.withOutputStrategy(OutputStrategy.LoggedOutput(log))
+    // fork with Java because Scala introduces an extra class loader (#702)
+    Fork.java.fork(configLogged, scalaOptions)
+  }
+  private def classpathOption(classpath: Seq[File]) =
+    "-classpath" :: Path.makeString(classpath) :: Nil
+}
+class Run(private[sbt] val newLoader: Seq[File] => ClassLoader, trapExit: Boolean)
+    extends ScalaRun {
+  def this(instance: ScalaInstance, trapExit: Boolean, nativeTmp: File) =
+    this(
+      (cp: Seq[File]) => ClasspathUtil.makeLoader(cp.map(_.toPath), instance, nativeTmp.toPath),
+      trapExit
+    )
+
+  private[sbt] def runWithLoader(
+      loader: ClassLoader,
+      classpath: Seq[File],
+      mainClass: String,
+      options: Seq[String],
+      log: Logger
+  ): Try[Unit] = {
+    log.info(s"running $mainClass ${Run.runOptionsStr(options)}")
+
+    def execute(): Unit =
+      try {
+        log.debug("  Classpath:\n\t" + classpath.mkString("\n\t"))
+        val main = getMainMethod(mainClass, loader)
+        invokeMain(loader, main, options)
+      } catch {
+        case e: java.lang.reflect.InvocationTargetException =>
+          e.getCause match {
+            case ex: ClassNotFoundException =>
+              val className = ex.getMessage
+              try {
+                loader.loadClass(className)
+                val msg =
+                  s"$className is on the project classpath but not visible to the ClassLoader " +
+                    "that attempted to load it.\n" +
+                    "See https://www.scala-sbt.org/1.x/docs/In-Process-Classloaders.html for " +
+                    "further information."
+                log.error(msg)
+              } catch { case NonFatal(_) => }
+              throw ex
+            case ex => throw ex
+          }
+      }
+    def directExecute(): Try[Unit] =
+      Try(execute()) recover {
+        case NonFatal(e) =>
+          // bgStop should not print out stack trace
+          // log.trace(e)
+          throw e
+      }
+    // try { execute(); None } catch { case e: Exception => log.trace(e); Some(e.toString) }
+
+    if (trapExit) Run.executeTrapExit(execute(), log)
+    else directExecute()
+  }
+
+  /** Runs the class 'mainClass' using the given classpath and options using the scala runner.*/
+  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Try[Unit] = {
+    val loader = newLoader(classpath)
+    try runWithLoader(loader, classpath, mainClass, options, log)
+    finally loader match {
+      case ac: AutoCloseable  => ac.close()
+      case c: ClasspathFilter => c.close()
+      case _                  =>
+    }
+  }
+  private def invokeMain(
+      loader: ClassLoader,
+      main: Method,
+      options: Seq[String]
+  ): Unit = {
     val currentThread = Thread.currentThread
     val oldLoader = Thread.currentThread.getContextClassLoader
     currentThread.setContextClassLoader(loader)
-    try { main.invoke(null, options.toArray[String]) }
-    finally { currentThread.setContextClassLoader(oldLoader) }
-  }
-  def getMainMethod(mainClassName: String, loader: ClassLoader) =
-    {
-      val mainClass = Class.forName(mainClassName, true, loader)
-      val method = mainClass.getMethod("main", classOf[Array[String]])
-      // jvm allows the actual main class to be non-public and to run a method in the non-public class,
-      //  we need to make it accessible
-      method.setAccessible(true)
-      val modifiers = method.getModifiers
-      if (!isPublic(modifiers)) throw new NoSuchMethodException(mainClassName + ".main is not public")
-      if (!isStatic(modifiers)) throw new NoSuchMethodException(mainClassName + ".main is not static")
-      method
+    try {
+      main.invoke(null, options.toArray[String]); ()
+    } catch {
+      case t: Throwable =>
+        t.getCause match {
+          case e: java.lang.IllegalAccessError =>
+            val msg = s"Error running $main.\n$e\n" +
+              "If using a layered classloader, this can occur if jvm package private classes are " +
+              "accessed across layers. This can be fixed by changing to the Flat or " +
+              "ScalaInstance class loader layering strategies."
+            throw new IllegalAccessError(msg)
+          case _ => throw t
+        }
+    } finally {
+      currentThread.setContextClassLoader(oldLoader)
     }
+  }
+  def getMainMethod(mainClassName: String, loader: ClassLoader) = {
+    val mainClass = Class.forName(mainClassName, true, loader)
+    val method = mainClass.getMethod("main", classOf[Array[String]])
+    // jvm allows the actual main class to be non-public and to run a method in the non-public class,
+    //  we need to make it accessible
+    method.setAccessible(true)
+    val modifiers = method.getModifiers
+    if (!isPublic(modifiers))
+      throw new NoSuchMethodException(mainClassName + ".main is not public")
+    if (!isStatic(modifiers))
+      throw new NoSuchMethodException(mainClassName + ".main is not static")
+    method
+  }
 }
 
 /** This module is an interface to starting the scala interpreter or runner.*/
 object Run {
-  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger)(implicit runner: ScalaRun) =
+  def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger)(
+      implicit runner: ScalaRun
+  ) =
     runner.run(mainClass, classpath, options, log)
 
   /** Executes the given function, trapping calls to System.exit. */
-  def executeTrapExit(f: => Unit, log: Logger): Option[String] =
-    {
-      val exitCode = TrapExit(f, log)
-      if (exitCode == 0) {
-        log.debug("Exited with code 0")
-        None
-      } else
-        Some("Nonzero exit code: " + exitCode)
-    }
+  def executeTrapExit(f: => Unit, log: Logger): Try[Unit] = {
+    val exitCode = TrapExit(f, log)
+    if (exitCode == 0) {
+      log.debug("Exited with code 0")
+      Success(())
+    } else Failure(new MessageOnlyException("Nonzero exit code: " + exitCode))
+  }
+
+  // quotes the option that includes a whitespace
+  // https://github.com/sbt/sbt/issues/4834
+  private[sbt] def runOptionsStr(options: Seq[String]): String =
+    (options map {
+      case str if str.contains(" ") => "\"" + str + "\""
+      case str                      => str
+    }).mkString(" ")
 }
diff --git a/run/src/main/scala/sbt/SelectMainClass.scala b/run/src/main/scala/sbt/SelectMainClass.scala
index 0c8e206ad..74803fb07 100644
--- a/run/src/main/scala/sbt/SelectMainClass.scala
+++ b/run/src/main/scala/sbt/SelectMainClass.scala
@@ -1,39 +1,59 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
+import sbt.internal.util.ConsoleAppender.ClearScreenAfterCursor
+import sbt.internal.util.Util.{ AnyOps, none }
+import scala.annotation.tailrec
+
 object SelectMainClass {
   // Some(SimpleReader.readLine _)
-  def apply(promptIfMultipleChoices: Option[String => Option[String]], mainClasses: Seq[String]): Option[String] =
-    {
-      mainClasses.toList match {
-        case Nil         => None
-        case head :: Nil => Some(head)
-        case multiple =>
-          promptIfMultipleChoices flatMap { prompt =>
-            println("\nMultiple main classes detected, select one to run:\n")
-            for ((className, index) <- multiple.zipWithIndex)
-              println(" [" + (index + 1) + "] " + className)
-            val line = trim(prompt("\nEnter number: "))
-            println("")
-            toInt(line, multiple.length) map multiple.apply
+  def apply(
+      promptIfMultipleChoices: Option[String => Option[String]],
+      mainClasses: Seq[String]
+  ): Option[String] = {
+    mainClasses.toList match {
+      case Nil         => None
+      case head :: Nil => Some(head)
+      case multiple =>
+        promptIfMultipleChoices.flatMap { prompt =>
+          @tailrec def loop(): Option[String] = {
+            val header = "\nMultiple main classes detected. Select one to run:\n"
+            val classes = multiple.zipWithIndex
+              .map { case (className, index) => s" [${index + 1}] $className" }
+              .mkString("\n")
+            println(ClearScreenAfterCursor + header + classes + "\n")
+            val line = trim(prompt("Enter number: "))
+            // An empty line usually means the user typed <ctrl+c>
+            if (line.nonEmpty) {
+              toInt(line, multiple.length) map multiple.apply match {
+                case None => loop()
+                case r    => r
+              }
+            } else None
           }
-      }
+          loop()
+        }
     }
+  }
   private def trim(s: Option[String]) = s.getOrElse("")
-  private def toInt(s: String, size: Int) =
+  private def toInt(s: String, size: Int): Option[Int] =
     try {
       val i = s.toInt
       if (i > 0 && i <= size)
-        Some(i - 1)
+        (i - 1).some
       else {
         println("Number out of range: was " + i + ", expected number between 1 and " + size)
-        None
+        none
       }
     } catch {
       case nfe: NumberFormatException =>
-        println("Invalid number: " + nfe.toString)
-        None
+        println(s"Invalid number: '$s'")
+        none
     }
-}
\ No newline at end of file
+}
diff --git a/run/src/main/scala/sbt/TrapExit.scala b/run/src/main/scala/sbt/TrapExit.scala
index 30fab253c..5c80e1be0 100644
--- a/run/src/main/scala/sbt/TrapExit.scala
+++ b/run/src/main/scala/sbt/TrapExit.scala
@@ -1,23 +1,24 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008 Mark Harrah
- *
- * Partially based on exit trapping in Nailgun by Pete Kirkham,
- * copyright 2004, Martian Software, Inc
- * licensed under Apache 2.0 License.
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import scala.reflect.Manifest
 import scala.collection.concurrent.TrieMap
-
 import java.lang.ref.WeakReference
 import Thread.currentThread
 import java.security.Permission
 import java.util.concurrent.{ ConcurrentHashMap => CMap }
 import java.lang.Integer.{ toHexString => hex }
+import java.util.function.Supplier
 
 import sbt.util.Logger
-
+import sbt.util.InterfaceUtil
+import sbt.internal.util.Util.{ AnyOps, none }
 import TrapExit._
 
 /**
@@ -32,13 +33,14 @@ import TrapExit._
  * This category of code should only be called by forking a new JVM.
  */
 object TrapExit {
+
   /**
    * Run `execute` in a managed context, using `log` for debugging messages.
    * `installManager` must be called before calling this method.
    */
   def apply(execute: => Unit, log: Logger): Int =
     System.getSecurityManager match {
-      case m: TrapExit => m.runManaged(Logger.f0(execute), log)
+      case m: TrapExit => m.runManaged(InterfaceUtil.toSupplier(execute), log)
       case _           => runUnmanaged(execute, log)
     }
 
@@ -56,17 +58,17 @@ object TrapExit {
   def uninstallManager(previous: SecurityManager): Unit =
     System.setSecurityManager(previous)
 
-  private[this] def runUnmanaged(execute: => Unit, log: Logger): Int =
-    {
-      log.warn("Managed execution not possible: security manager not installed.")
-      try { execute; 0 }
-      catch {
-        case e: Exception =>
-          log.error("Error during execution: " + e.toString)
-          log.trace(e)
-          1
-      }
+  private[this] def runUnmanaged(execute: => Unit, log: Logger): Int = {
+    log.warn("Managed execution not possible: security manager not installed.")
+    try {
+      execute; 0
+    } catch {
+      case e: Exception =>
+        log.error("Error during execution: " + e.toString)
+        log.trace(e)
+        1
     }
+  }
 
   private type ThreadID = String
 
@@ -98,29 +100,36 @@ object TrapExit {
     log.debug("\tInterrupted " + thread.getName)
   }
   // an uncaught exception handler that swallows InterruptedExceptions and otherwise defers to originalHandler
-  private final class TrapInterrupt(originalHandler: Thread.UncaughtExceptionHandler) extends Thread.UncaughtExceptionHandler {
+  private final class TrapInterrupt(originalHandler: Thread.UncaughtExceptionHandler)
+      extends Thread.UncaughtExceptionHandler {
     def uncaughtException(thread: Thread, e: Throwable): Unit = {
-      withCause[InterruptedException, Unit](e) { interrupted => () } { other => originalHandler.uncaughtException(thread, e) }
+      withCause[InterruptedException, Unit](e) { interrupted =>
+        ()
+      } { other =>
+        originalHandler.uncaughtException(thread, e)
+      }
       thread.setUncaughtExceptionHandler(originalHandler)
     }
   }
+
   /**
    * Recurses into the causes of the given exception looking for a cause of type CauseType.  If one is found, `withType` is called with that cause.
    *  If not, `notType` is called with the root cause.
    */
-  private def withCause[CauseType <: Throwable, T](e: Throwable)(withType: CauseType => T)(notType: Throwable => T)(implicit mf: Manifest[CauseType]): T =
-    {
-      val clazz = mf.runtimeClass
-      if (clazz.isInstance(e))
-        withType(e.asInstanceOf[CauseType])
-      else {
-        val cause = e.getCause
-        if (cause == null)
-          notType(e)
-        else
-          withCause(cause)(withType)(notType)(mf)
-      }
+  private def withCause[CauseType <: Throwable, T](
+      e: Throwable
+  )(withType: CauseType => T)(notType: Throwable => T)(implicit mf: Manifest[CauseType]): T = {
+    val clazz = mf.runtimeClass
+    if (clazz.isInstance(e))
+      withType(e.asInstanceOf[CauseType])
+    else {
+      val cause = e.getCause
+      if (cause == null)
+        notType(e)
+      else
+        withCause(cause)(withType)(notType)(mf)
     }
+  }
 
 }
 
@@ -136,6 +145,7 @@ object TrapExit {
  * Only one AWT application is supported at a time, however.
  */
 private final class TrapExit(delegateManager: SecurityManager) extends SecurityManager {
+
   /** Tracks the number of running applications in order to short-cut SecurityManager checks when no applications are active.*/
   private[this] val running = new java.util.concurrent.atomic.AtomicInteger
 
@@ -143,47 +153,46 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
   private[this] val threadToApp = new CMap[ThreadID, App]
 
   /** Executes `f` in a managed context. */
-  def runManaged(f: xsbti.F0[Unit], xlog: xsbti.Logger): Int =
-    {
-      val _ = running.incrementAndGet()
-      try runManaged0(f, xlog)
-      finally running.decrementAndGet()
-    }
-  private[this] def runManaged0(f: xsbti.F0[Unit], xlog: xsbti.Logger): Int =
-    {
-      val log: Logger = xlog
-      val app = new App(f, log)
-      val executionThread = app.mainThread
-      try {
-        executionThread.start() // thread actually evaluating `f`
-        finish(app, log)
-      } catch {
-        case e: InterruptedException => // here, the thread that started the run has been interrupted, not the main thread of the executing code
-          cancel(executionThread, app, log)
-      } finally app.cleanup()
+  def runManaged(f: Supplier[Unit], xlog: xsbti.Logger): Int = {
+    val _ = running.incrementAndGet()
+    try runManaged0(f, xlog)
+    finally {
+      running.decrementAndGet(); ()
     }
+  }
+  private[this] def runManaged0(f: Supplier[Unit], xlog: xsbti.Logger): Int = {
+    val log: Logger = xlog
+    val app = new App(f, log)
+    val executionThread = app.mainThread
+    try {
+      executionThread.start() // thread actually evaluating `f`
+      finish(app, log)
+    } catch {
+      case _: InterruptedException => // here, the thread that started the run has been interrupted, not the main thread of the executing code
+        cancel(executionThread, app, log)
+    } finally app.cleanup()
+  }
+
   /** Interrupt all threads and indicate failure in the exit code. */
-  private[this] def cancel(executionThread: Thread, app: App, log: Logger): Int =
-    {
-      log.warn("Run canceled.")
-      executionThread.interrupt()
-      stopAllThreads(app)
-      1
-    }
+  private[this] def cancel(executionThread: Thread, app: App, log: Logger): Int = {
+    log.warn("Run canceled.")
+    executionThread.interrupt()
+    stopAllThreads(app)
+    1
+  }
 
   /**
    * Wait for all non-daemon threads for `app` to exit, for an exception to be thrown in the main thread,
    * or for `System.exit` to be called in a thread started by `app`.
    */
-  private[this] def finish(app: App, log: Logger): Int =
-    {
-      log.debug("Waiting for threads to exit or System.exit to be called.")
-      waitForExit(app)
-      log.debug("Interrupting remaining threads (should be all daemons).")
-      stopAllThreads(app) // should only be daemon threads left now
-      log.debug("Sandboxed run complete..")
-      app.exitCode.value.getOrElse(0)
-    }
+  private[this] def finish(app: App, log: Logger): Int = {
+    log.debug("Waiting for threads to exit or System.exit to be called.")
+    waitForExit(app)
+    log.debug("Interrupting remaining threads (should be all daemons).")
+    stopAllThreads(app) // should only be daemon threads left now
+    log.debug("Sandboxed run complete..")
+    app.exitCode.value.getOrElse(0)
+  }
 
   // wait for all non-daemon threads to terminate
   private[this] def waitForExit(app: App): Unit = {
@@ -208,10 +217,11 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
 
   /**
    * Represents an isolated application as simulated by [[TrapExit]].
-   * `execute` is the application code to evalute.
+   * `execute` is the application code to evaluate.
    * `log` is used for debug logging.
    */
-  private final class App(val execute: xsbti.F0[Unit], val log: Logger) extends Runnable {
+  private final class App(val execute: Supplier[Unit], val log: Logger) extends Runnable {
+
     /**
      * Tracks threads and groups created by this application.
      * To avoid leaks, keys are a unique identifier and values are held via WeakReference.
@@ -230,7 +240,8 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
     /** The ThreadGroup to use to try to track created threads. */
     val mainGroup: ThreadGroup = new ThreadGroup("run-main-group-" + id) {
       private[this] val handler = new LoggingExceptionHandler(log, None)
-      override def uncaughtException(t: Thread, e: Throwable): Unit = handler.uncaughtException(t, e)
+      override def uncaughtException(t: Thread, e: Throwable): Unit =
+        handler.uncaughtException(t, e)
     }
     val mainThread = new Thread(mainGroup, this, "run-main-" + id)
 
@@ -244,7 +255,7 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
     val exitCode = new ExitCode
 
     def run(): Unit = {
-      try execute()
+      try execute.get()
       catch {
         case x: Throwable =>
           exitCode.set(1) //exceptions in the main thread cause the exit code to be 1
@@ -259,6 +270,7 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
         val old = groups.putIfAbsent(groupID, new WeakReference(g))
         if (old.isEmpty) { // wasn't registered
           threadToApp.put(groupID, this)
+          ()
         }
       }
 
@@ -266,26 +278,25 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
      * Records a new thread both in the global [[TrapExit]] manager and for this [[App]].
      * Its uncaught exception handler is configured to log exceptions through `log`.
      */
-    def register(t: Thread): Unit =
-      {
-        val threadID = computeID(t)
-        if (!isDone(t) && threadID != creatorThreadID) {
-          val old = threads.putIfAbsent(threadID, new WeakReference(t))
-          if (old.isEmpty) { // wasn't registered
-            threadToApp.put(threadID, this)
-            setExceptionHandler(t)
-            if (!awtUsed && isEventQueue(t))
-              awtUsed = true
-          }
+    def register(t: Thread): Unit = {
+      val threadID = computeID(t)
+      if (!isDone(t) && threadID != creatorThreadID) {
+        val old = threads.putIfAbsent(threadID, new WeakReference(t))
+        if (old.isEmpty) { // wasn't registered
+          threadToApp.put(threadID, this)
+          setExceptionHandler(t)
+          if (!awtUsed && isEventQueue(t))
+            awtUsed = true
         }
       }
+    }
 
     /** Registers the logging exception handler on `t`, delegating to the existing handler if it isn't the default. */
     private[this] def setExceptionHandler(t: Thread): Unit = {
       val group = t.getThreadGroup
       val previousHandler = t.getUncaughtExceptionHandler match {
-        case null | `group` | (_: LoggingExceptionHandler) => None
-        case x => Some(x) // delegate to a custom handler only
+        case null | `group` | (_: LoggingExceptionHandler) => none[Thread.UncaughtExceptionHandler]
+        case x                                             => x.some // delegate to a custom handler only
       }
       t.setUncaughtExceptionHandler(new LoggingExceptionHandler(log, previousHandler))
     }
@@ -295,7 +306,9 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
       threadToApp.remove(id)
       threads.remove(id)
       groups.remove(id)
+      ()
     }
+
     /** Final cleanup for this application after it has terminated. */
     def cleanup(): Unit = {
       cleanup(threads)
@@ -333,16 +346,18 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
     private[this] def addUntrackedThreads(): Unit =
       groupThreadsSnapshot foreach register
 
-    private[this] def groupThreadsSnapshot: Seq[Thread] =
-      {
-        val snap = groups.readOnlySnapshot.values.map(_.get).filter(_ != null)
-        threadsInGroups(snap.toList, Nil)
-      }
+    private[this] def groupThreadsSnapshot: Seq[Thread] = {
+      val snap = groups.readOnlySnapshot.values.map(_.get).filter(_ != null)
+      threadsInGroups(snap.toList, Nil)
+    }
 
     // takes a snapshot of the threads in `toProcess`, acquiring nested locks on each group to do so
     // the thread groups are accumulated in `accum` and then the threads in each are collected all at
     // once while they are all locked.  This is the closest thing to a snapshot that can be accomplished.
-    private[this] def threadsInGroups(toProcess: List[ThreadGroup], accum: List[ThreadGroup]): List[Thread] = toProcess match {
+    private[this] def threadsInGroups(
+        toProcess: List[ThreadGroup],
+        accum: List[ThreadGroup]
+    ): List[Thread] = toProcess match {
       case group :: tail =>
         // ThreadGroup implementation synchronizes on its methods, so by synchronizing here, we can workaround its quirks somewhat
         group.synchronized {
@@ -353,22 +368,20 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
     }
 
     // gets the immediate child ThreadGroups of `group`
-    private[this] def threadGroups(group: ThreadGroup): List[ThreadGroup] =
-      {
-        val upperBound = group.activeGroupCount
-        val groups = new Array[ThreadGroup](upperBound)
-        val childrenCount = group.enumerate(groups, false)
-        groups.take(childrenCount).toList
-      }
+    private[this] def threadGroups(group: ThreadGroup): List[ThreadGroup] = {
+      val upperBound = group.activeGroupCount
+      val groups = new Array[ThreadGroup](upperBound)
+      val childrenCount = group.enumerate(groups, false)
+      groups.take(childrenCount).toList
+    }
 
     // gets the immediate child Threads of `group`
-    private[this] def threads(group: ThreadGroup): List[Thread] =
-      {
-        val upperBound = group.activeCount
-        val threads = new Array[Thread](upperBound)
-        val childrenCount = group.enumerate(threads, false)
-        threads.take(childrenCount).toList
-      }
+    private[this] def threads(group: ThreadGroup): List[Thread] = {
+      val upperBound = group.activeCount
+      val threads = new Array[Thread](upperBound)
+      val childrenCount = group.enumerate(threads, false)
+      threads.take(childrenCount).toList
+    }
   }
 
   private[this] def stopAllThreads(app: App): Unit = {
@@ -381,7 +394,10 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
   }
 
   private[this] def interruptAllThreads(app: App): Unit =
-    app processThreads { t => if (!isSystemThread(t)) safeInterrupt(t, app.log) else app.log.debug(s"Not interrupting system thread $t") }
+    app processThreads { t =>
+      if (!isSystemThread(t)) safeInterrupt(t, app.log)
+      else app.log.debug(s"Not interrupting system thread $t")
+    }
 
   /** Gets the managed application associated with Thread `t` */
   private[this] def getApp(t: Thread): Option[App] =
@@ -411,6 +427,7 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
       throw new TrapExitSecurityException(status)
     }
   }
+
   /** This ensures that only actual calls to exit are trapped and not just calls to check if exit is allowed.*/
   private def isRealExit(element: StackTraceElement): Boolean =
     element.getClassName == "java.lang.Runtime" && element.getMethodName == "exit"
@@ -450,6 +467,7 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
     if (delegateManager ne null)
       delegateManager.checkAccess(t)
   }
+
   /**
    * This is specified to be called in every Thread's constructor and every time a ThreadGroup is created.
    * This allows us to reliably track every ThreadGroup that is created and map it back to the constructing application.
@@ -485,6 +503,7 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
       Thread.sleep(waitSeconds * 1000L) // AWT Thread doesn't exit immediately, so wait to interrupt it
     }
   }
+
   /** Returns true if the given thread is in the 'system' thread group or is an AWT thread other than AWT-EventQueue.*/
   private def isSystemThread(t: Thread) =
     if (t.getName.startsWith("AWT-"))
@@ -510,7 +529,10 @@ private final class ExitCode {
  * The default uncaught exception handler for managed executions.
  * It logs the thread and the exception.
  */
-private final class LoggingExceptionHandler(log: Logger, delegate: Option[Thread.UncaughtExceptionHandler]) extends Thread.UncaughtExceptionHandler {
+private final class LoggingExceptionHandler(
+    log: Logger,
+    delegate: Option[Thread.UncaughtExceptionHandler]
+) extends Thread.UncaughtExceptionHandler {
   def uncaughtException(t: Thread, e: Throwable): Unit = {
     log.error("(" + t.getName + ") " + e.toString)
     log.trace(e)
diff --git a/run/src/main/scala/sbt/TrapExitSecurityException.scala b/run/src/main/scala/sbt/TrapExitSecurityException.scala
index dc5792e66..ff5416eab 100644
--- a/run/src/main/scala/sbt/TrapExitSecurityException.scala
+++ b/run/src/main/scala/sbt/TrapExitSecurityException.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 /**
diff --git a/run/src/test/scala/sbt/ForkTest.scala b/run/src/test/scala/sbt/ForkTest.scala
index 638012ad8..a3a66d47b 100644
--- a/run/src/test/scala/sbt/ForkTest.scala
+++ b/run/src/test/scala/sbt/ForkTest.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import org.scalacheck._
@@ -7,8 +14,11 @@ import java.io.File
 
 import sbt.internal.TestLogger
 import sbt.io.{ IO, Path }
+import OutputStrategy._
+import sbt.internal.util.Util._
 
 object ForkTest extends Properties("Fork") {
+
   /**
    * Heuristic for limiting the length of the classpath string.
    * Longer than this will hit hard limits in the total space
@@ -16,38 +26,41 @@ object ForkTest extends Properties("Fork") {
    */
   final val MaximumClasspathLength = 100000
 
-  lazy val genOptionName = frequency((9, Some("-cp")), (9, Some("-classpath")), (1, None))
+  lazy val genOptionName = frequency((9, "-cp".some), (9, "-classpath".some), (1, none))
   lazy val pathElement = nonEmptyListOf(alphaNumChar).map(_.mkString)
   lazy val path = nonEmptyListOf(pathElement).map(_.mkString(File.separator))
   lazy val genRelClasspath = nonEmptyListOf(path)
 
   lazy val requiredEntries =
-    IO.classLocationFile[scala.Option[_]] ::
-      IO.classLocationFile[sbt.exit.type] ::
+    IO.classLocationPath[scala.Option[_]].toFile ::
+      IO.classLocationPath[sbt.exit.type].toFile ::
       Nil
   lazy val mainAndArgs =
     "sbt.exit" ::
       "0" ::
       Nil
 
-  property("Arbitrary length classpath successfully passed.") = forAllNoShrink(genOptionName, genRelClasspath) { (optionName: Option[String], relCP: List[String]) =>
-    IO.withTemporaryDirectory { dir =>
-      TestLogger { log =>
-        val withScala = requiredEntries ::: relCP.map(rel => new File(dir, rel))
-        val absClasspath = trimClasspath(Path.makeString(withScala))
-        val args = optionName.map(_ :: absClasspath :: Nil).toList.flatten ++ mainAndArgs
-        val config = ForkOptions(outputStrategy = Some(LoggedOutput(log)))
-        val exitCode = try Fork.java(config, args) catch { case e: Exception => e.printStackTrace; 1 }
-        val expectedCode = if (optionName.isEmpty) 1 else 0
-        s"temporary directory: ${dir.getAbsolutePath}" |:
-          s"required classpath: ${requiredEntries.mkString("\n\t", "\n\t", "")}" |:
-          s"main and args: ${mainAndArgs.mkString(" ")}" |:
-          s"args length: ${args.mkString(" ").length}" |:
-          s"exitCode: $exitCode, expected: $expectedCode" |:
-          (exitCode == expectedCode)
-      }
+  property("Arbitrary length classpath successfully passed.") =
+    forAllNoShrink(genOptionName, genRelClasspath) {
+      (optionName: Option[String], relCP: List[String]) =>
+        IO.withTemporaryDirectory { dir =>
+          TestLogger { log =>
+            val withScala = requiredEntries ::: relCP.map(rel => new File(dir, rel))
+            val absClasspath = trimClasspath(Path.makeString(withScala))
+            val args = optionName.map(_ :: absClasspath :: Nil).toList.flatten ++ mainAndArgs
+            val config = ForkOptions().withOutputStrategy(LoggedOutput(log))
+            val exitCode = try Fork.java(config, args)
+            catch { case e: Exception => e.printStackTrace; 1 }
+            val expectedCode = if (optionName.isEmpty) 1 else 0
+            s"temporary directory: ${dir.getAbsolutePath}" |:
+              s"required classpath: ${requiredEntries.mkString("\n\t", "\n\t", "")}" |:
+              s"main and args: ${mainAndArgs.mkString(" ")}" |:
+              s"args length: ${args.mkString(" ").length}" |:
+              s"exitCode: $exitCode, expected: $expectedCode" |:
+              (exitCode == expectedCode)
+          }
+        }
     }
-  }
 
   private[this] def trimClasspath(cp: String): String =
     if (cp.length > MaximumClasspathLength) {
diff --git a/run/src/test/scala/sbt/TestLogger.scala b/run/src/test/scala/sbt/TestLogger.scala
index 284bd70b6..6c3e96d51 100644
--- a/run/src/test/scala/sbt/TestLogger.scala
+++ b/run/src/test/scala/sbt/TestLogger.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package internal
 
@@ -5,10 +12,9 @@ import sbt.internal.util._
 import sbt.util._
 
 object TestLogger {
-  def apply[T](f: Logger => T): T =
-    {
-      val log = new BufferedLogger(ConsoleLogger())
-      log.setLevel(Level.Debug)
-      log.bufferQuietly(f(log))
-    }
+  def apply[T](f: Logger => T): T = {
+    val log = new BufferedLogger(ConsoleLogger())
+    log.setLevel(Level.Debug)
+    log.bufferQuietly(f(log))
+  }
 }
diff --git a/sbt-allsources.sh b/sbt-allsources.sh
new file mode 100755
index 000000000..c14239763
--- /dev/null
+++ b/sbt-allsources.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+sbt -Dsbtio.path=../io -Dsbtlm.path=../librarymanagement -Dsbtzinc.path=../zinc "$@"
diff --git a/sbt/project/build.properties b/sbt/project/build.properties
new file mode 100644
index 000000000..6db984250
--- /dev/null
+++ b/sbt/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.4.0
diff --git a/sbt/src/main/resources/log4j2.xml b/sbt/src/main/resources/log4j2.xml
new file mode 100644
index 000000000..5fa86616d
--- /dev/null
+++ b/sbt/src/main/resources/log4j2.xml
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration/>
diff --git a/sbt/src/main/scala/ProcessExtra.scala b/sbt/src/main/scala/ProcessExtra.scala
deleted file mode 100644
index 4625c6c90..000000000
--- a/sbt/src/main/scala/ProcessExtra.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-package sbt
-
-import java.lang.{ ProcessBuilder => JProcessBuilder }
-
-trait ProcessExtra {
-  import scala.sys.process._
-  import scala.sys.process.Process._
-  implicit def builderToProcess(builder: JProcessBuilder): ProcessBuilder = apply(builder)
-  implicit def fileToProcess(file: File): ProcessBuilder.FileBuilder = apply(file)
-  implicit def urlToProcess(url: URL): ProcessBuilder.URLBuilder = apply(url)
-  implicit def buildersToProcess[T](builders: Seq[T])(implicit convert: T => ProcessBuilder.Source): Seq[ProcessBuilder.Source] = applySeq(builders)
-
-  implicit def stringToProcess(command: String): ProcessBuilder = apply(command)
-  implicit def stringSeqToProcess(command: Seq[String]): ProcessBuilder = apply(command)
-}
diff --git a/sbt/src/main/scala/package.scala b/sbt/src/main/scala/package.scala
index 71288c370..01d133947 100644
--- a/sbt/src/main/scala/package.scala
+++ b/sbt/src/main/scala/package.scala
@@ -1,4 +1,64 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010, 2011 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
-package object sbt extends Import
+
+import sbt.nio.FileStamp
+import sjsonnew.JsonFormat
+import java.nio.file.{ Path => NioPath }
+
+import sbt.internal.FileChangesMacro
+
+import scala.language.experimental.macros
+
+package object sbt
+    extends sbt.IOSyntax0
+    with sbt.std.TaskExtra
+    with sbt.internal.util.Types
+    with sbt.ProjectExtra
+    with sbt.librarymanagement.DependencyBuilders
+    with sbt.librarymanagement.DependencyFilterExtra
+    with sbt.librarymanagement.LibraryManagementSyntax
+    with sbt.BuildExtra
+    with sbt.TaskMacroExtra
+    with sbt.ScopeFilter.Make
+    with sbt.BuildSyntax
+    with sbt.OptionSyntax
+    with sbt.SlashSyntax
+    with sbt.Import {
+  // IO
+  def uri(s: String): URI = new URI(s)
+  def file(s: String): File = new File(s)
+  def url(s: String): URL = new URL(s)
+  implicit def fileToRichFile(file: File): sbt.io.RichFile = new sbt.io.RichFile(file)
+  implicit def filesToFinder(cc: Traversable[File]): sbt.io.PathFinder =
+    sbt.io.PathFinder.strict(cc)
+  /*
+   * Provides macro extension methods. Because the extension methods are all macros, no instance
+   * of FileChangesMacro.TaskOps is ever made which is why it is ok to use `???`.
+   */
+  implicit def taskToTaskOpts[T](t: TaskKey[T]): FileChangesMacro.TaskOps[T] = ???
+  implicit val fileStampJsonFormatter: JsonFormat[Seq[(NioPath, FileStamp)]] =
+    FileStamp.Formats.seqPathFileStampJsonFormatter
+  implicit val pathJsonFormatter: JsonFormat[Seq[NioPath]] = FileStamp.Formats.seqPathJsonFormatter
+  implicit val fileJsonFormatter: JsonFormat[Seq[File]] = FileStamp.Formats.seqFileJsonFormatter
+  implicit val singlePathJsonFormatter: JsonFormat[NioPath] = FileStamp.Formats.pathJsonFormatter
+  implicit val singleFileJsonFormatter: JsonFormat[File] = FileStamp.Formats.fileJsonFormatter
+  // others
+
+  object CompileOrder {
+    val JavaThenScala = xsbti.compile.CompileOrder.JavaThenScala
+    val ScalaThenJava = xsbti.compile.CompileOrder.ScalaThenJava
+    val Mixed = xsbti.compile.CompileOrder.Mixed
+  }
+  type CompileOrder = xsbti.compile.CompileOrder
+
+  final val ThisScope = Scope.ThisScope
+  final val Global = Scope.Global
+  final val GlobalScope = Scope.GlobalScope
+
+  def config(name: String): Configuration =
+    macro sbt.librarymanagement.ConfigurationMacro.configMacroImpl
+}
diff --git a/sbt/src/main/scala/sbt/AllSyntax.scala b/sbt/src/main/scala/sbt/AllSyntax.scala
new file mode 100644
index 000000000..d3b6520fd
--- /dev/null
+++ b/sbt/src/main/scala/sbt/AllSyntax.scala
@@ -0,0 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+private[sbt] trait IOSyntax0 extends IOSyntax1 {
+  implicit def alternative[A, B](f: A => Option[B]): Alternative[A, B] = new Alternative[A, B] {
+    override def |(g: A => Option[B]): A => Option[B] = (a: A) => f(a) orElse g(a)
+  }
+}
+private[sbt] sealed trait IOSyntax1 extends sbt.io.IOSyntax with sbt.nio.file.syntax0
+private[sbt] sealed trait Alternative[A, B] {
+  def |(g: A => Option[B]): A => Option[B]
+}
diff --git a/sbt/src/main/scala/Import.scala b/sbt/src/main/scala/sbt/Import.scala
similarity index 67%
rename from sbt/src/main/scala/Import.scala
rename to sbt/src/main/scala/sbt/Import.scala
index 131021359..b71e855df 100644
--- a/sbt/src/main/scala/Import.scala
+++ b/sbt/src/main/scala/sbt/Import.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 trait Import {
@@ -8,8 +15,28 @@ trait Import {
   type URI = java.net.URI
   type URL = java.net.URL
 
+  @deprecated("Will be removed in sbt 2", "1.0.0-RC3")
+  def Seq2Vector[T](s: Seq[T]): Vector[T] = s.toVector
+
+  // sbt
+  val StdoutOutput = sbt.OutputStrategy.StdoutOutput
+  type BufferedOutput = sbt.OutputStrategy.BufferedOutput
+  val BufferedOutput = sbt.OutputStrategy.BufferedOutput
+  type LoggedOutput = sbt.OutputStrategy.LoggedOutput
+  val LoggedOutput = sbt.OutputStrategy.LoggedOutput
+  type CustomOutput = sbt.OutputStrategy.CustomOutput
+  val CustomOutput = sbt.OutputStrategy.CustomOutput
+  val AllRequirements = sbt.PluginTrigger.AllRequirements
+  val NoTrigger = sbt.PluginTrigger.NoTrigger
+
+  // sbt.testing
+  type TestResult = sbt.protocol.testing.TestResult
+  val TestResult = sbt.protocol.testing.TestResult
+
   // sbt.io
   val AllPassFilter = sbt.io.AllPassFilter
+  val CopyOptions = sbt.io.CopyOptions
+  type CopyOptions = sbt.io.CopyOptions
   val DirectoryFilter = sbt.io.DirectoryFilter
   type ExactFilter = sbt.io.ExactFilter
   val ExistsFileFilter = sbt.io.ExistsFileFilter
@@ -30,24 +57,72 @@ trait Import {
   type RichFile = sbt.io.RichFile
   type SimpleFileFilter = sbt.io.SimpleFileFilter
   type SimpleFilter = sbt.io.SimpleFilter
+  type WatchSource = sbt.internal.io.Source
+  val WatchSource = sbt.internal.io.Source
+
+  // sbt.nio
+  val ** = sbt.nio.file.**
+  val * = sbt.nio.file.*
+  val AnyPath = sbt.nio.file.AnyPath
+  type ChangedFiles = sbt.nio.file.ChangedFiles
+  val ChangedFiles = sbt.nio.file.ChangedFiles
+  type FileChanges = sbt.nio.FileChanges
+  val FileChanges = sbt.nio.FileChanges
+  type Glob = sbt.nio.file.Glob
+  val Glob = sbt.nio.file.Glob
+  type PathFilter = sbt.nio.file.PathFilter
+  val PathFilter = sbt.nio.file.PathFilter
+  type RelativeGlob = sbt.nio.file.RelativeGlob
+  val RelativeGlob = sbt.nio.file.RelativeGlob
+  val RecursiveGlob = sbt.nio.file.RecursiveGlob
+  val Watch = sbt.nio.Watch
 
   // sbt.util
   type AbstractLogger = sbt.util.AbstractLogger
-  val ControlEvent = sbt.util.ControlEvent
+  type BasicCache[I, O] = sbt.util.BasicCache[I, O]
+  type BasicCacheImplicits = sbt.util.BasicCacheImplicits
+  type Cache[I, O] = sbt.util.Cache[I, O]
+  val Cache = sbt.util.Cache
+  val CacheImplicits = sbt.util.CacheImplicits
+  @deprecated("Use Tracked.inputChanged and Tracked.outputChanged instead", "1.0.1")
+  type Changed[O] = sbt.util.Changed[O]
+  type ChangeReport[T] = sbt.util.ChangeReport[T]
+  val ChangeReport = sbt.util.ChangeReport
   type ControlEvent = sbt.util.ControlEvent
+  val ControlEvent = sbt.util.ControlEvent
+  type Difference = sbt.util.Difference
+  val Difference = sbt.util.Difference
+  type EmptyChangeReport[T] = sbt.util.EmptyChangeReport[T]
+  val FileFunction = sbt.util.FileFunction
+  type FileInfo = sbt.util.FileInfo
+  val FileInfo = sbt.util.FileInfo
+  type FilesInfo[F <: FileInfo] = sbt.util.FilesInfo[F]
+  val FilesInfo = sbt.util.FilesInfo
+  type HashFileInfo = sbt.util.HashFileInfo
+  type HashModifiedFileInfo = sbt.util.HashModifiedFileInfo
   val Level = sbt.util.Level
   type Log = sbt.util.Log
   type LogEvent = sbt.util.LogEvent
-  val Logger = sbt.util.Logger
   type Logger = sbt.util.Logger
+  val Logger = sbt.util.Logger
+  type ModifiedFileInfo = sbt.util.ModifiedFileInfo
+  type PlainFileInfo = sbt.util.PlainFileInfo
   type SetLevel = sbt.util.SetLevel
   type SetSuccess = sbt.util.SetSuccess
   type SetTrace = sbt.util.SetTrace
+  type Show[T] = sbt.util.Show[T]
+  val Show = sbt.util.Show
+  type ShowLines[A] = sbt.util.ShowLines[A]
+  val ShowLines = sbt.util.ShowLines
   type Success = sbt.util.Success
+  type Timestamp = sbt.util.Timestamp
   type Trace = sbt.util.Trace
+  type Tracked = sbt.util.Tracked
+  val Tracked = sbt.util.Tracked
 
   // sbt.internal.util
   val AList = sbt.internal.util.AList
+  type AList[K[L[x]]] = sbt.internal.util.AList[K]
   type AbstractRMap[K[_], V[_]] = sbt.internal.util.AbstractRMap[K, V]
   type AlreadyHandledException = sbt.internal.util.AlreadyHandledException
   val AttributeEntry = sbt.internal.util.AttributeEntry
@@ -58,17 +133,8 @@ trait Import {
   type AttributeMap = sbt.internal.util.AttributeMap
   val Attributed = sbt.internal.util.Attributed
   type Attributed[D] = sbt.internal.util.Attributed[D]
-  type BasicCache[I, O] = sbt.internal.util.BasicCache[I, O]
-  type BasicCacheImplicits = sbt.internal.util.BasicCacheImplicits
   type BasicLogger = sbt.internal.util.BasicLogger
   type BufferedLogger = sbt.internal.util.BufferedLogger
-  val Cache = sbt.internal.util.Cache
-  type Cache[I, O] = sbt.internal.util.Cache[I, O]
-  val CacheIO = sbt.internal.util.CacheIO
-  type CacheImplicits = sbt.internal.util.CacheImplicits
-  val ChangeReport = sbt.internal.util.ChangeReport
-  type ChangeReport[T] = sbt.internal.util.ChangeReport[T]
-  type Changed[O] = sbt.internal.util.Changed[O]
   val Classes = sbt.internal.util.Classes
   val ConsoleLogger = sbt.internal.util.ConsoleLogger
   type ConsoleLogger = sbt.internal.util.ConsoleLogger
@@ -77,9 +143,6 @@ trait Import {
   val Dag = sbt.internal.util.Dag
   type Dag[A <: Dag[A]] = sbt.internal.util.Dag[A]
   type DelegatingPMap[K[_], V[_]] = sbt.internal.util.DelegatingPMap[K, V]
-  val Difference = sbt.internal.util.Difference
-  type Difference = sbt.internal.util.Difference
-  type EmptyChangeReport[T] = sbt.internal.util.EmptyChangeReport[T]
   val ErrorHandling = sbt.internal.util.ErrorHandling
   type EvaluateSettings[S] = sbt.internal.util.EvaluateSettings[S]
   val EvaluationState = sbt.internal.util.EvaluationState
@@ -87,38 +150,23 @@ trait Import {
   type ExitHook = sbt.internal.util.ExitHook
   val ExitHooks = sbt.internal.util.ExitHooks
   type FeedbackProvidedException = sbt.internal.util.FeedbackProvidedException
-  val FileFunction = sbt.internal.util.FileFunction
-  val FileInfo = sbt.internal.util.FileInfo
-  type FileInfo = sbt.internal.util.FileInfo
   type FilePosition = sbt.internal.util.FilePosition
-  val FilesInfo = sbt.internal.util.FilesInfo
-  type FilesInfo[F <: FileInfo] = sbt.internal.util.FilesInfo[F]
   type FilterLogger = sbt.internal.util.FilterLogger
-  type Fn1[A, B] = sbt.internal.util.Fn1[A, B]
   val FullLogger = sbt.internal.util.FullLogger
   type FullLogger = sbt.internal.util.FullLogger
   val FullReader = sbt.internal.util.FullReader
   type FullReader = sbt.internal.util.FullReader
-  val GlobalLogBacking = sbt.internal.util.GlobalLogBacking
-  type GlobalLogBacking = sbt.internal.util.GlobalLogBacking
-  val GlobalLogging = sbt.internal.util.GlobalLogging
-  type GlobalLogging = sbt.internal.util.GlobalLogging
   val HCons = sbt.internal.util.HCons
   type HCons[H, T <: HList] = sbt.internal.util.HCons[H, T]
   val HList = sbt.internal.util.HList
   type HList = sbt.internal.util.HList
-  type HListCacheImplicits = sbt.internal.util.HListCacheImplicits
   val HNil = sbt.internal.util.HNil
   type HNil = sbt.internal.util.HNil
-  type HashFileInfo = sbt.internal.util.HashFileInfo
-  type HashModifiedFileInfo = sbt.internal.util.HashModifiedFileInfo
   val IDSet = sbt.internal.util.IDSet
   type IDSet[T] = sbt.internal.util.IDSet[T]
   val IMap = sbt.internal.util.IMap
   type IMap[K[_], V[_]] = sbt.internal.util.IMap[K, V]
   type Init[S] = sbt.internal.util.Init[S]
-  val InputCache = sbt.internal.util.InputCache
-  type InputCache[I] = sbt.internal.util.InputCache[I]
   type JLine = sbt.internal.util.JLine
   val KCons = sbt.internal.util.KCons
   type KCons[H, +T <: KList[M], +M[_]] = sbt.internal.util.KCons[H, T, M]
@@ -132,53 +180,36 @@ trait Import {
   type LineReader = sbt.internal.util.LineReader
   val LoggerWriter = sbt.internal.util.LoggerWriter
   type LoggerWriter = sbt.internal.util.LoggerWriter
-  val MainLogging = sbt.internal.util.MainLogging
   type MessageOnlyException = sbt.internal.util.MessageOnlyException
-  type ModifiedFileInfo = sbt.internal.util.ModifiedFileInfo
   type MultiLogger = sbt.internal.util.MultiLogger
-  val MultiLoggerConfig = sbt.internal.util.MultiLoggerConfig
-  type MultiLoggerConfig = sbt.internal.util.MultiLoggerConfig
   val NoPosition = sbt.internal.util.NoPosition
   val PMap = sbt.internal.util.PMap
   type PMap[K[_], V[_]] = sbt.internal.util.PMap[K, V]
-  val Param = sbt.internal.util.Param
-  type Param[A[_], B[_]] = sbt.internal.util.Param[A, B]
-  type PlainFileInfo = sbt.internal.util.PlainFileInfo
   type RMap[K[_], V[_]] = sbt.internal.util.RMap[K, V]
   val RangePosition = sbt.internal.util.RangePosition
   type RangePosition = sbt.internal.util.RangePosition
   val Relation = sbt.internal.util.Relation
   type Relation[A, B] = sbt.internal.util.Relation[A, B]
-  type SBinaryFormats = sbt.internal.util.SBinaryFormats
   val ScalaKeywords = sbt.internal.util.ScalaKeywords
   type Settings[S] = sbt.internal.util.Settings[S]
   type SharedAttributeKey[T] = sbt.internal.util.SharedAttributeKey[T]
-  val Show = sbt.internal.util.Show
-  type Show[T] = sbt.internal.util.Show[T]
-  val ShowLines = sbt.internal.util.ShowLines
-  type ShowLines[A] = sbt.internal.util.ShowLines[A]
   val Signals = sbt.internal.util.Signals
   val SimpleReader = sbt.internal.util.SimpleReader
   type SimpleReader = sbt.internal.util.SimpleReader
   type SourcePosition = sbt.internal.util.SourcePosition
   val StackTrace = sbt.internal.util.StackTrace
   type SuppressedTraceContext = sbt.internal.util.SuppressedTraceContext
-  type Timestamp = sbt.internal.util.Timestamp
-  val Tracked = sbt.internal.util.Tracked
-  type Tracked = sbt.internal.util.Tracked
   type TranslatedException = sbt.internal.util.TranslatedException
   type TranslatedIOException = sbt.internal.util.TranslatedIOException
   val TypeFunctions = sbt.internal.util.TypeFunctions
   type TypeFunctions = sbt.internal.util.TypeFunctions
   val Types = sbt.internal.util.Types
   type Types = sbt.internal.util.Types
-  type UnionImplicits = sbt.internal.util.UnionImplicits
   type UnprintableException = sbt.internal.util.UnprintableException
   val Util = sbt.internal.util.Util
   val ~> = sbt.internal.util.~>
   type ~>[-K[_], +V[_]] = sbt.internal.util.~>[K, V]
 
-
   // sbt.internal.util.complete
   object complete {
     val Completion = sbt.internal.util.complete.Completion
@@ -218,12 +249,16 @@ trait Import {
   // sbt.librarymanagement
   val Artifact = sbt.librarymanagement.Artifact
   type Artifact = sbt.librarymanagement.Artifact
+  val Binary = sbt.librarymanagement.Binary
+  type Binary = sbt.librarymanagement.Binary
   val Caller = sbt.librarymanagement.Caller
   type Caller = sbt.librarymanagement.Caller
   val ChainedResolver = sbt.librarymanagement.ChainedResolver
   type ChainedResolver = sbt.librarymanagement.ChainedResolver
-  val CircularDependencyLevel = sbt.librarymanagement.CircularDependencyLevel
-  type CircularDependencyLevel = sbt.librarymanagement.CircularDependencyLevel
+  val CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
+  type CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
+  val ConfigRef = sbt.librarymanagement.ConfigRef
+  type ConfigRef = sbt.librarymanagement.ConfigRef
   val Configuration = sbt.librarymanagement.Configuration
   type Configuration = sbt.librarymanagement.Configuration
   val ConfigurationReport = sbt.librarymanagement.ConfigurationReport
@@ -233,48 +268,65 @@ trait Import {
   type ConflictManager = sbt.librarymanagement.ConflictManager
   val ConflictWarning = sbt.librarymanagement.ConflictWarning
   type ConflictWarning = sbt.librarymanagement.ConflictWarning
-  val Credentials = sbt.librarymanagement.Credentials
-  type Credentials = sbt.librarymanagement.Credentials
+  val Credentials = sbt.librarymanagement.ivy.Credentials
+  type Credentials = sbt.librarymanagement.ivy.Credentials
   val CrossVersion = sbt.librarymanagement.CrossVersion
   type CrossVersion = sbt.librarymanagement.CrossVersion
-  val DefaultMavenRepository = sbt.librarymanagement.DefaultMavenRepository
+  val DefaultMavenRepository = sbt.librarymanagement.Resolver.DefaultMavenRepository
   val Developer = sbt.librarymanagement.Developer
   type Developer = sbt.librarymanagement.Developer
-  type DirectCredentials = sbt.librarymanagement.DirectCredentials
+  val Disabled = sbt.librarymanagement.Disabled
+  type Disabled = sbt.librarymanagement.Disabled
+  type DirectCredentials = sbt.librarymanagement.ivy.DirectCredentials
   val EvictionPair = sbt.librarymanagement.EvictionPair
   type EvictionPair = sbt.librarymanagement.EvictionPair
   val EvictionWarning = sbt.librarymanagement.EvictionWarning
   type EvictionWarning = sbt.librarymanagement.EvictionWarning
   val EvictionWarningOptions = sbt.librarymanagement.EvictionWarningOptions
   type EvictionWarningOptions = sbt.librarymanagement.EvictionWarningOptions
-  val ExclusionRule = sbt.librarymanagement.ExclusionRule
-  type ExclusionRule = sbt.librarymanagement.ExclusionRule
-  type FileCredentials = sbt.librarymanagement.FileCredentials
+  // val ExclusionRule = sbt.librarymanagement.InclExclRule
+  // type ExclusionRule = sbt.librarymanagement.InclExclRule
+  type FileCredentials = sbt.librarymanagement.ivy.FileCredentials
   val FileRepository = sbt.librarymanagement.FileRepository
   type FileRepository = sbt.librarymanagement.FileRepository
-  val IvyScala = sbt.librarymanagement.IvyScala
-  type IvyScala = sbt.librarymanagement.IvyScala
-  val JCenterRepository = sbt.librarymanagement.JCenterRepository
-  val JavaNet2Repository = sbt.librarymanagement.JavaNet2Repository
+  val Full = sbt.librarymanagement.Full
+  type Full = sbt.librarymanagement.Full
+  val InlineConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
+  type InlineConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
+  val IvyScala = sbt.librarymanagement.ScalaModuleInfo
+  type IvyScala = sbt.librarymanagement.ScalaModuleInfo
+  val JCenterRepository = sbt.librarymanagement.Resolver.JCenterRepository
+  val JavaNet2Repository = sbt.librarymanagement.Resolver.JavaNet2Repository
+  type LogicalClock = sbt.librarymanagement.LogicalClock
+  val LogicalClock = sbt.librarymanagement.LogicalClock
+  type MakePomConfiguration = sbt.librarymanagement.MakePomConfiguration
+  val MakePomConfiguration = sbt.librarymanagement.MakePomConfiguration
   val MavenCache = sbt.librarymanagement.MavenCache
   type MavenCache = sbt.librarymanagement.MavenCache
+  val MavenRepo = sbt.librarymanagement.MavenRepo
+  type MavenRepo = sbt.librarymanagement.MavenRepo
   val MavenRepository = sbt.librarymanagement.MavenRepository
   type MavenRepository = sbt.librarymanagement.MavenRepository
   val ModuleConfiguration = sbt.librarymanagement.ModuleConfiguration
   type ModuleConfiguration = sbt.librarymanagement.ModuleConfiguration
+  val ModuleDescriptorConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
+  type ModuleDescriptorConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
   val ModuleID = sbt.librarymanagement.ModuleID
   type ModuleID = sbt.librarymanagement.ModuleID
   val ModuleInfo = sbt.librarymanagement.ModuleInfo
   type ModuleInfo = sbt.librarymanagement.ModuleInfo
   val ModuleReport = sbt.librarymanagement.ModuleReport
   type ModuleReport = sbt.librarymanagement.ModuleReport
+  val ModuleSettings = sbt.librarymanagement.ModuleSettings
+  type ModuleSettings = sbt.librarymanagement.ModuleSettings
   val OrganizationArtifactReport = sbt.librarymanagement.OrganizationArtifactReport
   type OrganizationArtifactReport = sbt.librarymanagement.OrganizationArtifactReport
   val Patterns = sbt.librarymanagement.Patterns
   type Patterns = sbt.librarymanagement.Patterns
   type PatternsBasedRepository = sbt.librarymanagement.PatternsBasedRepository
+  val PublishConfiguration = sbt.librarymanagement.PublishConfiguration
+  type PublishConfiguration = sbt.librarymanagement.PublishConfiguration
   type RawRepository = sbt.librarymanagement.RawRepository
-  val RepositoryHelpers = sbt.librarymanagement.RepositoryHelpers
   val Resolver = sbt.librarymanagement.Resolver
   type Resolver = sbt.librarymanagement.Resolver
   val SbtArtifacts = sbt.librarymanagement.SbtArtifacts
@@ -283,6 +335,8 @@ trait Import {
   type ScalaVersion = sbt.librarymanagement.ScalaVersion
   val ScmInfo = sbt.librarymanagement.ScmInfo
   type ScmInfo = sbt.librarymanagement.ScmInfo
+  val SemanticSelector = sbt.librarymanagement.SemanticSelector
+  type SemanticSelector = sbt.librarymanagement.SemanticSelector
   val SftpRepository = sbt.librarymanagement.SftpRepository
   type SftpRepository = sbt.librarymanagement.SftpRepository
   type SshBasedRepository = sbt.librarymanagement.SshBasedRepository
@@ -292,8 +346,9 @@ trait Import {
   val TrackLevel = sbt.librarymanagement.TrackLevel
   val URLRepository = sbt.librarymanagement.URLRepository
   type URLRepository = sbt.librarymanagement.URLRepository
-  val UpdateOptions = sbt.librarymanagement.UpdateOptions
-  type UpdateOptions = sbt.librarymanagement.UpdateOptions
+  val UpdateLogging = sbt.librarymanagement.UpdateLogging
+  val UpdateOptions = sbt.librarymanagement.ivy.UpdateOptions
+  type UpdateOptions = sbt.librarymanagement.ivy.UpdateOptions
   val UpdateReport = sbt.librarymanagement.UpdateReport
   type UpdateReport = sbt.librarymanagement.UpdateReport
   val UpdateStats = sbt.librarymanagement.UpdateStats
@@ -302,10 +357,11 @@ trait Import {
   type VersionNumber = sbt.librarymanagement.VersionNumber
   type VersionNumberCompatibility = sbt.librarymanagement.VersionNumberCompatibility
 
-
-  // sbt.internal.librarymanagement
-  type IvyPaths = sbt.internal.librarymanagement.IvyPaths
-  val UpdateLogging = sbt.internal.librarymanagement.UpdateLogging
+  // sbt.librarymanagement.ivy
+  val InlineIvyConfiguration = sbt.librarymanagement.ivy.InlineIvyConfiguration
+  type InlineIvyConfiguration = sbt.librarymanagement.ivy.InlineIvyConfiguration
+  type IvyPaths = sbt.librarymanagement.ivy.IvyPaths
+  val IvyPaths = sbt.librarymanagement.ivy.IvyPaths
 
   type IncOptions = xsbti.compile.IncOptions
 }
diff --git a/sbt/src/main/scala/syntax.scala b/sbt/src/main/scala/syntax.scala
deleted file mode 100644
index 1472bec1f..000000000
--- a/sbt/src/main/scala/syntax.scala
+++ /dev/null
@@ -1,73 +0,0 @@
-package sbt
-
-import sbt.internal.DslEntry
-import sbt.internal.util.Eval
-
-object syntax extends syntax
-
-abstract class syntax extends IOSyntax0 with sbt.std.TaskExtra with sbt.internal.util.Types with sbt.ProcessExtra
-    with sbt.internal.librarymanagement.impl.DependencyBuilders with sbt.ProjectExtra
-    with sbt.internal.librarymanagement.DependencyFilterExtra with sbt.BuildExtra with sbt.TaskMacroExtra
-    with sbt.ScopeFilter.Make {
-
-  // IO
-  def uri(s: String): URI = new URI(s)
-  def file(s: String): File = new File(s)
-  def url(s: String): URL = new URL(s)
-  implicit def fileToRichFile(file: File): sbt.io.RichFile = new sbt.io.RichFile(file)
-  implicit def filesToFinder(cc: Traversable[File]): sbt.io.PathFinder = sbt.io.PathFinder.strict(cc)
-
-  // others
-
-  object CompileOrder {
-    val JavaThenScala = xsbti.compile.CompileOrder.JavaThenScala
-    val ScalaThenJava = xsbti.compile.CompileOrder.ScalaThenJava
-    val Mixed = xsbti.compile.CompileOrder.Mixed
-  }
-  type CompileOrder = xsbti.compile.CompileOrder
-
-  implicit def maybeToOption[S](m: xsbti.Maybe[S]): Option[S] =
-    if (m.isDefined) Some(m.get) else None
-
-  final val ThisScope = Scope.ThisScope
-  final val GlobalScope = Scope.GlobalScope
-
-  import sbt.{ Configurations => C }
-  final val Compile = C.Compile
-  final val Test = C.Test
-  final val Runtime = C.Runtime
-  final val IntegrationTest = C.IntegrationTest
-  final val Default = C.Default
-  final val Provided = C.Provided
-  // java.lang.System is more important, so don't alias this one
-  //  final val System = C.System
-  final val Optional = C.Optional
-  def config(s: String): Configuration = C.config(s)
-
-  import language.experimental.macros
-  def settingKey[T](description: String): SettingKey[T] = macro std.KeyMacro.settingKeyImpl[T]
-  def taskKey[T](description: String): TaskKey[T] = macro std.KeyMacro.taskKeyImpl[T]
-  def inputKey[T](description: String): InputKey[T] = macro std.KeyMacro.inputKeyImpl[T]
-
-  def enablePlugins(ps: AutoPlugin*): DslEntry = DslEntry.DslEnablePlugins(ps)
-  def disablePlugins(ps: AutoPlugin*): DslEntry = DslEntry.DslDisablePlugins(ps)
-  def configs(cs: Configuration*): DslEntry = DslEntry.DslConfigs(cs)
-  // avoid conflict with `sbt.Keys.aggregate`
-  def aggregateProjects(refs: Eval[ProjectReference]*): DslEntry = DslEntry.DslAggregate(refs)
-}
-
-// Todo share this this io.syntax
-private[sbt] trait IOSyntax0 extends IOSyntax1 {
-  implicit def alternative[A, B](f: A => Option[B]): Alternative[A, B] =
-    new Alternative[A, B] {
-      def |(g: A => Option[B]) =
-        (a: A) => f(a) orElse g(a)
-    }
-}
-private[sbt] trait Alternative[A, B] {
-  def |(g: A => Option[B]): A => Option[B]
-}
-
-private[sbt] trait IOSyntax1 {
-  implicit def singleFileFinder(file: File): sbt.io.PathFinder = sbt.io.PathFinder(file)
-}
diff --git a/sbt/src/repo-override-test/dependency-management/default-resolvers/build.sbt b/sbt/src/repo-override-test/dependency-management/default-resolvers/build.sbt
index 7984b34c7..ea3986b88 100644
--- a/sbt/src/repo-override-test/dependency-management/default-resolvers/build.sbt
+++ b/sbt/src/repo-override-test/dependency-management/default-resolvers/build.sbt
@@ -1,11 +1,9 @@
 lazy val check = taskKey[Unit]("")
 
-lazy val root = (project in file(".")).
-  settings(
-    autoScalaLibrary := false,
-    check := {
-      val ar = appResolvers.value.get
-      assert(!(ar exists { _.name == "jcenter" }))
-      assert(!(ar exists { _.name == "public" }))
-    }
-  )
+lazy val root = (project in file(".")).settings(
+  autoScalaLibrary := false,
+  check := {
+    val ar = appResolvers.value.get
+    assert(!(ar exists { _.name == "public" }))
+  }
+)
diff --git a/sbt/src/repo-override-test/repo.config b/sbt/src/repo-override-test/repo.config
index f3301bb9f..68dbabf81 100644
--- a/sbt/src/repo-override-test/repo.config
+++ b/sbt/src/repo-override-test/repo.config
@@ -1,3 +1,3 @@
 [repositories]
   local
-  typesafe-ivy-releases: https://repo.typesafe.com/typesafe/ivy-releases/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext]
+  jcenter: https://jcenter.bintray.com/
diff --git a/sbt/src/sbt-test/actions/add-alias/A.scala b/sbt/src/sbt-test/actions/add-alias/A.scala
index dbae0c48a..5b2ba478c 100644
--- a/sbt/src/sbt-test/actions/add-alias/A.scala
+++ b/sbt/src/sbt-test/actions/add-alias/A.scala
@@ -1,3 +1,5 @@
-object A extends App {
-  if(args(0).toBoolean) () else sys.error("Fail")
+object A {
+  def main(args: Array[String]): Unit = {
+    if (args(0).toBoolean) () else sys.error("Fail")
+  }
 }
diff --git a/sbt/src/sbt-test/actions/add-alias/build.sbt b/sbt/src/sbt-test/actions/add-alias/build.sbt
index 451b72246..089e388c1 100644
--- a/sbt/src/sbt-test/actions/add-alias/build.sbt
+++ b/sbt/src/sbt-test/actions/add-alias/build.sbt
@@ -1,2 +1,3 @@
-addCommandAlias("demo-success", "run true") ++
+addCommandAlias("demo-success", "run true")
 addCommandAlias("demo-failure", "run false")
+addCommandAlias("z", "scalaVersion")
diff --git a/sbt/src/sbt-test/actions/add-alias/test b/sbt/src/sbt-test/actions/add-alias/test
index b82ec3f27..0269ab4f8 100644
--- a/sbt/src/sbt-test/actions/add-alias/test
+++ b/sbt/src/sbt-test/actions/add-alias/test
@@ -1,2 +1,4 @@
 > demo-success
 -> demo-failure
+> +z
+> z
diff --git a/sbt/src/sbt-test/actions/aggregate/changes/build.sbt b/sbt/src/sbt-test/actions/aggregate/changes/build.sbt
index 6e31842b1..d369e4f9c 100644
--- a/sbt/src/sbt-test/actions/aggregate/changes/build.sbt
+++ b/sbt/src/sbt-test/actions/aggregate/changes/build.sbt
@@ -1,5 +1,5 @@
 lazy val root = (project in file(".")).
-  aggregateSeq((if(file("aggregate").exists) Seq(sub: sbt.ProjectReference) else Nil))
+  aggregate((if(file("aggregate").exists) Seq(sub: sbt.ProjectReference) else Nil): _*)
 
 lazy val sub = (project in file("sub")).
   aggregate(sub2)
diff --git a/sbt/src/sbt-test/actions/aggregate/project/Marker.scala b/sbt/src/sbt-test/actions/aggregate/project/Marker.scala
index 72f47b8fa..ad1697df4 100644
--- a/sbt/src/sbt-test/actions/aggregate/project/Marker.scala
+++ b/sbt/src/sbt-test/actions/aggregate/project/Marker.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 import Def.Initialize
 
 object Marker extends AutoPlugin {
@@ -11,7 +11,7 @@ object Marker extends AutoPlugin {
     final def mark(baseKey: SettingKey[File]): Initialize[Task[Unit]] = baseKey map { base =>
       val toMark = base / "ran"
       if(toMark.exists)
-        error("Already ran (" + toMark + " exists)")
+        sys.error("Already ran (" + toMark + " exists)")
       else
         IO touch toMark
     }
diff --git a/sbt/src/sbt-test/actions/clean-files-directory/a.txt b/sbt/src/sbt-test/actions/clean-files-directory/a.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/actions/clean-files-directory/build.sbt b/sbt/src/sbt-test/actions/clean-files-directory/build.sbt
new file mode 100644
index 000000000..24aa7be9b
--- /dev/null
+++ b/sbt/src/sbt-test/actions/clean-files-directory/build.sbt
@@ -0,0 +1,2 @@
+cleanFiles += baseDirectory.value / "foo"
+cleanFiles += baseDirectory.value / "a.txt"
diff --git a/sbt/src/sbt-test/actions/clean-files-directory/foo/bar/baz.txt b/sbt/src/sbt-test/actions/clean-files-directory/foo/bar/baz.txt
new file mode 100644
index 000000000..3f9538666
--- /dev/null
+++ b/sbt/src/sbt-test/actions/clean-files-directory/foo/bar/baz.txt
@@ -0,0 +1 @@
+baz
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/clean-files-directory/test b/sbt/src/sbt-test/actions/clean-files-directory/test
new file mode 100644
index 000000000..e98a3b020
--- /dev/null
+++ b/sbt/src/sbt-test/actions/clean-files-directory/test
@@ -0,0 +1,4 @@
+> clean
+
+$ absent foo/bar/baz.txt
+$ absent a.txt
diff --git a/sbt/src/sbt-test/actions/clean-keep/build.sbt b/sbt/src/sbt-test/actions/clean-keep/build.sbt
index 64de3093b..9c2ae05b6 100644
--- a/sbt/src/sbt-test/actions/clean-keep/build.sbt
+++ b/sbt/src/sbt-test/actions/clean-keep/build.sbt
@@ -1,6 +1,10 @@
+import sbt.nio.file.Glob
+
 cleanKeepFiles ++= Seq(
 	target.value / "keep",
-	target.value / "keepfile",
-	target.value / "keepdir"
+	target.value / "keepfile"
 )
 
+cleanKeepGlobs += target.value.toGlob / "keepdir" / **
+// This is necessary because recursive globs do not include the base directory.
+cleanKeepGlobs += Glob(target.value / "keepdir")
diff --git a/sbt/src/sbt-test/actions/clean-managed/build.sbt b/sbt/src/sbt-test/actions/clean-managed/build.sbt
new file mode 100644
index 000000000..cedf36e1c
--- /dev/null
+++ b/sbt/src/sbt-test/actions/clean-managed/build.sbt
@@ -0,0 +1,9 @@
+import sbt.nio.file.Glob
+
+Compile / sourceGenerators += Def.task {
+  val files = Seq(sourceManaged.value / "foo.txt", sourceManaged.value / "bar.txt")
+  files.foreach(IO.touch(_))
+  files
+}
+
+cleanKeepGlobs += Glob(sourceManaged.value, "bar.txt")
diff --git a/sbt/src/sbt-test/actions/clean-managed/test b/sbt/src/sbt-test/actions/clean-managed/test
new file mode 100644
index 000000000..f6fd6ce8f
--- /dev/null
+++ b/sbt/src/sbt-test/actions/clean-managed/test
@@ -0,0 +1,6 @@
+> compile
+$ exists target/scala-2.12/src_managed/foo.txt target/scala-2.12/src_managed/bar.txt
+
+> clean
+$ absent target/scala-2.12/src_managed/foo.txt
+$ exists target/scala-2.12/src_managed/bar.txt
diff --git a/sbt/src/sbt-test/actions/command-name/build.sbt b/sbt/src/sbt-test/actions/command-name/build.sbt
new file mode 100644
index 000000000..374a7d3cd
--- /dev/null
+++ b/sbt/src/sbt-test/actions/command-name/build.sbt
@@ -0,0 +1,5 @@
+val command = Command.command("noop") { s => s }
+
+TaskKey[Unit]("check") := {
+  assert(command.nameOption == Some("noop"), """command.commandName should be "noop"""")
+}
diff --git a/sbt/src/sbt-test/actions/command-name/test b/sbt/src/sbt-test/actions/command-name/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/actions/command-name/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/actions/command-to-string/build.sbt b/sbt/src/sbt-test/actions/command-to-string/build.sbt
index 00aeb8a65..8dc3e9a93 100644
--- a/sbt/src/sbt-test/actions/command-to-string/build.sbt
+++ b/sbt/src/sbt-test/actions/command-to-string/build.sbt
@@ -1,6 +1,6 @@
 commands += Command.command("noop") { s => s }
 
 TaskKey[Unit]("check") := {
-  assert(commands.value.toString() == "List(SimpleCommand(noop))",
-    s"""commands should display "List(SimpleCommand(noop))" but is ${commands.value}""")
+  assert(commands.value.toString().contains("SimpleCommand(noop)"),
+    s"""commands should contain "SimpleCommand(noop)" in ${commands.value}""")
 }
diff --git a/sbt/src/sbt-test/actions/compile-clean/build.sbt b/sbt/src/sbt-test/actions/compile-clean/build.sbt
new file mode 100644
index 000000000..0b40a6eb6
--- /dev/null
+++ b/sbt/src/sbt-test/actions/compile-clean/build.sbt
@@ -0,0 +1,4 @@
+import sbt.nio.file.Glob
+
+cleanKeepGlobs in Compile +=
+  Glob((classDirectory in Compile in compile).value, "X.class")
diff --git a/sbt/src/sbt-test/actions/compile-clean/src/main/scala/A.scala b/sbt/src/sbt-test/actions/compile-clean/src/main/scala/A.scala
new file mode 100644
index 000000000..6da20a96e
--- /dev/null
+++ b/sbt/src/sbt-test/actions/compile-clean/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+class A {
+  val x: Int = 1
+}
diff --git a/sbt/src/sbt-test/actions/compile-clean/src/main/scala/X.scala b/sbt/src/sbt-test/actions/compile-clean/src/main/scala/X.scala
new file mode 100644
index 000000000..bd84382cd
--- /dev/null
+++ b/sbt/src/sbt-test/actions/compile-clean/src/main/scala/X.scala
@@ -0,0 +1,3 @@
+class X {
+  val y: Int = 0
+}
diff --git a/sbt/src/sbt-test/actions/compile-clean/src/test/scala/B.scala b/sbt/src/sbt-test/actions/compile-clean/src/test/scala/B.scala
new file mode 100644
index 000000000..4e79fe7a2
--- /dev/null
+++ b/sbt/src/sbt-test/actions/compile-clean/src/test/scala/B.scala
@@ -0,0 +1,3 @@
+class B {
+  val x: Int = 2
+}
diff --git a/sbt/src/sbt-test/actions/compile-clean/test b/sbt/src/sbt-test/actions/compile-clean/test
new file mode 100644
index 000000000..2e805ffd0
--- /dev/null
+++ b/sbt/src/sbt-test/actions/compile-clean/test
@@ -0,0 +1,22 @@
+$ touch target/cant-touch-this
+
+> Test/compile
+$ exists target/scala-2.12/classes/A.class
+$ exists target/scala-2.12/test-classes/B.class
+
+> Test/clean
+$ exists target/cant-touch-this
+# it should clean only compile classes
+$ exists target/scala-2.12/classes/A.class
+$ exists target/scala-2.12/classes/X.class
+$ absent target/scala-2.12/test-classes/B.class
+
+# compiling everything again, but now cleaning only compile classes
+> Test/compile
+> Compile/clean
+$ exists target/cant-touch-this
+# it should clean only compile classes
+$ absent target/scala-2.12/classes/A.class
+$ exists target/scala-2.12/test-classes/B.class
+# and X has to be kept, because of the cleanKeepFiles override
+$ exists target/scala-2.12/classes/X.class
diff --git a/sbt/src/sbt-test/actions/compile-time-only/changes/A1.scala b/sbt/src/sbt-test/actions/compile-time-only/changes/A1.scala
index d83a42865..0975dfda7 100644
--- a/sbt/src/sbt-test/actions/compile-time-only/changes/A1.scala
+++ b/sbt/src/sbt-test/actions/compile-time-only/changes/A1.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 import Def.Initialize
 import complete.{DefaultParsers, Parser}
 
diff --git a/sbt/src/sbt-test/actions/compile-time-only/changes/A3.scala b/sbt/src/sbt-test/actions/compile-time-only/changes/A3.scala
index 8a4a3a849..83a45ead8 100644
--- a/sbt/src/sbt-test/actions/compile-time-only/changes/A3.scala
+++ b/sbt/src/sbt-test/actions/compile-time-only/changes/A3.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 import Def.Initialize
 import complete.{DefaultParsers, Parser}
 
diff --git a/sbt/src/sbt-test/actions/completions/build.sbt b/sbt/src/sbt-test/actions/completions/build.sbt
new file mode 100644
index 000000000..072ab22e7
--- /dev/null
+++ b/sbt/src/sbt-test/actions/completions/build.sbt
@@ -0,0 +1,29 @@
+import complete.{ Completion, Completions, DefaultParsers, Parser }
+import DefaultParsers._
+import Command.applyEffect
+import CommandUtil._
+
+lazy val root = (project in file(".")).
+  enablePlugins(FooPlugin).
+  settings(
+    commands += checkCompletionsCommand
+  )
+
+// This checks the tab completion lists build-level keys
+def checkCompletionsCommand = Command.make("checkCompletions")(completionsParser)
+def completionsParser(state: State) =
+  {
+    val notQuoted = (NotQuoted ~ any.*) map { case (nq, s) => (nq +: s).mkString }
+    val quotedOrUnquotedSingleArgument = Space ~> (StringVerbatim | StringEscapable | notQuoted)
+    applyEffect(token(quotedOrUnquotedSingleArgument ?? "" examples ("", " ")))(runCompletions(state))
+  }
+def runCompletions(state: State)(input: String): State = {
+  val xs = Parser.completions(state.combinedParser, input, 9).get map {
+    c => if (c.isEmpty) input else input + c.append
+  } map { c =>
+    c.replaceAll("\n", " ")
+  }
+  println(xs)
+  assert(xs == Set("myTask"))
+  state
+}
diff --git a/sbt/src/sbt-test/actions/completions/project/FooPlugin.scala b/sbt/src/sbt-test/actions/completions/project/FooPlugin.scala
new file mode 100644
index 000000000..4bef386d9
--- /dev/null
+++ b/sbt/src/sbt-test/actions/completions/project/FooPlugin.scala
@@ -0,0 +1,14 @@
+import sbt._
+
+object FooPlugin extends AutoPlugin {
+  override def trigger = noTrigger
+  object autoImport {
+    val myTask = taskKey[Unit]("My task")
+  }
+
+  import autoImport._
+
+  override def buildSettings = super.buildSettings ++ Seq(
+    myTask := println("Called my task")
+  )
+}
diff --git a/sbt/src/sbt-test/actions/completions/test b/sbt/src/sbt-test/actions/completions/test
new file mode 100644
index 000000000..942db912e
--- /dev/null
+++ b/sbt/src/sbt-test/actions/completions/test
@@ -0,0 +1 @@
+> checkCompletions my
diff --git a/sbt/src/sbt-test/actions/conditional/build.sbt b/sbt/src/sbt-test/actions/conditional/build.sbt
new file mode 100644
index 000000000..02077559b
--- /dev/null
+++ b/sbt/src/sbt-test/actions/conditional/build.sbt
@@ -0,0 +1,54 @@
+val condition = taskKey[Boolean]("")
+val number = settingKey[Int]("")
+val trueAction = taskKey[Unit]("")
+val falseAction = taskKey[Unit]("")
+val negAction = taskKey[Unit]("")
+val zeroAction = taskKey[Unit]("")
+val posAction = taskKey[Unit]("")
+val foo = taskKey[Unit]("")
+val bar = taskKey[Unit]("")
+val output = settingKey[File]("")
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "conditional",
+    output := baseDirectory.value / "output.txt",
+    condition := true,
+    number := -1,
+
+    // automatic conversion to Def.ifS
+    bar := {
+      if (number.value < 0) negAction.value
+      else if (number.value == 0) zeroAction.value
+      else posAction.value
+    },
+
+    // explicit call to Def.taskIf
+    foo := (Def.taskIf {
+      if (condition.value) trueAction.value
+      else falseAction.value
+    }).value,
+
+    trueAction := { IO.write(output.value, s"true\n", append = true) },
+    falseAction := { IO.write(output.value, s"false\n", append = true) },
+    negAction := { IO.write(output.value, s"neg\n", append = true) },
+    zeroAction := { IO.write(output.value, s"zero\n", append = true) },
+    posAction := { IO.write(output.value, s"pos\n", append = true) },
+
+    TaskKey[Unit]("checkTrue") := checkLines("true"),
+    TaskKey[Unit]("checkFalse") := checkLines("false"),
+    TaskKey[Unit]("checkNeg") := checkLines("neg"),
+    TaskKey[Unit]("checkZero") := checkLines("zero"),
+
+    // https://github.com/sbt/sbt/issues/5625
+    javacOptions ++= (
+      if (true) Seq.empty
+      else Seq("--release", "8")
+    ),
+  )
+
+def checkLines(content: String) = Def.task {
+  val lines = IO.read(output.value).linesIterator.toList
+  assert(lines == List("true"), s"$content was expected but found: $lines")
+  ()
+}
diff --git a/sbt/src/sbt-test/actions/conditional/test b/sbt/src/sbt-test/actions/conditional/test
new file mode 100644
index 000000000..ca5845809
--- /dev/null
+++ b/sbt/src/sbt-test/actions/conditional/test
@@ -0,0 +1,16 @@
+> foo
+> checkTrue
+
+$ delete output.txt
+> bar
+> checkNeg
+
+$ delete output.txt
+> set condition := false
+> foo
+> checkFalse
+
+$ delete output.txt
+> set number := 0
+> bar
+> checkZero
diff --git a/sbt/src/sbt-test/actions/cross-advanced/build.sbt b/sbt/src/sbt-test/actions/cross-advanced/build.sbt
new file mode 100644
index 000000000..0076195d7
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-advanced/build.sbt
@@ -0,0 +1,59 @@
+lazy val check = taskKey[Unit]("")
+lazy val compile2 = taskKey[Unit]("")
+
+lazy val root = (project in file("."))
+  .aggregate(foo, bar, client)
+  .settings(
+    crossScalaVersions := Nil,
+    addCommandAlias("build", "compile2"),
+  )
+
+lazy val foo = project
+  .settings(
+    crossScalaVersions := Seq("2.12.13", "2.13.1"),
+    libraryDependencies += "org.scalatest" %% "scalatest" % "3.1.0",
+
+    check := {
+      // This tests that +check will respect bar's crossScalaVersions and not switch
+      val x = (LocalProject("bar") / scalaVersion).value
+      assert(x == "2.12.13", s"$x == 2.12.12")
+      (Compile / compile).value
+    },
+    (Test / testOnly) := {
+      // This tests that +testOnly will respect bar's crossScalaVersions and not switch
+      val x = (LocalProject("bar") / scalaVersion).value
+      assert(x == "2.12.13", s"$x == 2.12.12")
+      val _ = (Test / testOnly).evaluated
+    },
+    compile2 := {
+      // This tests that +build will ignore bar's crossScalaVersions and use root's like sbt 0.13
+      val x = (LocalProject("bar") / scalaVersion).value
+      assert(x == scalaVersion.value, s"$x == ${scalaVersion.value}")
+      (Compile / compile).value
+    },
+  )
+
+lazy val bar = project
+  .settings(
+    crossScalaVersions := Seq("2.12.13"),
+    check := (Compile / compile).value,
+    compile2 := (Compile / compile).value,
+  )
+
+lazy val baz = project
+  .settings(
+    crossScalaVersions := Seq("2.13.1"),
+    check := {
+      // This tests that +baz/check will respect bar's crossScalaVersions and not switch
+      val x = (LocalProject("bar") / scalaVersion).value
+      assert(x == "2.12.13", s"$x == 2.12.13")
+      (Compile / compile).value
+    },
+  )
+
+lazy val client = project
+  .settings(
+    crossScalaVersions := Seq("2.12.13", "2.13.1"),
+    check := (Compile / compile).value,
+    compile2 := (Compile / compile).value,
+  )
diff --git a/sbt/src/sbt-test/actions/cross-advanced/foo/src/test/scala/foo/FooSpec.scala b/sbt/src/sbt-test/actions/cross-advanced/foo/src/test/scala/foo/FooSpec.scala
new file mode 100644
index 000000000..87c315f92
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-advanced/foo/src/test/scala/foo/FooSpec.scala
@@ -0,0 +1,9 @@
+package foo
+
+import org.scalatest.FlatSpec
+
+class FooSpec extends FlatSpec {
+  "foo" should "bar" in {
+    assert(true)
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/cross-advanced/test b/sbt/src/sbt-test/actions/cross-advanced/test
new file mode 100644
index 000000000..9aabd48d6
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-advanced/test
@@ -0,0 +1,27 @@
+> + clean
+
+## verbose
+> + -v compile
+
+## test scoped task
+## this should not force any Scala version changes to other subprojects
+> + baz/check
+
+## test input task
+> + foo / testOnly foo.FooSpec
+> + testOnly foo.FooSpec
+
+## test + with task in multi-project with different Scala versions
+> + check
+
+## test + with command or alias
+> clean
+## for command cross building you do need crossScalaVerions on root
+> set root/crossScalaVersions := Seq("2.12.13", "2.13.1")
+> + build
+$ exists foo/target/scala-2.12
+$ exists foo/target/scala-2.13
+$ exists bar/target/scala-2.12
+$ exists bar/target/scala-2.13
+$ exists client/target/scala-2.12
+$ exists client/target/scala-2.13
diff --git a/sbt/src/sbt-test/actions/cross-incremental/build.sbt b/sbt/src/sbt-test/actions/cross-incremental/build.sbt
new file mode 100644
index 000000000..b8ff210c9
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-incremental/build.sbt
@@ -0,0 +1,22 @@
+scalaVersion := "2.12.12"
+crossScalaVersions := List("2.12.12", "2.13.0")
+
+val setLastModified = taskKey[Unit]("Sets the last modified time for classfiles")
+setLastModified := {
+  val versions = crossScalaVersions.value
+  versions.map(_.split('.').take(2).mkString("scala-", ".", "")).foreach { v =>
+    val f = target.value / v / "classes" / "A.class"
+    Stamps.value.put(f, IO.getModifiedTimeOrZero(f))
+  }
+}
+
+val checkLastModified = taskKey[Unit]("Checks the last modified time for classfiles")
+checkLastModified := {
+  val versions = crossScalaVersions.value
+  versions.map(_.split('.').take(2).mkString("scala-", ".", "")).foreach { v =>
+    val classFile = target.value / v / "classes" / "A.class"
+    val actual = IO.getModifiedTimeOrZero(classFile)
+    val previous = Stamps.value.get(classFile)
+    assert(actual == previous, s"$actual did not equal $previous for $classFile")
+  }
+}
diff --git a/sbt/src/sbt-test/actions/cross-incremental/project/src/main/scala/Stamps.scala b/sbt/src/sbt-test/actions/cross-incremental/project/src/main/scala/Stamps.scala
new file mode 100644
index 000000000..e39d1a4fb
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-incremental/project/src/main/scala/Stamps.scala
@@ -0,0 +1,3 @@
+object Stamps {
+  val value = new java.util.HashMap[java.io.File, Long]
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/cross-incremental/src/main/scala/A.scala b/sbt/src/sbt-test/actions/cross-incremental/src/main/scala/A.scala
new file mode 100644
index 000000000..3c8bfdd75
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-incremental/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+object A {
+  def a = 1
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/cross-incremental/test b/sbt/src/sbt-test/actions/cross-incremental/test
new file mode 100644
index 000000000..036f3dca0
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-incremental/test
@@ -0,0 +1,7 @@
+> +compile
+
+> setLastModified
+
+> +compile
+
+> checkLastModified
diff --git a/sbt/src/sbt-test/actions/cross-multi-parser/build.sbt b/sbt/src/sbt-test/actions/cross-multi-parser/build.sbt
new file mode 100644
index 000000000..7fb4676d4
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-multi-parser/build.sbt
@@ -0,0 +1 @@
+crossScalaVersions := Seq[String]("2.11.12", "2.12.12")
diff --git a/sbt/src/sbt-test/actions/cross-multi-parser/src/main/scala/cross/Build.scala b/sbt/src/sbt-test/actions/cross-multi-parser/src/main/scala/cross/Build.scala
new file mode 100644
index 000000000..e6dcf2377
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-multi-parser/src/main/scala/cross/Build.scala
@@ -0,0 +1,3 @@
+package cross
+
+object Build
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/cross-multi-parser/test b/sbt/src/sbt-test/actions/cross-multi-parser/test
new file mode 100644
index 000000000..e731a77d1
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-multi-parser/test
@@ -0,0 +1,5 @@
+> ++2.11.12; compile
+
+> ++ 2.12.12  ; compile;
+
+> ++ 2.12.12 ; compile
diff --git a/sbt/src/sbt-test/actions/cross-multiproject/build.sbt b/sbt/src/sbt-test/actions/cross-multiproject/build.sbt
index 6414c5417..2dd090dad 100644
--- a/sbt/src/sbt-test/actions/cross-multiproject/build.sbt
+++ b/sbt/src/sbt-test/actions/cross-multiproject/build.sbt
@@ -1,18 +1,30 @@
+lazy val scala212 = "2.12.12"
+// keep this at M5 to test full version
+lazy val scala213 = "2.13.1"
 
-lazy val rootProj = (project in file(".")).
-  aggregate(libProj, fooPlugin)
+ThisBuild / crossScalaVersions := Seq(scala212, scala213)
+ThisBuild / scalaVersion       := scala212
 
-lazy val libProj = (project in file("lib")).
-  settings(
-    name := "foo-lib",
-    scalaVersion := "2.11.8",
-    crossScalaVersions := Seq("2.11.8", "2.10.4")
+lazy val rootProj = (project in file("."))
+  .aggregate(libProj, fooPlugin)
+  .settings(
+    crossScalaVersions := Nil,
+    addCommandAlias("build", "compile")
   )
 
-lazy val fooPlugin =(project in file("sbt-foo")).
-  settings(
+lazy val libProj = (project in file("lib"))
+  .settings(
+    name := "foo-lib"
+  )
+
+lazy val fooPlugin = (project in file("sbt-foo"))
+  .enablePlugins(SbtPlugin)
+  .settings(
     name := "sbt-foo",
-    sbtPlugin := true,
-    scalaVersion := "2.10.4",
-    crossScalaVersions := Seq("2.10.4")
+    crossScalaVersions := Seq(scala212)
+  )
+
+lazy val extrasProj = (project in file("extras"))
+  .settings(
+    name := "foo-extras",
   )
diff --git a/sbt/src/sbt-test/actions/cross-multiproject/test b/sbt/src/sbt-test/actions/cross-multiproject/test
index 6c4f8282c..68b8383d5 100644
--- a/sbt/src/sbt-test/actions/cross-multiproject/test
+++ b/sbt/src/sbt-test/actions/cross-multiproject/test
@@ -1,46 +1,43 @@
 > + compile
-
-$ exists lib/target/scala-2.11
-$ exists lib/target/scala-2.10
-$ exists sbt-foo/target/scala-2.10
--$ exists sbt-foo/target/scala-2.11
+$ exists lib/target/scala-2.12
+$ exists lib/target/scala-2.13
+$ exists sbt-foo/target/scala-2.12
+-$ exists sbt-foo/target/scala-2.13
 
 > clean
 > + libProj/compile
+$ exists lib/target/scala-2.12
+$ exists lib/target/scala-2.13
+-$ exists sbt-foo/target/scala-2.12
+-$ exists sbt-foo/target/scala-2.13
 
-$ exists lib/target/scala-2.11
-$ exists lib/target/scala-2.10
--$ exists sbt-foo/target/scala-2.10
--$ exists sbt-foo/target/scala-2.11
-
+# test safe switching
 > clean
-> ++ 2.11.1 compile
+> ++ 2.12.12 -v compile
+$ exists lib/target/scala-2.12
+-$ exists lib/target/scala-2.13
+$ exists sbt-foo/target/scala-2.12
+-$ exists sbt-foo/target/scala-2.13
 
-$ exists lib/target/scala-2.11
--$ exists lib/target/scala-2.10
-$ exists sbt-foo/target/scala-2.10
--$ exists sbt-foo/target/scala-2.11
+# Test legacy cross build with command support
+# > clean
+# > + build
+# $ exists lib/target/scala-2.12
+# $ exists lib/target/scala-2.13
+# $ exists sbt-foo/target/scala-2.12
+# -$ exists sbt-foo/target/scala-2.13
 
+# Test ++ leaves crossScalaVersions unchanged
 > clean
-> ++ 2.10.4 compile
-
--$ exists lib/target/scala-2.11
-$ exists lib/target/scala-2.10
-$ exists sbt-foo/target/scala-2.10
--$ exists sbt-foo/target/scala-2.11
+> ++2.12.12
+> +extrasProj/compile
+$ exists extras/target/scala-2.13
+$ exists extras/target/scala-2.12
 
+# test safe switching
 > clean
-> ++ 2.11.5 compile
-
-$ exists lib/target/scala-2.11
--$ exists lib/target/scala-2.10
-$ exists sbt-foo/target/scala-2.10
--$ exists sbt-foo/target/scala-2.11
-
-> clean
-> ++ 2.11.5! compile
-
-$ exists lib/target/scala-2.11
--$ exists lib/target/scala-2.10
--$ exists sbt-foo/target/scala-2.10
-$ exists sbt-foo/target/scala-2.11
+> ++ 2.13.1 -v compile
+$ exists lib/target/scala-2.13
+-$ exists lib/target/scala-2.12
+# -$ exists sbt-foo/target/scala-2.12
+-$ exists sbt-foo/target/scala-2.13
diff --git a/sbt/src/sbt-test/actions/cross-strict-aggregation/build.sbt b/sbt/src/sbt-test/actions/cross-strict-aggregation/build.sbt
new file mode 100644
index 000000000..b7cb3b5c2
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-strict-aggregation/build.sbt
@@ -0,0 +1,20 @@
+lazy val scala212 = "2.12.12"
+lazy val scala213 = "2.13.1"
+
+ThisBuild / scalaVersion := scala212
+
+lazy val root = (project in file("."))
+  .aggregate(core, module)
+  .settings(
+    crossScalaVersions := Nil
+  )
+
+lazy val core = (project in file("core"))
+  .settings(
+    crossScalaVersions := Seq(scala212, scala213))
+
+lazy val module = (project in file("module"))
+  .dependsOn(core)
+  .settings(
+    crossScalaVersions := Seq(scala212)
+  )
diff --git a/sbt/src/sbt-test/actions/cross-strict-aggregation/core/src/main/scala-2/A.scala b/sbt/src/sbt-test/actions/cross-strict-aggregation/core/src/main/scala-2/A.scala
new file mode 100644
index 000000000..6c542aa30
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-strict-aggregation/core/src/main/scala-2/A.scala
@@ -0,0 +1,5 @@
+package foo
+
+object Foo {
+
+}
diff --git a/sbt/src/sbt-test/actions/cross-strict-aggregation/module/B.scala b/sbt/src/sbt-test/actions/cross-strict-aggregation/module/B.scala
new file mode 100644
index 000000000..d262f7e5d
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-strict-aggregation/module/B.scala
@@ -0,0 +1,5 @@
+package foo.module
+
+object FooModule {
+
+}
diff --git a/sbt/src/sbt-test/actions/cross-strict-aggregation/test b/sbt/src/sbt-test/actions/cross-strict-aggregation/test
new file mode 100644
index 000000000..8767e4e22
--- /dev/null
+++ b/sbt/src/sbt-test/actions/cross-strict-aggregation/test
@@ -0,0 +1,7 @@
+-> ++2.12.0-magic
+
+> ++2.13.1 compile
+
+$ exists core/target/scala-2.13
+-$ exists module/target/scala-2.13
+-$ exists module/target/scala-2.12
diff --git a/sbt/src/sbt-test/actions/cross/build.sbt b/sbt/src/sbt-test/actions/cross/build.sbt
index f5c3dc75f..5fe7a87aa 100644
--- a/sbt/src/sbt-test/actions/cross/build.sbt
+++ b/sbt/src/sbt-test/actions/cross/build.sbt
@@ -1,20 +1,24 @@
-scalaVersion in ThisBuild := "2.7.7"
+ThisBuild / scalaVersion := "2.11.12"
 
-scalaVersion := "2.9.1"
+lazy val root = (project in file("."))
+  .settings(
+    scalaVersion := "2.12.12",
 
-scalaVersion in update := {
-  scalaVersion.value match {
-    case "2.9.1" => "2.9.0-1"
-    case "2.8.2" => "2.8.1"
-    case x => x
-  }
-}
+    update / scalaVersion := {
+      scalaVersion.value match {
+        case "2.12.12" => "2.12.10"
+        case "2.11.12" => "2.11.11"
+        case x         => x
+      }
+    },
 
-InputKey[Unit]("check") := (inputTask { argsT =>
-  (argsT, scalaVersion in ThisBuild, scalaVersion, scalaVersion in update) map { (args, svTB, svP, svU) =>
-    def check(label: String, i: Int, actual: String) = assert(args(i) == actual, "Expected " + label + "='" + args(i) + "' got '" + actual + "'")
-    check("scalaVersion in ThisBuild", 0, svTB)
-    check("scalaVersion", 1, svP)
-    check("scalaVersion in update", 2, svU)
-  }
-}).evaluated
+    InputKey[Unit]("check") := {
+      val args = Def.spaceDelimited().parsed
+      def checkV(label: String, i: Int, actual: String) =
+        assert(args(i) == actual, s"Expected $label='${args(i)}' got '$actual'")
+
+      checkV("ThisBuild / scalaVersion", 0, (ThisBuild / scalaVersion).value)
+      checkV("scalaVersion", 1, scalaVersion.value)
+      checkV("update / scalaVersion", 2, (update / scalaVersion).value)
+    }
+  )
diff --git a/sbt/src/sbt-test/actions/cross/test b/sbt/src/sbt-test/actions/cross/test
index 0ea962b97..faed188fa 100644
--- a/sbt/src/sbt-test/actions/cross/test
+++ b/sbt/src/sbt-test/actions/cross/test
@@ -1,8 +1,11 @@
-> check 2.7.7 2.9.1 2.9.0-1
-> ++ 2.8.2!
-> check 2.8.2 2.8.2 2.8.1
-> ++ 2.10.4!
+> check 2.11.12 2.12.12 2.12.10
+
+> ++ 2.11.12!
+> check 2.11.12 2.11.12 2.11.11
+
+> ++ 2.13.1!
 > set resolvers ++= Nil
-> check 2.10.4 2.10.4 2.10.4
+> check 2.13.1 2.13.1 2.13.1
+
 > session clear-all
-> check 2.7.7 2.9.1 2.9.0-1
\ No newline at end of file
+> check 2.11.12 2.12.12 2.12.10
diff --git a/sbt/src/sbt-test/actions/depends-on/build.sbt b/sbt/src/sbt-test/actions/depends-on/build.sbt
index c20f79671..8a319ce52 100644
--- a/sbt/src/sbt-test/actions/depends-on/build.sbt
+++ b/sbt/src/sbt-test/actions/depends-on/build.sbt
@@ -14,7 +14,7 @@ lazy val d = taskKey[Unit]("")
 
 lazy val input = (project in file("input")).
   settings(
-    f := (inputTask { _ map { args => if (args(0) == "succeed") () else sys.error("fail") } }).evaluated,
+    f := (if (Def.spaceDelimited().parsed.head == "succeed") () else sys.error("fail")),
     j := sys.error("j"),
     g := (f dependsOn(j)).evaluated,
     h := (f map { _ => IO.touch(file("h")) }).evaluated
diff --git a/sbt/src/sbt-test/actions/depends-on/test b/sbt/src/sbt-test/actions/depends-on/test
index 7c474b5fc..d893d7973 100644
--- a/sbt/src/sbt-test/actions/depends-on/test
+++ b/sbt/src/sbt-test/actions/depends-on/test
@@ -1,11 +1,13 @@
 -> a
 -> b
 -> c
+-> d
 
 $ touch succeed
 > a
 > b
 > c
+> d
 
 > project input
 -> j
@@ -18,4 +20,4 @@ $ absent h
 > set traceLevel in ThisBuild := 100
 > set logLevel in ThisBuild := Level.Debug
 > h succeed
-$ exists h
\ No newline at end of file
+$ exists h
diff --git a/sbt/src/sbt-test/actions/doc-file-options/build.sbt b/sbt/src/sbt-test/actions/doc-file-options/build.sbt
index be9255579..2c90c5429 100644
--- a/sbt/src/sbt-test/actions/doc-file-options/build.sbt
+++ b/sbt/src/sbt-test/actions/doc-file-options/build.sbt
@@ -2,15 +2,16 @@ val newContents = "bbbbbbbbb"
 
 val rootContentFile = "root.txt"
 
-scalaVersion := "2.10.2"
+ThisBuild / scalaVersion := "2.12.12"
 
-scalacOptions in (Compile, doc) := Seq("-doc-root-content", rootContentFile)
-
-TaskKey[Unit]("changeRootContent") := {
-	IO.write(file(rootContentFile), newContents)
-}
-
-TaskKey[Unit]("check") := {
-	val packageHtml = (target in Compile in doc).value / "package.html"
-	assert(IO.read(packageHtml).contains(newContents), s"does not contains ${newContents} in ${packageHtml}" )
-}
+lazy val root = (project in file("."))
+  .settings(
+    Compile / doc / scalacOptions := Seq("-doc-root-content", rootContentFile),
+    TaskKey[Unit]("changeRootContent") := {
+      IO.write(file(rootContentFile), newContents)
+    },
+    TaskKey[Unit]("check") := {
+      val packageHtml = (Compile / doc / target).value / "index.html"
+      assert(IO.read(packageHtml).contains(newContents), s"does not contains ${newContents} in ${packageHtml}" )
+    }
+  )
diff --git a/sbt/src/sbt-test/actions/doc-scala-instance/a/A.scala b/sbt/src/sbt-test/actions/doc-scala-instance/a/A.scala
deleted file mode 100644
index e89cff328..000000000
--- a/sbt/src/sbt-test/actions/doc-scala-instance/a/A.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-class A {
-  def x = 3
-}
-class B
-object B {
-	implicit def bToA(b: B): A = new A
-}
diff --git a/sbt/src/sbt-test/actions/doc-scala-instance/build.sbt b/sbt/src/sbt-test/actions/doc-scala-instance/build.sbt
deleted file mode 100644
index fe9da4b6d..000000000
--- a/sbt/src/sbt-test/actions/doc-scala-instance/build.sbt
+++ /dev/null
@@ -1,10 +0,0 @@
-lazy val a = project.settings(
-	scalaVersion := "2.9.2",
-	scalaInstance in (Compile,doc) := (scalaInstance in b).value,
-	// 2.10.1-only, so this will only succeed if `doc` recognizes the more specific scalaInstance scoped to `doc`
-	scalacOptions in (Compile,doc) += "-implicits"
-)
-
-lazy val b = project.settings(
-	scalaVersion := "2.10.6"
-)
diff --git a/sbt/src/sbt-test/actions/doc-scala-instance/test b/sbt/src/sbt-test/actions/doc-scala-instance/test
deleted file mode 100644
index 285de2cc4..000000000
--- a/sbt/src/sbt-test/actions/doc-scala-instance/test
+++ /dev/null
@@ -1 +0,0 @@
-> a/doc
diff --git a/sbt/src/sbt-test/actions/doc-scala3/build.sbt b/sbt/src/sbt-test/actions/doc-scala3/build.sbt
new file mode 100644
index 000000000..583a736e0
--- /dev/null
+++ b/sbt/src/sbt-test/actions/doc-scala3/build.sbt
@@ -0,0 +1,11 @@
+lazy val m3 = (project in file("m3"))
+  .settings(
+    scalaVersion := "3.0.0-M3",
+    resolvers += Resolver.JCenterRepository
+  )
+
+lazy val rc1 = (project in file("rc1"))
+  .settings(
+    scalaVersion := "3.0.0-RC1"
+  )
+
diff --git a/sbt/src/sbt-test/actions/doc-scala3/m3/src/main/scala/foo/A.scala b/sbt/src/sbt-test/actions/doc-scala3/m3/src/main/scala/foo/A.scala
new file mode 100644
index 000000000..c4496c701
--- /dev/null
+++ b/sbt/src/sbt-test/actions/doc-scala3/m3/src/main/scala/foo/A.scala
@@ -0,0 +1,10 @@
+package foo
+
+final val foo="Foo"
+
+object A:
+  /**
+   * @param i An argument
+   */
+  def x(i:Int)=3
+
diff --git a/sbt/src/sbt-test/actions/doc-scala3/rc1/src/main/scala/foo/A.scala b/sbt/src/sbt-test/actions/doc-scala3/rc1/src/main/scala/foo/A.scala
new file mode 100644
index 000000000..c4496c701
--- /dev/null
+++ b/sbt/src/sbt-test/actions/doc-scala3/rc1/src/main/scala/foo/A.scala
@@ -0,0 +1,10 @@
+package foo
+
+final val foo="Foo"
+
+object A:
+  /**
+   * @param i An argument
+   */
+  def x(i:Int)=3
+
diff --git a/sbt/src/sbt-test/actions/doc-scala3/test b/sbt/src/sbt-test/actions/doc-scala3/test
new file mode 100644
index 000000000..c13e97789
--- /dev/null
+++ b/sbt/src/sbt-test/actions/doc-scala3/test
@@ -0,0 +1,15 @@
+> rc1 / doc
+
+# there shouldn't be two api/ directories
+# see https://github.com/lampepfl/dotty/issues/11412
+$ exists rc1/target/scala-3.0.0-RC1/api/api/index.html
+$ exists rc1/target/scala-3.0.0-RC1/api/api/foo/A$.html
+$ exists rc1/target/scala-3.0.0-RC1/api/api/foo.html
+
+> m3 / doc
+
+# there shouldn't be two api/ directories
+# see https://github.com/lampepfl/dotty/issues/11412
+$ exists m3/target/scala-3.0.0-M3/api/index.html
+$ exists m3/target/scala-3.0.0-M3/api/api/foo/A$.html
+$ exists m3/target/scala-3.0.0-M3/api/api/foo.html
diff --git a/sbt/src/sbt-test/actions/doc/build.sbt b/sbt/src/sbt-test/actions/doc/build.sbt
new file mode 100644
index 000000000..8f1b96ff9
--- /dev/null
+++ b/sbt/src/sbt-test/actions/doc/build.sbt
@@ -0,0 +1,19 @@
+import complete.{ Parser, Parsers }
+import Parser._
+import Parsers._
+
+lazy val root = (project in file("."))
+  .settings(
+    crossPaths := false,
+    crossScalaVersions := Seq("2.12.12", "2.13.3"),
+    scalaVersion := "2.12.12",
+    Compile / doc / scalacOptions += "-Xfatal-warnings",
+    commands += Command.command("excludeB") { s =>
+      val impl = """val src = (sources in Compile).value; src.filterNot(_.getName.contains("B"))"""
+      s"set sources in (Compile, doc) := { $impl }" :: s
+    },
+    commands += Command.arb(_ => ("setDocExtension": Parser[String]) ~> " " ~> matched(any.*)) { (s, filter: String) =>
+      val impl = s"""val src = (sources in Compile).value; src.filter(_.getName.endsWith("$filter"))"""
+      s"set sources in (Compile, doc) := { $impl }" :: s
+    },
+  )
diff --git a/sbt/src/sbt-test/actions/doc/changes/B.scala b/sbt/src/sbt-test/actions/doc/changes/B.scala
new file mode 100644
index 000000000..1e17e20e9
--- /dev/null
+++ b/sbt/src/sbt-test/actions/doc/changes/B.scala
@@ -0,0 +1,6 @@
+object B {
+	/**
+	* @param i An argument
+	*/
+	def x(i: Int) = 3
+}
diff --git a/sbt/src/sbt-test/actions/doc/test b/sbt/src/sbt-test/actions/doc/test
index dd5ba0ed9..14318f4e5 100644
--- a/sbt/src/sbt-test/actions/doc/test
+++ b/sbt/src/sbt-test/actions/doc/test
@@ -1,37 +1,47 @@
-> 'set crossPaths := false'
-
-> 'set scalacOptions in (Compile, doc) += "-Xfatal-warnings"'
-
 -> doc
 
-> 'set sources in (Compile, doc) := { val src = (sources in Compile).value; src.filterNot(_.getName contains "B") }'
+> excludeB
 
 # hybrid project, only scaladoc run
 > doc
-$ exists "target/api/index.js"
-$ absent "target/api/scala"
-$ absent "target/api/java"
+$ exists target/api/index.js
+$ exists target/api/A$.html
+$ absent target/api/scala
+$ absent target/api/java
 
-> 'set sources in (Compile, doc) := { val src = (sources in (Compile, doc)).value; src.filterNot(_.getName endsWith ".java") }'
+> setDocExtension scala
 
+# The original B.scala fails scaladoc
+$ copy-file changes/B.scala B.scala
 # compile task is superfluous. Since doc task preceded by compile task has been problematic due to scala
 # compiler's way of handling empty classpath. We have it here to test that our workaround works.
-> ; clean ; compile ; doc
+> clean ; compile ; doc
 
 # pure scala project, only scaladoc at top level
-$ exists "target/api/index.js"
-$ absent "target/api/package-list"
-$ absent "target/api/scala"
-$ absent "target/api/java"
+$ exists target/api/index.js
+$ exists target/api/A$.html
+$ exists target/api/B$.html
+$ absent target/api/package-list
+$ absent target/api/scala
+$ absent target/api/java
 
-> 'set sources in (Compile, doc) := { val src = (sources in Compile).value; src.filter(_.getName endsWith ".java") }'
+> setDocExtension java
 
-> ; clean ; doc
+> clean ; doc
 
 # pure java project, only javadoc at top level
-$ exists "target/api/package-list"
-$ absent "target/api/index.js"
+$ exists target/api/index.html
+$ exists target/api/pkg/J.html
+$ absent target/api/index.js
 
-# pending 
-# $ absent "target/api/scala"
-#$ absent "target/api/java"
+> setDocExtension scala
+> ++2.13.3
+> clean
+$ absent target/api/A$.html
+> doc
+$ exists target/api/A$.html
+$ exists target/api/B$.html
+
+# pending
+# $ absent target/api/scala
+# $ absent target/api/java
diff --git a/sbt/src/sbt-test/actions/early-command/test b/sbt/src/sbt-test/actions/early-command/test
index 532cef013..66e241ad4 100644
--- a/sbt/src/sbt-test/actions/early-command/test
+++ b/sbt/src/sbt-test/actions/early-command/test
@@ -1,2 +1,3 @@
 > -error
 > early(error)
+> --error
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/eval-is-safe-and-sound/build.sbt b/sbt/src/sbt-test/actions/eval-is-safe-and-sound/build.sbt
index 9fd0eaaea..12bedf524 100644
--- a/sbt/src/sbt-test/actions/eval-is-safe-and-sound/build.sbt
+++ b/sbt/src/sbt-test/actions/eval-is-safe-and-sound/build.sbt
@@ -9,9 +9,9 @@ lazy val numConfigClasses = taskKey[Int]("counts number of config classes")
 
 lazy val configClassCountFile = settingKey[File]("File where we write the # of config classes")
 
-lazy val saveNumConfigClasses = taskKey[Unit]("Saves the number of config clases")
+lazy val saveNumConfigClasses = taskKey[Unit]("Saves the number of config classes")
 
-lazy val checkNumConfigClasses = taskKey[Unit]("Checks the number of config clases")
+lazy val checkNumConfigClasses = taskKey[Unit]("Checks the number of config classes")
 
 lazy val checkDifferentConfigClasses = taskKey[Unit]("Checks that the number of config classes are different.")
 
diff --git a/sbt/src/sbt-test/actions/eval-is-safe-and-sound/test b/sbt/src/sbt-test/actions/eval-is-safe-and-sound/disabled
similarity index 100%
rename from sbt/src/sbt-test/actions/eval-is-safe-and-sound/test
rename to sbt/src/sbt-test/actions/eval-is-safe-and-sound/disabled
diff --git a/sbt/src/sbt-test/actions/external-doc/build.sbt b/sbt/src/sbt-test/actions/external-doc/build.sbt
index 1d7e24672..fe2d502d8 100644
--- a/sbt/src/sbt-test/actions/external-doc/build.sbt
+++ b/sbt/src/sbt-test/actions/external-doc/build.sbt
@@ -1,3 +1,6 @@
+// https://github.com/coursier/coursier/issues/1123
+ThisBuild / useCoursier := false
+
 Seq(
 	autoAPIMappings in ThisBuild := true,
 	publishArtifact in (ThisBuild, packageDoc) := false,
@@ -21,7 +24,7 @@ val bResolver = Def.setting {
 
 val apiBaseSetting = apiURL := Some(apiBase(name.value))
 def apiBase(projectName: String) = url(s"http://example.org/${projectName}")
-def scalaLibraryBase(v: String) = url(s"http://www.scala-lang.org/api/$v/")
+def scalaLibraryBase(v: String) = url(s"https://www.scala-lang.org/api/$v/")
 def addDep(projectName: String) =
 	libraryDependencies += organization.value %% projectName % version.value
 
@@ -29,12 +32,14 @@ def addDep(projectName: String) =
 val checkApiMappings = taskKey[Unit]("Verifies that the API mappings are collected as expected.")
 
 def expectedMappings = Def.task {
-	val ms = update.value.configuration(Compile.name).get.modules.flatMap { mod => 
+  val version = scalaVersion.value
+  val binVersion = scalaBinaryVersion.value
+	val ms = update.value.configuration(Compile).get.modules.flatMap { mod => 
 		mod.artifacts.flatMap { case (a,f) =>
-			val n = a.name.stripSuffix("_" + scalaBinaryVersion.value)
+			val n = a.name.stripSuffix("_" + binVersion)
 			n match {
 				case "a" | "b" | "c" => (f, apiBase(n)) :: Nil
-				case "scala-library" => (f, scalaLibraryBase(scalaVersion.value)) :: Nil
+				case "scala-library" => (f, scalaLibraryBase(version)) :: Nil
 				case _ => Nil
 			}
 		}
diff --git a/sbt/src/sbt-test/actions/generator/build.sbt b/sbt/src/sbt-test/actions/generator/build.sbt
new file mode 100644
index 000000000..d9139f3a0
--- /dev/null
+++ b/sbt/src/sbt-test/actions/generator/build.sbt
@@ -0,0 +1,14 @@
+val buildInfo = taskKey[Seq[File]]("generates the build info")
+
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file("."))
+  .settings(
+    buildInfo := {
+      val file = sourceManaged.value / "BuildInfo.scala"
+      IO.write(file, "object BuildInfo")
+      file :: Nil
+    },
+    sourceGenerators in Compile += buildInfo,
+    sourceGenerators in Compile += Def.task { Nil }
+  )
diff --git a/sbt/src/sbt-test/actions/generator/test b/sbt/src/sbt-test/actions/generator/test
new file mode 100644
index 000000000..b7ff4b2e4
--- /dev/null
+++ b/sbt/src/sbt-test/actions/generator/test
@@ -0,0 +1,2 @@
+> compile
+$ exists target/scala-2.12/src_managed/BuildInfo.scala
diff --git a/sbt/src/sbt-test/actions/input-task-dyn/Bar.scala b/sbt/src/sbt-test/actions/input-task-dyn/Bar.scala
new file mode 100644
index 000000000..75d1e1195
--- /dev/null
+++ b/sbt/src/sbt-test/actions/input-task-dyn/Bar.scala
@@ -0,0 +1,5 @@
+object Bar {
+  def main(args: Array[String]): Unit = {
+    println("Bar: " + args.toList.toString)
+  }
+}
diff --git a/sbt/src/sbt-test/actions/input-task-dyn/Foo.scala b/sbt/src/sbt-test/actions/input-task-dyn/Foo.scala
new file mode 100644
index 000000000..e7c14d665
--- /dev/null
+++ b/sbt/src/sbt-test/actions/input-task-dyn/Foo.scala
@@ -0,0 +1,5 @@
+object Foo {
+  def main(args: Array[String]): Unit = {
+    println("Foo: " + args.toList.toString)
+  }
+}
diff --git a/sbt/src/sbt-test/actions/input-task-dyn/build.sbt b/sbt/src/sbt-test/actions/input-task-dyn/build.sbt
new file mode 100644
index 000000000..46d9578d5
--- /dev/null
+++ b/sbt/src/sbt-test/actions/input-task-dyn/build.sbt
@@ -0,0 +1,18 @@
+import complete.Parser
+
+// https://www.scala-sbt.org/0.13/docs/Input-Tasks.html
+
+val runFoo = inputKey[Unit]("Runs Foo with passed arguments")
+val check = taskKey[Unit]("")
+
+lazy val root = (project in file(".")).
+  settings(
+    name := "run-test",
+    runFoo := Def.inputTaskDyn {
+        val args = Def.spaceDelimited().parsed
+        (runMain in Compile).toTask(s" Foo " + args.mkString(" "))
+    }.evaluated,
+    check := {
+      val x = runFoo.toTask(" hi ho").value
+    }
+  )
diff --git a/sbt/src/sbt-test/actions/input-task-dyn/test b/sbt/src/sbt-test/actions/input-task-dyn/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/actions/input-task-dyn/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/actions/input-task/build.sbt b/sbt/src/sbt-test/actions/input-task/build.sbt
index ecc533f9b..3d61bdf90 100644
--- a/sbt/src/sbt-test/actions/input-task/build.sbt
+++ b/sbt/src/sbt-test/actions/input-task/build.sbt
@@ -1,6 +1,6 @@
 import complete.Parser
 
-// http://www.scala-sbt.org/0.13/docs/Input-Tasks.html
+// https://www.scala-sbt.org/0.13/docs/Input-Tasks.html
 
 val run2 = inputKey[Unit](
     "Runs the main class twice with different argument lists separated by --")
diff --git a/sbt/src/sbt-test/actions/multi-command/build.sbt b/sbt/src/sbt-test/actions/multi-command/build.sbt
new file mode 100644
index 000000000..e3dba3ba2
--- /dev/null
+++ b/sbt/src/sbt-test/actions/multi-command/build.sbt
@@ -0,0 +1,22 @@
+import Build._
+
+organization := "sbt"
+
+name := "scripted-multi-command-parser"
+
+setStringValue := setStringValueImpl.evaluated
+
+checkStringValue := checkStringValueImpl.evaluated
+
+taskThatFails := {
+  throw new IllegalArgumentException("")
+  ()
+}
+
+checkInput := checkInputImpl.evaluated
+
+val dynamicTask = taskKey[Unit]("dynamic input task")
+
+dynamicTask := { println("not yet et") }
+
+crossScalaVersions := "2.11.12" :: "2.12.12" :: Nil
diff --git a/sbt/src/sbt-test/actions/multi-command/project/Build.scala b/sbt/src/sbt-test/actions/multi-command/project/Build.scala
new file mode 100644
index 000000000..06176933e
--- /dev/null
+++ b/sbt/src/sbt-test/actions/multi-command/project/Build.scala
@@ -0,0 +1,26 @@
+import sbt._
+
+import sbt.internal.util.complete.Parser._
+
+object Build {
+  private[this] var string: String = ""
+  private[this] val stringFile = file("string.txt")
+  val setStringValue = inputKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  val taskThatFails = taskKey[Unit]("this should fail")
+  val checkInput = inputKey[Unit]("this should extract arguments that are semicolon delimited")
+  def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    string = Def.spaceDelimited().parsed.mkString(" ").trim
+    IO.write(stringFile, string)
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val actual = Def.spaceDelimited().parsed.mkString(" ").trim
+    assert(string == actual)
+    assert(IO.read(stringFile) == string)
+  }
+
+  def checkInputImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val actual = (charClass(_ != ';').+ <~ ';'.?).map(_.mkString.trim).+.parsed
+    assert(actual == Seq("foo"))
+  }
+}
diff --git a/sbt/src/sbt-test/actions/multi-command/src/main/scala/Foo.scala b/sbt/src/sbt-test/actions/multi-command/src/main/scala/Foo.scala
new file mode 100644
index 000000000..43c42f145
--- /dev/null
+++ b/sbt/src/sbt-test/actions/multi-command/src/main/scala/Foo.scala
@@ -0,0 +1 @@
+class Foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/multi-command/test b/sbt/src/sbt-test/actions/multi-command/test
new file mode 100644
index 000000000..568d028fb
--- /dev/null
+++ b/sbt/src/sbt-test/actions/multi-command/test
@@ -0,0 +1,40 @@
+> ;set dynamicTask := { println("1");  println("2") }; dynamicTask
+
+-> ; set dynamicTask := { throw new IllegalStateException("fail") }; dynamicTask
+
+> set dynamicTask := { println("1");  println("2") }; dynamicTask
+
+-> set dynamicTask := { throw new IllegalStateException("fail") }; dynamicTask
+
+> ; setStringValue baz
+
+> ; checkStringValue baz
+
+> ; setStringValue foo; setStringValue bar
+
+> checkStringValue bar
+
+> ; setStringValue foo; setStringValue bar; setStringValue baz; checkStringValue baz
+
+> setStringValue foo; setStringValue bar
+
+> checkStringValue bar
+
+> setStringValue foo; setStringValue bar; setStringValue baz
+
+> checkStringValue baz
+
+-> setStringValue foo; taskThatFails; setStringValue bar
+
+> checkStringValue foo
+
+# this fails even though the checkInput parser would parse the input into Seq("foo", "bar")
+-> checkInput foo; bar
+
+> checkInput foo
+
+> compile; checkInput foo
+
+> ++ 2.11.12 compile; setStringValue bar; checkStringValue bar
+
+> ++2.12.12 compile; setStringValue foo; checkStringValue foo
diff --git a/sbt/src/sbt-test/actions/multi-scope/build.sbt b/sbt/src/sbt-test/actions/multi-scope/build.sbt
index 87be113cb..654c75d38 100644
--- a/sbt/src/sbt-test/actions/multi-scope/build.sbt
+++ b/sbt/src/sbt-test/actions/multi-scope/build.sbt
@@ -1,11 +1,12 @@
 lazy val taskX = taskKey[Set[Int]]("numbers")
 lazy val filterX = ScopeFilter( inDependencies(ThisProject, transitive=false, includeRoot=false) )
 
-lazy val filterA: ScopeFilter.ScopeFilter = ScopeFilter( 
+lazy val filterA: ScopeFilter.ScopeFilter = ScopeFilter(
 	inAggregates( LocalProject(e.id) ),
-	inConfigurations(Compile,Test) || inGlobalConfiguration,
-	inTasks(console) || inGlobalTask
+	inConfigurations(Compile,Test) || inZeroConfiguration,
+	inTasks(console) || inZeroTask
 )
+
 lazy val eGlobal = Set(192, 210)
 lazy val cGlobal = Set(123, 57)
 lazy val cCompile = Set(694)
diff --git a/sbt/src/sbt-test/actions/multiple-with-error/test b/sbt/src/sbt-test/actions/multiple-with-error/test
index ff83f1b3d..c35330bc1 100644
--- a/sbt/src/sbt-test/actions/multiple-with-error/test
+++ b/sbt/src/sbt-test/actions/multiple-with-error/test
@@ -1,3 +1,3 @@
 # Issue 732: reload followed by a command that results in an error exits in interactive mode
 -> ;reload;not-a-command
-> help
+> about
diff --git a/sbt/src/sbt-test/actions/package-delete-target/build.sbt b/sbt/src/sbt-test/actions/package-delete-target/build.sbt
new file mode 100644
index 000000000..521d0c6da
--- /dev/null
+++ b/sbt/src/sbt-test/actions/package-delete-target/build.sbt
@@ -0,0 +1,5 @@
+lazy val root = (project in file("."))
+  .settings(
+    name := "delete-target",
+    scalaVersion := "2.12.1"
+  )
diff --git a/sbt/src/sbt-test/actions/package-delete-target/test b/sbt/src/sbt-test/actions/package-delete-target/test
new file mode 100644
index 000000000..7fa1b3ae7
--- /dev/null
+++ b/sbt/src/sbt-test/actions/package-delete-target/test
@@ -0,0 +1,4 @@
+$ mkdir target/scala-2.12/delete-target_2.12-0.1.0-SNAPSHOT.jar
+$ touch target/scala-2.12/delete-target_2.12-0.1.0-SNAPSHOT.jar/hello
+-> package
+$ exists target/scala-2.12/delete-target_2.12-0.1.0-SNAPSHOT.jar/hello
diff --git a/sbt/src/sbt-test/actions/previous-in-input-task/build.sbt b/sbt/src/sbt-test/actions/previous-in-input-task/build.sbt
new file mode 100644
index 000000000..a7e169d7e
--- /dev/null
+++ b/sbt/src/sbt-test/actions/previous-in-input-task/build.sbt
@@ -0,0 +1,10 @@
+import sjsonnew.BasicJsonProtocol._
+
+val cacheTask = taskKey[Int]("task")
+cacheTask := 1
+
+val checkTask = inputKey[Unit]("validate that the correct value is set by cacheTask")
+checkTask := {
+  val expected = Def.spaceDelimited("").parsed.head.toInt
+  assert(cacheTask.previous.getOrElse(0) == expected)
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/previous-in-input-task/test b/sbt/src/sbt-test/actions/previous-in-input-task/test
new file mode 100644
index 000000000..1b7969eea
--- /dev/null
+++ b/sbt/src/sbt-test/actions/previous-in-input-task/test
@@ -0,0 +1,5 @@
+> checkTask 0
+
+> cacheTask
+
+> checkTask 1
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/previous/build.sbt b/sbt/src/sbt-test/actions/previous/build.sbt
index ef4b0d353..95440022d 100644
--- a/sbt/src/sbt-test/actions/previous/build.sbt
+++ b/sbt/src/sbt-test/actions/previous/build.sbt
@@ -1,4 +1,4 @@
-import sbinary.DefaultProtocol._
+import sjsonnew.BasicJsonProtocol._
 
 lazy val a0 = 1
 lazy val b0 = 1
@@ -29,4 +29,4 @@ checkNext := {
 	val actualB = b.value
 	assert(actualA == expectedA, s"Expected 'a' to be $expectedA, got $actualA")
 	assert(actualB == expectedB, s"Expected 'b' to be $expectedB, got $actualB")
-}
\ No newline at end of file
+}
diff --git a/sbt/src/sbt-test/actions/previous/scopes.sbt b/sbt/src/sbt-test/actions/previous/scopes.sbt
index d0ebe7ecf..8062b1df1 100644
--- a/sbt/src/sbt-test/actions/previous/scopes.sbt
+++ b/sbt/src/sbt-test/actions/previous/scopes.sbt
@@ -1,4 +1,4 @@
-import sbinary.DefaultProtocol._
+import sjsonnew.BasicJsonProtocol._
 
 lazy val x = taskKey[Int]("x")
 lazy val y = taskKey[Int]("y")
@@ -44,4 +44,4 @@ checkScopes := {
 	val actualY = (y in subB in Test).value
 	assert(actualX == expectedX, s"Expected 'x' to be $expectedX, got $actualX")
 	assert(actualY == expectedY, s"Expected 'y' to be $expectedY, got $actualY")
-}
\ No newline at end of file
+}
diff --git a/sbt/src/sbt-test/actions/previous/test b/sbt/src/sbt-test/actions/previous/test
index 5975f711e..ebee855a7 100644
--- a/sbt/src/sbt-test/actions/previous/test
+++ b/sbt/src/sbt-test/actions/previous/test
@@ -1,5 +1,3 @@
-> debug
-
 > checkNext 1 2
 > checkNext 2 3
 > checkNext 3 5
diff --git a/sbt/src/sbt-test/actions/promise/build.sbt b/sbt/src/sbt-test/actions/promise/build.sbt
new file mode 100644
index 000000000..977218fb9
--- /dev/null
+++ b/sbt/src/sbt-test/actions/promise/build.sbt
@@ -0,0 +1,40 @@
+val midpoint = taskKey[PromiseWrap[Int]]("")
+val longRunning = taskKey[Unit]("")
+val midTask = taskKey[Unit]("")
+val joinTwo = taskKey[Unit]("")
+val output = settingKey[File]("")
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "promise",
+    output := baseDirectory.value / "output.txt",
+    midpoint := Def.promise[Int],
+    longRunning := {
+      val p = midpoint.value
+      val st = streams.value
+      IO.write(output.value, "start\n", append = true)
+      Thread.sleep(100)
+      p.success(5)
+      Thread.sleep(100)
+      IO.write(output.value, "end\n", append = true)
+    },
+    midTask := {
+      val st = streams.value
+      val x = midpoint.await.value
+      IO.write(output.value, s"$x in the middle\n", append = true)
+    },
+    joinTwo := {
+      val x = longRunning.value
+      val y = midTask.value
+    },
+    TaskKey[Unit]("check") := {
+      val lines = IO.read(output.value).linesIterator.toList
+      assert(lines == List("start", "5 in the middle", "end"))
+      ()
+    },
+    TaskKey[Unit]("check2") := {
+      val lines = IO.read(output.value).linesIterator.toList
+      assert(lines == List("start", "end", "5 in the middle"))
+      ()
+    },
+  )
diff --git a/sbt/src/sbt-test/actions/promise/test b/sbt/src/sbt-test/actions/promise/test
new file mode 100644
index 000000000..24416f93e
--- /dev/null
+++ b/sbt/src/sbt-test/actions/promise/test
@@ -0,0 +1,8 @@
+> joinTwo
+> check
+
+$ delete output.txt
+# check that we won't thread starve
+> set Global / concurrentRestrictions := Seq(Tags.limitAll(1))
+> joinTwo
+> check2
diff --git a/sbt/src/sbt-test/actions/remote-cache-semanticdb/build.sbt b/sbt/src/sbt-test/actions/remote-cache-semanticdb/build.sbt
new file mode 100644
index 000000000..374410229
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache-semanticdb/build.sbt
@@ -0,0 +1,18 @@
+name := "my-project"
+
+scalaVersion := "2.12.12"
+
+semanticdbIncludeInJar := true
+
+semanticdbEnabled := true
+
+pushRemoteCacheTo := Some(
+  MavenCache("local-cache", (ThisBuild / baseDirectory).value / "remote-cache-semanticdb")
+)
+
+Compile / remoteCacheId := "fixed-id"
+Compile / remoteCacheIdCandidates := Seq((Compile / remoteCacheId).value)
+Test / remoteCacheId := "fixed-id"
+Test / remoteCacheIdCandidates := Seq((Test / remoteCacheId).value)
+Compile / pushRemoteCacheConfiguration := (Compile / pushRemoteCacheConfiguration).value.withOverwrite(true)
+Test / pushRemoteCacheConfiguration := (Test / pushRemoteCacheConfiguration).value.withOverwrite(true)
diff --git a/sbt/src/sbt-test/actions/remote-cache-semanticdb/src/main/scala/MyClass.scala b/sbt/src/sbt-test/actions/remote-cache-semanticdb/src/main/scala/MyClass.scala
new file mode 100644
index 000000000..2d9059cdb
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache-semanticdb/src/main/scala/MyClass.scala
@@ -0,0 +1 @@
+object MyClass
diff --git a/sbt/src/sbt-test/actions/remote-cache-semanticdb/src/test/scala/MyTest.scala b/sbt/src/sbt-test/actions/remote-cache-semanticdb/src/test/scala/MyTest.scala
new file mode 100644
index 000000000..9caa86632
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache-semanticdb/src/test/scala/MyTest.scala
@@ -0,0 +1 @@
+object MyTest
diff --git a/sbt/src/sbt-test/actions/remote-cache-semanticdb/test b/sbt/src/sbt-test/actions/remote-cache-semanticdb/test
new file mode 100644
index 000000000..3875dd2ea
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache-semanticdb/test
@@ -0,0 +1,48 @@
+> pushRemoteCache
+
+# Generated sources, compiled classes
+$ exists target/scala-2.12/classes/MyClass.class
+$ exists target/scala-2.12/classes/MyClass$.class
+$ exists target/scala-2.12/classes/META-INF/semanticdb/src/main/scala/MyClass.scala.semanticdb
+$ exists target/scala-2.12/zinc/inc_compile_2.12.zip
+$ exists target/scala-2.12/test-classes/MyTest.class
+$ exists target/scala-2.12/test-classes/MyTest$.class
+$ exists target/scala-2.12/test-classes/META-INF/semanticdb/src/test/scala/MyTest.scala.semanticdb
+$ exists target/scala-2.12/test-zinc/inc_compile_2.12.zip
+
+# Compile
+$ exists remote-cache-semanticdb/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-compile.jar
+$ exists remote-cache-semanticdb/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-compile.jar.md5
+$ exists remote-cache-semanticdb/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-compile.jar.sha1
+
+# Test
+$ exists remote-cache-semanticdb/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-test.jar
+$ exists remote-cache-semanticdb/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-test.jar.md5
+$ exists remote-cache-semanticdb/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-test.jar.sha1
+
+> clean
+
+$ absent target/scala-2.12/classes/MyClass.class
+$ absent target/scala-2.12/classes/MyClass$.class
+$ absent target/scala-2.12/classes/META-INF
+$ absent target/scala-2.12/zinc/inc_compile_2.12.zip
+$ absent target/scala-2.12/test-classes/MyTest.class
+$ absent target/scala-2.12/test-classes/MyTest$.class
+$ absent target/scala-2.12/test-classes/META-INF
+$ absent target/scala-2.12/test-zinc/inc_compile_2.12.zip
+
+> pullRemoteCache
+
+# Files extracted from the cache artifacts
+$ exists target/scala-2.12/classes/MyClass.class
+$ exists target/scala-2.12/classes/MyClass$.class
+$ exists target/scala-2.12/classes/META-INF/semanticdb/src/main/scala/MyClass.scala.semanticdb
+$ exists target/scala-2.12/zinc/inc_compile_2.12.zip
+$ exists target/scala-2.12/test-classes/MyTest.class
+$ exists target/scala-2.12/test-classes/MyTest$.class
+$ exists target/scala-2.12/test-classes/META-INF/semanticdb/src/test/scala/MyTest.scala.semanticdb
+$ exists target/scala-2.12/test-zinc/inc_compile_2.12.zip
+
+# Artifacts can be pushed twice (enabled overriding)
+> pushRemoteCache
+
diff --git a/sbt/src/sbt-test/actions/remote-cache/build.sbt b/sbt/src/sbt-test/actions/remote-cache/build.sbt
new file mode 100644
index 000000000..920bc2e0c
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache/build.sbt
@@ -0,0 +1,95 @@
+import sbt.internal.remotecache.CustomRemoteCacheArtifact
+import sbt.internal.inc.Analysis
+import complete.DefaultParsers._
+
+lazy val CustomArtifact = config("custom-artifact")
+
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
+
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / pushRemoteCacheTo := Some(
+  MavenCache("local-cache", (ThisBuild / baseDirectory).value / "r")
+)
+
+lazy val root = (project in file("."))
+  .configs(CustomArtifact)
+  .settings(
+    name := "my-project",
+
+    customArtifactSettings,
+    pushRemoteCacheConfiguration / remoteCacheArtifacts += (CustomArtifact / packageCache / remoteCacheArtifact).value,
+
+    Compile / pushRemoteCacheConfiguration := (Compile / pushRemoteCacheConfiguration).value.withOverwrite(true),
+    Test / pushRemoteCacheConfiguration := (Test / pushRemoteCacheConfiguration).value.withOverwrite(true),
+
+    Compile / sourceGenerators += Def.task {
+      val extractDirectory = (CustomArtifact / sourceManaged).value
+      val output = extractDirectory / "HelloWorld.scala"
+      IO.write(output, "class HelloWorld")
+      Seq(output)
+    }.taskValue,
+    // bring back fixed-id because JDK 8/11 would be different intentionally
+    Compile / remoteCacheId := "fixed-id",
+    Compile / remoteCacheIdCandidates := Seq((Compile / remoteCacheId).value),
+    Test / remoteCacheId := "fixed-id",
+    Test / remoteCacheIdCandidates := Seq((Test / remoteCacheId).value),
+    CustomArtifact / remoteCacheId := "fixed-id",
+    CustomArtifact / remoteCacheIdCandidates := Seq((CustomArtifact / remoteCacheId).value),
+
+    // test tasks
+    recordPreviousIterations := {
+      val log = streams.value.log
+      CompileState.previousIterations = {
+        val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+        previousAnalysis match {
+          case None =>
+            log.info("No previous analysis detected")
+            0
+          case Some(a: Analysis) => a.compilations.allCompilations.size
+        }
+      }
+    },
+    checkIterations := {
+      val expected: Int = (Space ~> NatBasic).parsed
+      val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+      assert(expected == actual, s"Expected $expected compilations, got $actual")
+    }
+  )
+
+def customArtifactSettings: Seq[Def.Setting[_]] = {
+  val classifier = "custom-artifact"
+
+  def cachedArtifactTask = Def.task {
+    val art = (CustomArtifact / artifact).value
+    val packaged = CustomArtifact / packageCache
+    val extractDirectory = (CustomArtifact / sourceManaged).value
+    CustomRemoteCacheArtifact(art, packaged, extractDirectory, preserveLastModified = false)
+  }
+  inConfig(CustomArtifact)(
+    sbt.internal.RemoteCache.configCacheSettings(cachedArtifactTask) ++
+    Seq(
+      packageOptions := {
+        val n = name.value + "-" + classifier
+        val ver = version.value
+        val orgName = organizationName.value
+
+        List(Package.addSpecManifestAttributes(n, ver, orgName))
+      },
+      sourceManaged := (Compile / target).value / "custom-artifact-gen",
+      mappings := {
+        val sourcesDir = sourceManaged.value
+        val sources = sourcesDir.allPaths.pair(Path.relativeTo(sourcesDir))
+
+        sources
+      },
+      packageConfiguration := Defaults.packageConfigurationTask.value,
+      packageCache := Defaults.packageTask.value,
+      artifact := Artifact(moduleName.value, classifier),
+      packagedArtifact := (artifact.value -> packageCache.value),
+      artifactPath := Defaults.artifactPathSetting(artifact).value,
+      artifactName := Artifact.artifactName
+    )
+  )
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/remote-cache/project/CompileState.scala b/sbt/src/sbt-test/actions/remote-cache/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/actions/remote-cache/src/main/scala/MyClass.scala b/sbt/src/sbt-test/actions/remote-cache/src/main/scala/MyClass.scala
new file mode 100644
index 000000000..7c7f7e635
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache/src/main/scala/MyClass.scala
@@ -0,0 +1 @@
+object MyClass
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/remote-cache/src/test/scala/MyTest.scala b/sbt/src/sbt-test/actions/remote-cache/src/test/scala/MyTest.scala
new file mode 100644
index 000000000..d27811abd
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache/src/test/scala/MyTest.scala
@@ -0,0 +1 @@
+object MyTest
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/remote-cache/test b/sbt/src/sbt-test/actions/remote-cache/test
new file mode 100644
index 000000000..5da745c18
--- /dev/null
+++ b/sbt/src/sbt-test/actions/remote-cache/test
@@ -0,0 +1,56 @@
+> recordPreviousIterations
+> compile
+> pushRemoteCache
+
+# Generated sources, compiled classes
+$ exists target/custom-artifact-gen/HelloWorld.scala
+$ exists target/scala-2.12/classes/HelloWorld.class
+$ exists target/scala-2.12/classes/MyClass.class
+$ exists target/scala-2.12/classes/MyClass$.class
+$ exists target/scala-2.12/zinc/inc_compile_2.12.zip
+$ exists target/scala-2.12/test-classes/MyTest.class
+$ exists target/scala-2.12/test-classes/MyTest$.class
+$ exists target/scala-2.12/test-zinc/inc_compile_2.12.zip
+
+# Compile
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-compile.jar
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-compile.jar.md5
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-compile.jar.sha1
+
+# Test
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-test.jar
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-test.jar.md5
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-cached-test.jar.sha1
+
+# Custom artifact
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-custom-artifact.jar
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-custom-artifact.jar.md5
+$ exists r/my-project/my-project_2.12/0.0.0-fixed-id/my-project_2.12-0.0.0-fixed-id-custom-artifact.jar.sha1
+
+> clean
+
+$ absent target/custom-artifact-gen/HelloWorld.scala
+$ absent target/scala-2.12/classes/HelloWorld.class
+$ absent target/scala-2.12/classes/MyClass.class
+$ absent target/scala-2.12/classes/MyClass$.class
+$ absent target/scala-2.12/zinc/inc_compile_2.12.zip
+$ absent target/scala-2.12/test-classes/MyTest.class
+$ absent target/scala-2.12/test-classes/MyTest$.class
+$ absent target/scala-2.12/test-zinc/inc_compile_2.12.zip
+
+> pullRemoteCache
+
+# Files extracted from the cache artifacts
+$ exists target/custom-artifact-gen/HelloWorld.scala
+$ exists target/scala-2.12/classes/HelloWorld.class
+$ exists target/scala-2.12/classes/MyClass.class
+$ exists target/scala-2.12/classes/MyClass$.class
+$ exists target/scala-2.12/zinc/inc_compile_2.12.zip
+$ exists target/scala-2.12/test-classes/MyTest.class
+$ exists target/scala-2.12/test-classes/MyTest$.class
+$ exists target/scala-2.12/test-zinc/inc_compile_2.12.zip
+
+> checkIterations 1
+
+# Artifacts can be pushed twice (enabled overriding)
+> pushRemoteCache
\ No newline at end of file
diff --git a/sbt/src/sbt-test/actions/run-task/A.scala b/sbt/src/sbt-test/actions/run-task/A.scala
index f12139e7b..f003b3e20 100644
--- a/sbt/src/sbt-test/actions/run-task/A.scala
+++ b/sbt/src/sbt-test/actions/run-task/A.scala
@@ -1,7 +1,6 @@
 object A {
-	def main(args: Array[String]) =
-	{
-		assert(args(0).toInt == args(1).toInt)
-		assert(java.lang.Boolean.getBoolean("sbt.check.forked"))
-	}
+  def main(args: Array[String]) = {
+    assert(args(0).toInt == args(1).toInt)
+    assert(java.lang.Boolean.getBoolean("sbt.check.forked"))
+  }
 }
diff --git a/sbt/src/sbt-test/actions/run-task/build.sbt b/sbt/src/sbt-test/actions/run-task/build.sbt
index 0166f62ed..69fb3e613 100644
--- a/sbt/src/sbt-test/actions/run-task/build.sbt
+++ b/sbt/src/sbt-test/actions/run-task/build.sbt
@@ -1,13 +1,7 @@
-lazy val root = (project in file(".")).
-  settings(
-    myRun,
-    fork in demo := true,
-    javaOptions in demo := "-Dsbt.check.forked=true" :: Nil,
-    myIn
-  )
+val demo = taskKey[Unit]("Demo run task")
+fullRunTask(demo, Compile, "A", "1", "1")
+fork in demo := true
+javaOptions in demo := "-Dsbt.check.forked=true" :: Nil
 
-lazy val demoIn = InputKey[Unit]("demoIn", "Demo run input task", demo)
-lazy val demo = taskKey[Unit]("Demo run task")
-
-def myRun = fullRunTask(demo, Compile, "A", "1", "1")
-def myIn = fullRunInputTask(demoIn, Compile, "A", "1")
+val demoIn = InputKey[Unit]("demoIn", "Demo run input task", demo)
+fullRunInputTask(demoIn, Compile, "A", "1")
diff --git a/sbt/src/sbt-test/actions/set/build.sbt b/sbt/src/sbt-test/actions/set/build.sbt
index 1d4e17374..61949f0a0 100644
--- a/sbt/src/sbt-test/actions/set/build.sbt
+++ b/sbt/src/sbt-test/actions/set/build.sbt
@@ -1,6 +1,6 @@
 
 TaskKey[Unit]("checkName", "") := {
-	assert(name.value == "hello-world", "Name is not hello-worled, failed to set!")
+	assert(name.value == "hello-world", "Name is not hello-world, failed to set!")
 }
 
 val notExistingThing = settingKey[Int]("Something new")
diff --git a/sbt/src/sbt-test/actions/state/build.sbt b/sbt/src/sbt-test/actions/state/build.sbt
index c52644d14..3f3f9fa73 100644
--- a/sbt/src/sbt-test/actions/state/build.sbt
+++ b/sbt/src/sbt-test/actions/state/build.sbt
@@ -2,6 +2,7 @@ import complete.Parser
 import complete.DefaultParsers._
 import sbinary.DefaultProtocol._
 import Def.Initialize
+import sjsonnew.BasicJsonProtocol._
 
 val keep = taskKey[Int]("")
 val persist = taskKey[Int]("")
@@ -26,12 +27,13 @@ lazy val root = (project in file(".")).
 
 def demoState(s: State, i: Int): State = s put (sample, i + 1)
 
-def checkInit: Initialize[InputTask[Unit]] = InputTask( (_: State) => token(Space ~> IntBasic) ~ token(Space ~> IntBasic).?) { key =>
-  (key, updateDemo, state) map { case ((curExpected, prevExpected), value, s) =>
-    val prev = s get sample
-    assert(value == curExpected, "Expected current value to be " + curExpected + ", got " + value)
-    assert(prev == prevExpected, "Expected previous value to be " + prevExpected + ", got " + prev)
-  }
+def checkInit: Initialize[InputTask[Unit]] = Def inputTask {
+  val key = (token(Space ~> IntBasic) ~ token(Space ~> IntBasic).?).parsed
+  val (curExpected, prevExpected) = key
+  val value = updateDemo.value
+  val prev = state.value get sample
+  assert(value == curExpected, s"Expected current value to be $curExpected, got $value")
+  assert(prev == prevExpected, s"Expected previous value to be $prevExpected, got $prev")
 }
 
 def  inMemorySetting = keep    :=  (getPrevious(keep)    map { case None =>  3; case Some(x) => x + 1}  keepAs(keep)).value
diff --git a/sbt/src/sbt-test/actions/task-cancel/build.sbt b/sbt/src/sbt-test/actions/task-cancel/build.sbt
index 149e93163..334fa825d 100644
--- a/sbt/src/sbt-test/actions/task-cancel/build.sbt
+++ b/sbt/src/sbt-test/actions/task-cancel/build.sbt
@@ -1,9 +1,9 @@
 import sbt.ExposeYourself._
 
-taskCancelHandler := { (state: State) =>
-  new TaskEvaluationCancelHandler {
+taskCancelStrategy := { (state: State) =>
+  new TaskCancellationStrategy {
     type State = Unit
-    override def onTaskEngineStart(canceller: TaskCancel): Unit = canceller.cancel()
-    override def finish(result: Unit): Unit = ()
+    override def onTaskEngineStart(canceller: RunningTaskEngine): Unit = canceller.cancelAndShutdown()
+    override def onTaskEngineFinish(state: State): Unit = ()
   }
-}
\ No newline at end of file
+}
diff --git a/sbt/src/sbt-test/actions/task-cancel/project/Build.scala b/sbt/src/sbt-test/actions/task-cancel/project/Build.scala
index cd7055cf0..33011f1fb 100644
--- a/sbt/src/sbt-test/actions/task-cancel/project/Build.scala
+++ b/sbt/src/sbt-test/actions/task-cancel/project/Build.scala
@@ -1,5 +1,5 @@
 package sbt  // this API is private[sbt], so only exposed for trusted clients and folks who like breaking.
 
 object ExposeYourself {
-	val taskCancelHandler = sbt.Keys.taskCancelHandler
-}
\ No newline at end of file
+	val taskCancelStrategy = sbt.Keys.taskCancelStrategy
+}
diff --git a/sbt/src/sbt-test/actions/task-map/build.sbt b/sbt/src/sbt-test/actions/task-map/build.sbt
new file mode 100644
index 000000000..57a7dcc3a
--- /dev/null
+++ b/sbt/src/sbt-test/actions/task-map/build.sbt
@@ -0,0 +1,26 @@
+val taskA = taskKey[File]("")
+val taskB = taskKey[File]("")
+
+val taskE = taskKey[File]("")
+val taskF = taskKey[File]("")
+
+taskA := touch(target.value / "a")
+taskB := touch(target.value / "b")
+
+taskE := touch(target.value / "e")
+taskF := touch(target.value / "f")
+
+//   a <<= a triggeredBy b
+// means "a" will be triggered by "b"
+// said differently, invoking "b" will run "b" and then run "a"
+
+taskA := (taskA triggeredBy taskB).value
+
+//   e <<= e runBefore f
+// means "e" will be run before running "f"
+// said differently, invoking "f" will run "e" and then run "f"
+
+taskE := (taskE runBefore taskF).value
+
+// test utils
+def touch(f: File): File = { IO touch f; f }
diff --git a/sbt/src/sbt-test/actions/task-map/test b/sbt/src/sbt-test/actions/task-map/test
new file mode 100644
index 000000000..3a88d40a7
--- /dev/null
+++ b/sbt/src/sbt-test/actions/task-map/test
@@ -0,0 +1,7 @@
+> taskB
+$ exists target/b
+$ exists target/a
+
+> taskF
+$ exists target/e
+$ exists target/f
diff --git a/sbt/src/sbt-test/actions/update-state-fail/build.sbt b/sbt/src/sbt-test/actions/update-state-fail/build.sbt
index cb3695fd4..6a5c0fc9f 100644
--- a/sbt/src/sbt-test/actions/update-state-fail/build.sbt
+++ b/sbt/src/sbt-test/actions/update-state-fail/build.sbt
@@ -1,4 +1,4 @@
-lazy val akey = AttributeKey[Int]("TestKey")
+lazy val akey = AttributeKey[Int]("testKey")
 lazy val testTask = taskKey[String]("")
 lazy val check = inputKey[Unit]("")
 
diff --git a/sbt/src/sbt-test/apiinfo/basic/build.sbt b/sbt/src/sbt-test/apiinfo/basic/build.sbt
deleted file mode 100644
index cc6aa3d78..000000000
--- a/sbt/src/sbt-test/apiinfo/basic/build.sbt
+++ /dev/null
@@ -1,4 +0,0 @@
-lazy val root = (project in file(".")).
-  settings(
-    scalaVersion := "2.10.6"
-  )
diff --git a/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/FooUser.scala b/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/FooUser.scala
deleted file mode 100644
index e2702a0e3..000000000
--- a/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/FooUser.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-package testCase
-
-case class FooUser(@Foo a: Int)
diff --git a/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/JFoo.java b/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/JFoo.java
deleted file mode 100644
index e849d8df7..000000000
--- a/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/JFoo.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package testCase;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-
-@Retention(RetentionPolicy.RUNTIME)
-public @interface JFoo {
-
-}
diff --git a/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/annotations.scala b/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/annotations.scala
deleted file mode 100644
index c74c28494..000000000
--- a/sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/annotations.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-
-import annotation.target.field
-
-
-package object testCase {
-	type Foo = JFoo @field;
-}
diff --git a/sbt/src/sbt-test/apiinfo/show-circular-structure/test b/sbt/src/sbt-test/apiinfo/show-circular-structure/test
index 535ef6fcf..92d7d983e 100644
--- a/sbt/src/sbt-test/apiinfo/show-circular-structure/test
+++ b/sbt/src/sbt-test/apiinfo/show-circular-structure/test
@@ -1,4 +1,4 @@
-# test case for http://github.com/sbt/sbt/issues/676
+# test case for https://github.com/sbt/sbt/issues/676
 > compile
 # fails with StackOverflowException
 > showApis
diff --git a/sbt/src/sbt-test/apiinfo/unstable-existential-names/build.sbt b/sbt/src/sbt-test/apiinfo/unstable-existential-names/build.sbt
index ec0b0288c..1036709cc 100644
--- a/sbt/src/sbt-test/apiinfo/unstable-existential-names/build.sbt
+++ b/sbt/src/sbt-test/apiinfo/unstable-existential-names/build.sbt
@@ -1,12 +1,25 @@
 import sbt.internal.inc.Analysis
+import complete.DefaultParsers._
 
-// checks number of compilation iterations performed since last `clean` run
-InputKey[Unit]("check-number-of-compiler-iterations") := (inputTask { (argTask: TaskKey[Seq[String]]) =>
-  (argTask, compile in Compile) map { case (args: Seq[String], a: Analysis) =>
-    assert(args.size == 1)
-    val expectedIterationsNumber = args(0).toInt
-    val allCompilationsSize = a.compilations.allCompilations.size
-    assert(allCompilationsSize == expectedIterationsNumber,
-      "allCompilationsSize == %d (expected %d)".format(allCompilationsSize, expectedIterationsNumber))
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+    }
   }
-}).evaluated
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
+
+checkIterations := {
+  val expected: Int = (Space ~> NatBasic).parsed
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+  assert(expected == actual, s"Expected $expected compilations, got $actual")
+}
diff --git a/sbt/src/sbt-test/apiinfo/unstable-existential-names/project/CompileState.scala b/sbt/src/sbt-test/apiinfo/unstable-existential-names/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/apiinfo/unstable-existential-names/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/apiinfo/unstable-existential-names/test b/sbt/src/sbt-test/apiinfo/unstable-existential-names/test
index 4a895eb1c..1eff3117d 100644
--- a/sbt/src/sbt-test/apiinfo/unstable-existential-names/test
+++ b/sbt/src/sbt-test/apiinfo/unstable-existential-names/test
@@ -2,6 +2,7 @@
 # do not introduce unnecessary compile iterations
 
 # introduces first compile iteration
+> recordPreviousIterations
 > compile
 # this change is local to a method and does not change the api so introduces
 # only one additional compile iteration
@@ -9,4 +10,4 @@ $ copy-file changes/Foo1.scala src/main/scala/Foo.scala
 # second iteration
 > compile
 # check if there are only two compile iterations being performed
-> checkNumberOfCompilerIterations 2
+> checkIterations 2
diff --git a/sbt/src/sbt-test/classloader-cache/akka-actor-system/build.sbt b/sbt/src/sbt-test/classloader-cache/akka-actor-system/build.sbt
new file mode 100644
index 000000000..889490e92
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/akka-actor-system/build.sbt
@@ -0,0 +1,11 @@
+ThisBuild / turbo := true
+
+val akkaTest = (project in file(".")).settings(
+  name := "akka-test",
+  scalaVersion := "2.12.12",
+  libraryDependencies ++= Seq(
+    "com.typesafe.akka" %% "akka-actor" % "2.5.16",
+    "com.lihaoyi" %% "utest" % "0.6.6" % "test"
+  ),
+  testFrameworks := Seq(new TestFramework("utest.runner.Framework"))
+)
diff --git a/sbt/src/sbt-test/classloader-cache/akka-actor-system/src/main/scala/AkkaTest.scala b/sbt/src/sbt-test/classloader-cache/akka-actor-system/src/main/scala/AkkaTest.scala
new file mode 100644
index 000000000..971b0341c
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/akka-actor-system/src/main/scala/AkkaTest.scala
@@ -0,0 +1,15 @@
+package sbt.scripted
+
+import akka.actor.ActorSystem
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+object AkkaTest {
+  def main(args: Array[String]): Unit = {
+    val now = System.nanoTime
+    val system = ActorSystem("akka")
+    Await.result(system.terminate(), 5.seconds)
+    val elapsed = System.nanoTime - now
+    println(s"Run took ${elapsed / 1.0e6} ms")
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/akka-actor-system/src/test/scala/AkkaPerfTest.scala b/sbt/src/sbt-test/classloader-cache/akka-actor-system/src/test/scala/AkkaPerfTest.scala
new file mode 100644
index 000000000..9e5bbe5f6
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/akka-actor-system/src/test/scala/AkkaPerfTest.scala
@@ -0,0 +1,12 @@
+package sbt.scripted
+
+import utest._
+
+object AkkaPerfTest extends TestSuite {
+  val tests: Tests = Tests {
+    'run - {
+      AkkaTest.main(Array.empty[String])
+      1 ==> 1
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/akka-actor-system/test b/sbt/src/sbt-test/classloader-cache/akka-actor-system/test
new file mode 100644
index 000000000..b14110376
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/akka-actor-system/test
@@ -0,0 +1,7 @@
+> run
+
+> run
+
+> test
+
+> test
diff --git a/sbt/src/sbt-test/classloader-cache/close-run/src/main/scala/Main.scala b/sbt/src/sbt-test/classloader-cache/close-run/src/main/scala/Main.scala
new file mode 100644
index 000000000..4b57eebb6
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/close-run/src/main/scala/Main.scala
@@ -0,0 +1,10 @@
+object Main extends App {
+  class Foo
+  new Thread {
+    override def run(): Unit = {
+      Thread.sleep(500)
+      try new Foo
+      catch { case t: Throwable => sys.exit(1) }
+    }
+  }.start()
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/close-run/test b/sbt/src/sbt-test/classloader-cache/close-run/test
new file mode 100644
index 000000000..9e4c2371c
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/close-run/test
@@ -0,0 +1 @@
+> run
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/java-serialization/build.sbt b/sbt/src/sbt-test/classloader-cache/java-serialization/build.sbt
new file mode 100644
index 000000000..ecc5e2814
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/java-serialization/build.sbt
@@ -0,0 +1,4 @@
+val dependency = project.settings(exportJars := true)
+val descendant = project.dependsOn(dependency).settings(
+  libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.5" % "test"
+)
diff --git a/sbt/src/sbt-test/classloader-cache/java-serialization/dependency/src/main/scala/reflection/Reflection.scala b/sbt/src/sbt-test/classloader-cache/java-serialization/dependency/src/main/scala/reflection/Reflection.scala
new file mode 100644
index 000000000..09853ea44
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/java-serialization/dependency/src/main/scala/reflection/Reflection.scala
@@ -0,0 +1,17 @@
+package reflection
+
+import java.io._
+import scala.util.control.NonFatal
+
+object Reflection {
+  def roundTrip[A](a: A): A = {
+    val baos = new ByteArrayOutputStream()
+    val oos = new ObjectOutputStream(baos)
+    oos.writeObject(a)
+    oos.close()
+    val bais = new ByteArrayInputStream(baos.toByteArray())
+    val ois = new ObjectInputStream(bais)
+    try ois.readObject().asInstanceOf[A]
+    finally ois.close()
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/Bar.scala b/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/Bar.scala
new file mode 100644
index 000000000..459991fa3
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/Bar.scala
@@ -0,0 +1,3 @@
+package test
+
+trait Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/Foo.scala b/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/Foo.scala
new file mode 100644
index 000000000..ce6e4e590
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/Foo.scala
@@ -0,0 +1,12 @@
+package test
+
+class Foo extends Bar with Serializable {
+  private[this] var value: Int = 0
+  def getValue(): Int = value
+  def setValue(newValue: Int): Unit = value = newValue
+  override def equals(o: Any): Boolean = o match {
+    case that: Foo => this.getValue() == that.getValue()
+    case _ => false
+  }
+  override def hashCode: Int = value
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/ReflectionTest.scala b/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/ReflectionTest.scala
new file mode 100644
index 000000000..73df72562
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/java-serialization/descendant/src/test/scala/test/ReflectionTest.scala
@@ -0,0 +1,32 @@
+package test
+
+import java.util.concurrent.{ CountDownLatch, TimeUnit }
+
+import org.scalatest._
+
+class ReflectionTest extends FlatSpec {
+  val procs = 2
+  val initLatch = new CountDownLatch(procs)
+  val loader = this.getClass.getClassLoader
+  val latch = new CountDownLatch(procs)
+  (1 to procs).foreach { i =>
+    new Thread() {
+      setDaemon(true)
+      start()
+      override def run(): Unit = {
+        initLatch.countDown()
+        initLatch.await(5, TimeUnit.SECONDS)
+        val className = if (i % 2 == 0) "test.Foo" else "test.Bar"
+        loader.loadClass(className)
+        val foo = new Foo
+        foo.setValue(3)
+        val newFoo = reflection.Reflection.roundTrip(foo)
+        assert(newFoo == foo)
+        assert(System.identityHashCode(newFoo) != System.identityHashCode(foo))
+        latch.countDown()
+      }
+    }
+  }
+  assert(latch.await(5, TimeUnit.SECONDS))
+}
+
diff --git a/sbt/src/sbt-test/classloader-cache/java-serialization/test b/sbt/src/sbt-test/classloader-cache/java-serialization/test
new file mode 100644
index 000000000..cb8ead9be
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/java-serialization/test
@@ -0,0 +1,20 @@
+> set descendant / Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+# We run test a number of times to ensure that it doesn't deadlock
+> test
+
+> test
+
+> test
+
+> test
+
+> test
+
+> testOnly
+
+> set descendant / Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary
+
+> test
+
+> testOnly
diff --git a/sbt/src/sbt-test/classloader-cache/jni/build.sbt b/sbt/src/sbt-test/classloader-cache/jni/build.sbt
new file mode 100644
index 000000000..9bd266eb7
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/build.sbt
@@ -0,0 +1,40 @@
+import java.nio.file._
+import scala.collection.JavaConverters._
+
+val copyTestResources = inputKey[Unit]("Copy the native libraries to the base directory")
+val appendToLibraryPath = taskKey[Unit]("Append the base directory to the java.library.path system property")
+val dropLibraryPath = taskKey[Unit]("Drop the last path from the java.library.path system property")
+val wrappedRun = taskKey[Unit]("Run with modified java.library.path")
+val wrappedTest = taskKey[Unit]("Test with modified java.library.path")
+
+def wrap(task: InputKey[Unit]): Def.Initialize[Task[Unit]] =
+  Def.sequential(appendToLibraryPath, task.toTask(""), dropLibraryPath)
+
+ThisBuild / turbo := true
+
+val root = (project in file(".")).settings(
+  scalaVersion := "2.12.12",
+  javacOptions ++= Seq("-source", "1.8", "-target", "1.8", "-h",
+  sourceDirectory.value.toPath.resolve("main/native/include").toString),
+  libraryDependencies += "com.lihaoyi" %% "utest" % "0.6.6" % "test",
+  testFrameworks := Seq(new TestFramework("utest.runner.Framework")),
+  copyTestResources := {
+    val key = Def.spaceDelimited().parsed.head
+    val base = baseDirectory.value.toPath
+    val resources = (baseDirectory.value / "src" / "main" / "resources" / key).toPath
+    Files.walk(resources).iterator.asScala.foreach { p =>
+      Files.copy(p, base.resolve(p.getFileName), StandardCopyOption.REPLACE_EXISTING)
+    }
+  },
+  appendToLibraryPath := {
+    val cp = System.getProperty("java.library.path", "").split(":")
+    val newCp = if (cp.contains(".")) cp else cp :+ "."
+    System.setProperty("java.library.path", newCp.mkString(":"))
+  },
+  dropLibraryPath := {
+    val cp = System.getProperty("java.library.path", "").split(":").dropRight(1)
+    System.setProperty("java.library.path", cp.mkString(":"))
+  },
+  wrappedRun := wrap(Runtime / run).value,
+  wrappedTest := wrap(Test / testOnly).value
+)
diff --git a/sbt/src/sbt-test/classloader-cache/jni/changes/JniLibraryTest.scala b/sbt/src/sbt-test/classloader-cache/jni/changes/JniLibraryTest.scala
new file mode 100644
index 000000000..aa15d4aaa
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/changes/JniLibraryTest.scala
@@ -0,0 +1,15 @@
+package sbt
+
+import java.nio.file._
+import utest._
+
+object JniLibraryTest extends TestSuite {
+  val tests = Tests {
+    'load - {
+      'native - {
+        System.loadLibrary("sbt-jni-library-test0")
+        new JniLibrary().getIntegerValue ==> 2
+      }
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/java/sbt/JniLibrary.java b/sbt/src/sbt-test/classloader-cache/jni/src/main/java/sbt/JniLibrary.java
new file mode 100644
index 000000000..35ff90ec6
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/main/java/sbt/JniLibrary.java
@@ -0,0 +1,5 @@
+package sbt;
+
+final class JniLibrary {
+  public native int getIntegerValue();
+}
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/native/1/Makefile b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/1/Makefile
new file mode 100644
index 000000000..f1fa7c538
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/1/Makefile
@@ -0,0 +1,61 @@
+TARGET_DIR := ../../../target
+BUILD_DIR := $(TARGET_DIR)/build
+NATIVE_DIR := native/$(shell uname -sm | cut -d ' ' -f2 | tr '[:upper:]' '[:lower:]')
+LIB_DIR := ../resources/$(NATIVE_DIR)
+LIB_NAME := sbt-jni-library-test0
+POSIX_LIB_NAME := lib$(LIB_NAME)
+SOURCE := sbt_JniLibrary
+CC := clang
+
+UNAME_S := $(shell uname -s)
+
+ifeq ($(UNAME_S),Darwin)
+	JNI_INCLUDE := -I$(shell mdfind -name jni.h | grep jdk1.8 | tail -n 1 | xargs dirname)\
+		-I$(shell mdfind -name jni_md.h | grep jdk1.8 | tail -n 1 | xargs dirname)
+	LD := /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++
+	OBJS := $(BUILD_DIR)/x86_64/darwin/$(SOURCE).o
+	LIBS := $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).dylib
+endif
+
+ifeq ($(UNAME_S), Linux)
+	BASE_INCLUDE := $(shell locate jni.h | tail -n 1 | xargs dirname)
+	JNI_INCLUDE := -I$(BASE_INCLUDE) -I$(BASE_INCLUDE)/linux
+	OBJS := $(BUILD_DIR)/x86_64/linux/$(SOURCE).o
+	LIBS := $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).so
+endif
+
+LINUX_CCFLAGS := -fPIC
+LINUX_LDFLAGS := -fPIC -shared
+
+CCFLAGS := -I./../include $(JNI_INCLUDE) -Wno-unused-command-line-argument -std=c++11 -O3
+
+all: $(LIBS)
+
+.PHONY: clean all
+
+$(BUILD_DIR)/x86_64/linux/$(SOURCE).o: $(SOURCE).cc
+	mkdir -p $(BUILD_DIR)/x86_64/linux; \
+	$(CC) -c $< $(CCFLAGS) $(JNI_INCLUDE) -fPIC -o $@
+
+$(BUILD_DIR)/x86_64/darwin/$(SOURCE).o: $(SOURCE).cc
+	mkdir -p $(BUILD_DIR)/x86_64/darwin; \
+	$(CC) -c $< $(CCFLAGS) -framework Carbon -o $@
+
+$(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).dylib: $(BUILD_DIR)/x86_64/darwin/$(SOURCE).o
+	mkdir -p $(TARGET_DIR)/x86_64; \
+	$(LD) -dynamiclib -framework Carbon $(CCFLAGS) -Wl,-headerpad_max_install_names -install_name @rpath/$(POSIX_LIB_NAME) \
+	$(BUILD_DIR)/x86_64/darwin/$(SOURCE).o  \
+	 -o $@ ; \
+	mkdir -p ../../resources/1; \
+	cp $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).dylib ../../resources/1
+
+
+
+$(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).so: $(BUILD_DIR)/x86_64/linux/$(SOURCE).o
+	mkdir -p $(TARGET_DIR)/x86_64; \
+	$(CC) -shared $< $(CCFLAGS) -Wl,-headerpad_max_install_names -o $@; \
+	mkdir -p ../../resources/1; \
+	cp $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).so ../../resources/1;
+
+clean:
+	rm -rf $(TARGET_DIR)/build $(TARGET_DIR)/$(NATIVE)
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/native/1/sbt_JniLibrary.cc b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/1/sbt_JniLibrary.cc
new file mode 100644
index 000000000..46d048f60
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/1/sbt_JniLibrary.cc
@@ -0,0 +1,15 @@
+#include <jni.h>
+#include "sbt_JniLibrary.h"
+
+extern "C" {
+
+/*
+ * Class:     sbt_JniLibrary
+ * Method:    getIntegerValue
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_sbt_JniLibrary_getIntegerValue
+  (JNIEnv *env, jobject obj) {
+    return 1;
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/native/2/Makefile b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/2/Makefile
new file mode 100644
index 000000000..d0634d916
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/2/Makefile
@@ -0,0 +1,61 @@
+TARGET_DIR := ../../../target
+BUILD_DIR := $(TARGET_DIR)/build
+NATIVE_DIR := native/$(shell uname -sm | cut -d ' ' -f2 | tr '[:upper:]' '[:lower:]')
+LIB_DIR := ../resources/$(NATIVE_DIR)
+LIB_NAME := sbt-jni-library-test0
+POSIX_LIB_NAME := lib$(LIB_NAME)
+SOURCE := sbt_JniLibrary
+CC := clang
+
+UNAME_S := $(shell uname -s)
+
+ifeq ($(UNAME_S),Darwin)
+	JNI_INCLUDE := -I$(shell mdfind -name jni.h | grep jdk1.8 | tail -n 1 | xargs dirname)\
+		-I$(shell mdfind -name jni_md.h | grep jdk1.8 | tail -n 1 | xargs dirname)
+	LD := /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++
+	OBJS := $(BUILD_DIR)/x86_64/darwin/$(SOURCE).o
+	LIBS := $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).dylib
+endif
+
+ifeq ($(UNAME_S), Linux)
+	BASE_INCLUDE := $(shell locate jni.h | tail -n 1 | xargs dirname)
+	JNI_INCLUDE := -I$(BASE_INCLUDE) -I$(BASE_INCLUDE)/linux
+	OBJS := $(BUILD_DIR)/x86_64/linux/$(SOURCE).o
+	LIBS := $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).so
+endif
+
+LINUX_CCFLAGS := -fPIC
+LINUX_LDFLAGS := -fPIC -shared
+
+CCFLAGS := -I./../include $(JNI_INCLUDE) -Wno-unused-command-line-argument -std=c++11 -O3
+
+all: $(LIBS)
+
+.PHONY: clean all
+
+$(BUILD_DIR)/x86_64/linux/$(SOURCE).o: $(SOURCE).cc
+	mkdir -p $(BUILD_DIR)/x86_64/linux; \
+	$(CC) -c $< $(CCFLAGS) $(JNI_INCLUDE) -fPIC -o $@
+
+$(BUILD_DIR)/x86_64/darwin/$(SOURCE).o: $(SOURCE).cc
+	mkdir -p $(BUILD_DIR)/x86_64/darwin; \
+	$(CC) -c $< $(CCFLAGS) -framework Carbon -o $@
+
+$(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).dylib: $(BUILD_DIR)/x86_64/darwin/$(SOURCE).o
+	mkdir -p $(TARGET_DIR)/x86_64; \
+	$(LD) -dynamiclib -framework Carbon $(CCFLAGS) -Wl,-headerpad_max_install_names -install_name @rpath/$(POSIX_LIB_NAME) \
+	$(BUILD_DIR)/x86_64/darwin/$(SOURCE).o  \
+	 -o $@ ; \
+	mkdir -p ../../resources/2; \
+	cp $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).dylib ../../resources/2
+
+
+
+$(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).so: $(BUILD_DIR)/x86_64/linux/$(SOURCE).o
+	mkdir -p $(TARGET_DIR)/x86_64; \
+	$(CC) -shared $< $(CCFLAGS) -Wl,-headerpad_max_install_names -o $@; \
+	mkdir -p ../../resources/2; \
+	cp $(TARGET_DIR)/x86_64/$(POSIX_LIB_NAME).so ../../resources/2;
+
+clean:
+	rm -rf $(TARGET_DIR)/build $(TARGET_DIR)/$(NATIVE)
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/native/2/sbt_JniLibrary.cc b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/2/sbt_JniLibrary.cc
new file mode 100644
index 000000000..eeb97bfa2
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/2/sbt_JniLibrary.cc
@@ -0,0 +1,15 @@
+#include <jni.h>
+#include "sbt_JniLibrary.h"
+
+extern "C" {
+
+/*
+ * Class:     sbt_JniLibrary
+ * Method:    getIntegerValue
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_sbt_JniLibrary_getIntegerValue
+  (JNIEnv *env, jobject obj) {
+    return 2;
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/native/include/sbt_JniLibrary.h b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/include/sbt_JniLibrary.h
new file mode 100644
index 000000000..ccdb7bd80
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/main/native/include/sbt_JniLibrary.h
@@ -0,0 +1,21 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class sbt_JniLibrary */
+
+#ifndef _Included_sbt_JniLibrary
+#define _Included_sbt_JniLibrary
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     sbt_JniLibrary
+ * Method:    getIntegerValue
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_sbt_JniLibrary_getIntegerValue
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/1/libsbt-jni-library-test0.dylib b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/1/libsbt-jni-library-test0.dylib
new file mode 100755
index 000000000..660445b66
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/1/libsbt-jni-library-test0.dylib differ
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/1/libsbt-jni-library-test0.so b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/1/libsbt-jni-library-test0.so
new file mode 100755
index 000000000..6cac0d6fb
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/1/libsbt-jni-library-test0.so differ
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/2/libsbt-jni-library-test0.dylib b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/2/libsbt-jni-library-test0.dylib
new file mode 100755
index 000000000..ed8916036
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/2/libsbt-jni-library-test0.dylib differ
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/2/libsbt-jni-library-test0.so b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/2/libsbt-jni-library-test0.so
new file mode 100755
index 000000000..ce87cb48d
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/2/libsbt-jni-library-test0.so differ
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/native/x86_64/libswoval-jni-library-test0.dylib b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/native/x86_64/libswoval-jni-library-test0.dylib
new file mode 100755
index 000000000..472d59c2b
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/jni/src/main/resources/native/x86_64/libswoval-jni-library-test0.dylib differ
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/main/scala/TestMain.scala b/sbt/src/sbt-test/classloader-cache/jni/src/main/scala/TestMain.scala
new file mode 100644
index 000000000..523c37799
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/main/scala/TestMain.scala
@@ -0,0 +1,12 @@
+package sbt
+
+import java.nio.file._
+import scala.collection.JavaConverters._
+
+object TestMain {
+  def main(args: Array[String]): Unit = {
+    val libraryPath = System.getProperty("java.library.path")
+    System.loadLibrary("sbt-jni-library-test0")
+    println(s"Native value is ${new JniLibrary().getIntegerValue}")
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/jni/src/test/scala/sbt/JniLibraryTest.scala b/sbt/src/sbt-test/classloader-cache/jni/src/test/scala/sbt/JniLibraryTest.scala
new file mode 100644
index 000000000..c4b20e199
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/src/test/scala/sbt/JniLibraryTest.scala
@@ -0,0 +1,15 @@
+package sbt
+
+import java.nio.file._
+import utest._
+
+object JniLibraryTest extends TestSuite {
+  val tests = Tests {
+    'load - {
+      'native - {
+        System.loadLibrary("sbt-jni-library-test0")
+        new JniLibrary().getIntegerValue ==> 1
+      }
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/jni/test b/sbt/src/sbt-test/classloader-cache/jni/test
new file mode 100644
index 000000000..7375b6eba
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/jni/test
@@ -0,0 +1,6 @@
+> copyTestResources 1
+> wrappedRun
+> wrappedTest
+> copyTestResources 2
+$ copy-file changes/JniLibraryTest.scala src/test/scala/sbt/JniLibraryTest.scala
+> wrappedTest
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/build.sbt b/sbt/src/sbt-test/classloader-cache/library-mismatch/build.sbt
new file mode 100644
index 000000000..b0fe1aa10
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/build.sbt
@@ -0,0 +1,11 @@
+ThisBuild / turbo := true
+
+val snapshot = (project in file(".")).settings(
+  name := "mismatched-libraries",
+  scalaVersion := "2.12.12",
+  libraryDependencies ++= Seq("com.lihaoyi" %% "utest" % "0.6.6" % "test"),
+  testFrameworks := Seq(TestFramework("utest.runner.Framework")),
+  resolvers += "Local Maven" at file("libraries/ivy").toURI.toURL.toString,
+  libraryDependencies += "sbt" % "transitive-lib" % "0.1.0",
+  libraryDependencies += "sbt" % "foo-lib" % "0.2.0" % "test",
+)
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/build.sbt b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/build.sbt
new file mode 100644
index 000000000..a450e3bb9
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/build.sbt
@@ -0,0 +1,11 @@
+name := "foo-lib"
+
+organization := "sbt"
+
+publishTo := Some(Resolver.file("test-resolver", file("..").getCanonicalFile / "ivy"))
+
+version := "0.1.0"
+
+crossPaths := false
+
+autoScalaLibrary := false
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/project/build.properties b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/project/build.properties
new file mode 100644
index 000000000..7c58a83ab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.6
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/src/main/java/sbt/foo/Foo.java b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/src/main/java/sbt/foo/Foo.java
new file mode 100644
index 000000000..4f89c900b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.1.0/src/main/java/sbt/foo/Foo.java
@@ -0,0 +1,7 @@
+package sbt.foo;
+
+public class Foo {
+  static public int x() {
+    return 1;
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/build.sbt b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/build.sbt
new file mode 100644
index 000000000..b399a06f5
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/build.sbt
@@ -0,0 +1,11 @@
+name := "foo-lib"
+
+organization := "sbt"
+
+publishTo := Some(Resolver.file("test-resolver", file("..").getCanonicalFile / "ivy"))
+
+version := "0.2.0"
+
+crossPaths := false
+
+autoScalaLibrary := false
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/project/build.properties b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/project/build.properties
new file mode 100644
index 000000000..7c58a83ab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.6
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/src/main/java/sbt/foo/Foo.java b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/src/main/java/sbt/foo/Foo.java
new file mode 100644
index 000000000..66595cf6f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/foo-lib-0.2.0/src/main/java/sbt/foo/Foo.java
@@ -0,0 +1,10 @@
+package sbt.foo;
+
+public class Foo {
+  static public int x() {
+    return 2;
+  }
+  static public int y() {
+    return 3;
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar
new file mode 100644
index 000000000..13319bbfb
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar.md5
new file mode 100644
index 000000000..e8c91778b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar.md5
@@ -0,0 +1 @@
+66124717bb8840ce6f60567b19634a4b
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar.sha1
new file mode 100644
index 000000000..7df850585
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-javadoc.jar.sha1
@@ -0,0 +1 @@
+ca2193d86495f120496370cf2e75355f2b10b2a3
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar
new file mode 100644
index 000000000..d675c2cb2
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar.md5
new file mode 100644
index 000000000..e16a6727e
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar.md5
@@ -0,0 +1 @@
+8bb4c394490df92c43361e47d98cba52
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar.sha1
new file mode 100644
index 000000000..8eb308f6d
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0-sources.jar.sha1
@@ -0,0 +1 @@
+86ce6f4d12e075e8ef4ba80b671783673a8a0443
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar
new file mode 100644
index 000000000..5eb0d2b98
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar.md5
new file mode 100644
index 000000000..4119cd027
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar.md5
@@ -0,0 +1 @@
+4cd195abad8639ba6df345c125068058
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar.sha1
new file mode 100644
index 000000000..3a4ae59c3
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.jar.sha1
@@ -0,0 +1 @@
+e18f4c7a4b52d288733f123008d98985610da4f3
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom
new file mode 100644
index 000000000..fc90d29ec
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom
@@ -0,0 +1,13 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>sbt</groupId>
+    <artifactId>foo-lib</artifactId>
+    <packaging>jar</packaging>
+    <description>foo-lib</description>
+    <version>0.1.0</version>
+    <name>foo-lib</name>
+    <organization>
+        <name>sbt</name>
+    </organization>
+</project>
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom.md5
new file mode 100644
index 000000000..2cb48799b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom.md5
@@ -0,0 +1 @@
+22ebca3d8b32a4c0cb40341501b798e2
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom.sha1
new file mode 100644
index 000000000..4e5efcb01
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.1.0/foo-lib-0.1.0.pom.sha1
@@ -0,0 +1 @@
+575258d8c9fecff7e8beefee2637c2928328e0dc
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar
new file mode 100644
index 000000000..1037d4546
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar.md5
new file mode 100644
index 000000000..6c94e7950
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar.md5
@@ -0,0 +1 @@
+ce4dcb6be9c11c1356e6aeaa024c80f1
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar.sha1
new file mode 100644
index 000000000..17453e3b8
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-javadoc.jar.sha1
@@ -0,0 +1 @@
+cc1a6b548cb9efd6e43c7fb5fa44728fc3f50d45
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar
new file mode 100644
index 000000000..99410b913
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar.md5
new file mode 100644
index 000000000..ddafa9ebb
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar.md5
@@ -0,0 +1 @@
+f18c726e5009cf205ca83cf96a28345b
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar.sha1
new file mode 100644
index 000000000..4dd6ee7f1
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0-sources.jar.sha1
@@ -0,0 +1 @@
+af0ac149e4c810884bb921bb3826e495faa5854b
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar
new file mode 100644
index 000000000..948dd983f
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar.md5
new file mode 100644
index 000000000..cf6b26db1
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar.md5
@@ -0,0 +1 @@
+fcadc4b2d6965cec0f5e5efb0a59226d
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar.sha1
new file mode 100644
index 000000000..086f63d7f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.jar.sha1
@@ -0,0 +1 @@
+585422ad5196b83f83bbca644e62a39a2e4171e0
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom
new file mode 100644
index 000000000..4ab3397ba
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom
@@ -0,0 +1,13 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>sbt</groupId>
+    <artifactId>foo-lib</artifactId>
+    <packaging>jar</packaging>
+    <description>foo-lib</description>
+    <version>0.2.0</version>
+    <name>foo-lib</name>
+    <organization>
+        <name>sbt</name>
+    </organization>
+</project>
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom.md5
new file mode 100644
index 000000000..087635a3c
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom.md5
@@ -0,0 +1 @@
+790acd1d77316ff2c0310bb88d01dc72
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom.sha1
new file mode 100644
index 000000000..0c74509e8
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/foo-lib/0.2.0/foo-lib-0.2.0.pom.sha1
@@ -0,0 +1 @@
+94eec0571d936004eb5682b8b12268d1bcb2be40
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar
new file mode 100644
index 000000000..39f0eea9a
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar.md5
new file mode 100644
index 000000000..ce5c94c76
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar.md5
@@ -0,0 +1 @@
+31f61c992ede7185d70d7c8a9ed19340
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar.sha1
new file mode 100644
index 000000000..c0b7f1add
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-javadoc.jar.sha1
@@ -0,0 +1 @@
+3083e0439d988b1cce30be566f8c95448c310eca
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar
new file mode 100644
index 000000000..3cc549138
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar.md5
new file mode 100644
index 000000000..9669bc52f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar.md5
@@ -0,0 +1 @@
+b9e2ead915294bf9e79622fe4ad9eadb
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar.sha1
new file mode 100644
index 000000000..981beaca9
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0-sources.jar.sha1
@@ -0,0 +1 @@
+5454c981af36713e2f0cedce98a83da2b0e4b982
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar
new file mode 100644
index 000000000..45223c30c
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar.md5
new file mode 100644
index 000000000..19d0fe484
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar.md5
@@ -0,0 +1 @@
+c7b4fbba100656a2798c39ca1d88317f
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar.sha1
new file mode 100644
index 000000000..84f5adbb1
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.jar.sha1
@@ -0,0 +1 @@
+f0fcc50b65e83f42210bbd3f366e2cc439177aa8
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom
new file mode 100644
index 000000000..a3306d5b1
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom
@@ -0,0 +1,20 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>sbt</groupId>
+    <artifactId>transitive-lib</artifactId>
+    <packaging>jar</packaging>
+    <description>transitive-lib</description>
+    <version>0.1.0</version>
+    <name>transitive-lib</name>
+    <organization>
+        <name>sbt</name>
+    </organization>
+    <dependencies>
+        <dependency>
+            <groupId>sbt</groupId>
+            <artifactId>foo-lib</artifactId>
+            <version>0.1.0</version>
+        </dependency>
+    </dependencies>
+</project>
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom.md5 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom.md5
new file mode 100644
index 000000000..b370e9b87
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom.md5
@@ -0,0 +1 @@
+460393fd256f121413f943d085887278
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom.sha1 b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom.sha1
new file mode 100644
index 000000000..9956e4112
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/ivy/sbt/transitive-lib/0.1.0/transitive-lib-0.1.0.pom.sha1
@@ -0,0 +1 @@
+4cb84c1daf7152544065849db0c1ce2d8d47c334
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/build.sbt b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/build.sbt
new file mode 100644
index 000000000..5bb0f4ae8
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/build.sbt
@@ -0,0 +1,15 @@
+name := "transitive-lib"
+
+organization := "sbt"
+
+resolvers += "Local Maven" at file("../ivy").getCanonicalFile.toURI.toURL.toString
+
+publishTo := Some(Resolver.file("test-resolver", file("..").getCanonicalFile / "ivy"))
+
+version := "0.1.0"
+
+libraryDependencies += "sbt" % "foo-lib" % "0.1.0"
+
+crossPaths := false
+
+autoScalaLibrary := false
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/project/build.properties b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/project/build.properties
new file mode 100644
index 000000000..7c58a83ab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.6
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/src/main/java/sbt/transitive/Transitive.java b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/src/main/java/sbt/transitive/Transitive.java
new file mode 100644
index 000000000..bdc984690
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/libraries/transitive-lib-0.1.0/src/main/java/sbt/transitive/Transitive.java
@@ -0,0 +1,7 @@
+package sbt.transitive;
+
+public class Transitive {
+  public static int x() {
+    return sbt.foo.Foo.x();
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/src/main/scala/Main.scala b/sbt/src/sbt-test/classloader-cache/library-mismatch/src/main/scala/Main.scala
new file mode 100644
index 000000000..7a4455526
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/src/main/scala/Main.scala
@@ -0,0 +1,7 @@
+package sbt
+
+object TestMain {
+  def main(args: Array[String]) {
+    println(transitive.Transitive.x)
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/src/test/scala/sbt/MismatchedLibrariesTest.scala b/sbt/src/sbt-test/classloader-cache/library-mismatch/src/test/scala/sbt/MismatchedLibrariesTest.scala
new file mode 100644
index 000000000..9bc5a9a86
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/src/test/scala/sbt/MismatchedLibrariesTest.scala
@@ -0,0 +1,11 @@
+package sbt
+
+import utest._
+
+object MismatchedLibrariesTest extends TestSuite {
+  val tests: Tests = Tests {
+    'check - {
+      assert(foo.Foo.y == 3)
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/library-mismatch/test b/sbt/src/sbt-test/classloader-cache/library-mismatch/test
new file mode 100644
index 000000000..d737a4d50
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/library-mismatch/test
@@ -0,0 +1,3 @@
+> run
+
+> test
diff --git a/sbt/src/sbt-test/classloader-cache/package-private/build.sbt b/sbt/src/sbt-test/classloader-cache/package-private/build.sbt
new file mode 100644
index 000000000..68a4b5df0
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/package-private/build.sbt
@@ -0,0 +1 @@
+libraryDependencies += "org.scala-sbt.ivy" % "ivy" % "2.3.0-sbt-cb9cc189e9f3af519f9f102e6c5d446488ff6832"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/package-private/src/main/scala/sbt/classpath/Run.scala b/sbt/src/sbt-test/classloader-cache/package-private/src/main/scala/sbt/classpath/Run.scala
new file mode 100644
index 000000000..de1de4fab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/package-private/src/main/scala/sbt/classpath/Run.scala
@@ -0,0 +1,12 @@
+package org.apache.ivy.plugins.parser.m2
+
+import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor
+
+object Run {
+  def main(args: Array[String]): Unit = {
+    new PomModuleDescriptorBuilder.ConfMapper {
+      override def addMappingConfs(dd: DefaultDependencyDescriptor, isOptional: Boolean): Unit = {}
+    }
+    ()
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/package-private/test b/sbt/src/sbt-test/classloader-cache/package-private/test
new file mode 100644
index 000000000..dd298596e
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/package-private/test
@@ -0,0 +1,11 @@
+> set Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+-> run
+
+> set Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat
+
+> run
+
+> set Runtime / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary
+
+> run
diff --git a/sbt/src/sbt-test/classloader-cache/resources/build.sbt b/sbt/src/sbt-test/classloader-cache/resources/build.sbt
new file mode 100644
index 000000000..bf5ab6486
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/build.sbt
@@ -0,0 +1,7 @@
+ThisBuild / turbo := true
+
+resolvers += "Local Maven" at (baseDirectory.value / "libraries" / "foo" / "ivy").toURI.toURL.toString
+
+libraryDependencies += "sbt" %% "foo-lib" % "0.1.0"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.5" % "test"
diff --git a/sbt/src/sbt-test/classloader-cache/resources/changes/UpdatedResourceTest.scala b/sbt/src/sbt-test/classloader-cache/resources/changes/UpdatedResourceTest.scala
new file mode 100644
index 000000000..b1b13145e
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/changes/UpdatedResourceTest.scala
@@ -0,0 +1,9 @@
+package scripted
+
+import org.scalatest.FlatSpec
+
+class ResourceTest extends FlatSpec {
+  "test resources" should "load" in {
+    Main.main(Array("bar.txt", "updated-test"))
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/resources/changes/updated-main.txt b/sbt/src/sbt-test/classloader-cache/resources/changes/updated-main.txt
new file mode 100644
index 000000000..d53f0341f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/changes/updated-main.txt
@@ -0,0 +1 @@
+updated-main
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/changes/updated-test.txt b/sbt/src/sbt-test/classloader-cache/resources/changes/updated-test.txt
new file mode 100644
index 000000000..e0f0eebab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/changes/updated-test.txt
@@ -0,0 +1 @@
+updated-test
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/build.sbt b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/build.sbt
new file mode 100644
index 000000000..860c958ab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/build.sbt
@@ -0,0 +1,11 @@
+name := "foo-lib"
+
+organization := "sbt"
+
+publishTo := Some(Resolver.file("test-resolver", file("").getCanonicalFile / "ivy"))
+
+version := "0.1.0"
+
+classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar
new file mode 100644
index 000000000..276995bb9
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar.md5 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar.md5
new file mode 100644
index 000000000..a1d5ac6db
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar.md5
@@ -0,0 +1 @@
+9bab3dca3e061fdbbff2419ef0eee90d
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar.sha1 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar.sha1
new file mode 100644
index 000000000..4ee36a1b4
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-javadoc.jar.sha1
@@ -0,0 +1 @@
+11081018ca6824226893b153fe439d3a94e23286
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar
new file mode 100644
index 000000000..e445add15
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar.md5 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar.md5
new file mode 100644
index 000000000..3fad0add4
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar.md5
@@ -0,0 +1 @@
+afba811024a110dc47734c6d9ec0eb5b
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar.sha1 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar.sha1
new file mode 100644
index 000000000..b2a820350
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0-sources.jar.sha1
@@ -0,0 +1 @@
+e4e1b37d77060a77ab20c508df90cdae6125f3bc
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar
new file mode 100644
index 000000000..e2441bf60
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar.md5 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar.md5
new file mode 100644
index 000000000..7acfc2da3
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar.md5
@@ -0,0 +1 @@
+6de1cfe8548a007ac08763ab5f051e08
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar.sha1 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar.sha1
new file mode 100644
index 000000000..e60d8daff
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.jar.sha1
@@ -0,0 +1 @@
+f25267dfe760e734ea4f8a00b8dc6ace477589d6
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom
new file mode 100644
index 000000000..a340da7e4
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom
@@ -0,0 +1,20 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>sbt</groupId>
+    <artifactId>foo-lib_2.12</artifactId>
+    <packaging>jar</packaging>
+    <description>foo-lib</description>
+    <version>0.1.0</version>
+    <name>foo-lib</name>
+    <organization>
+        <name>sbt</name>
+    </organization>
+    <dependencies>
+        <dependency>
+            <groupId>org.scala-lang</groupId>
+            <artifactId>scala-library</artifactId>
+            <version>2.12.8</version>
+        </dependency>
+    </dependencies>
+</project>
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom.md5 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom.md5
new file mode 100644
index 000000000..70f55bc4e
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom.md5
@@ -0,0 +1 @@
+b83994a1d5ecfc3d6ff71021649e342d
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom.sha1 b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom.sha1
new file mode 100644
index 000000000..b005d6129
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/ivy/sbt/foo-lib_2.12/0.1.0/foo-lib_2.12-0.1.0.pom.sha1
@@ -0,0 +1 @@
+6b2c0b4d69ed8e10e0221db841e0f1fdeef12780
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/project/build.properties b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/project/build.properties
new file mode 100644
index 000000000..c66f82ead
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.3.0-RC1
diff --git a/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/src/main/scala/resource/Resource.scala b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/src/main/scala/resource/Resource.scala
new file mode 100644
index 000000000..9793cd8a0
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/libraries/foo/src/main/scala/resource/Resource.scala
@@ -0,0 +1,19 @@
+package resource
+
+import java.net.URL
+import java.nio.file._
+import java.util.Collections
+
+object Resource {
+  def readFile(url: URL): String = {
+      val uri = url.toURI
+      val fileSystem =
+        if (uri.getScheme != "jar") None
+        else Some(FileSystems.newFileSystem(uri, Collections.emptyMap[String, Object]))
+      try new String(Files.readAllBytes(Paths.get(uri)))
+      finally fileSystem.foreach(_.close())
+  }
+  def getStringResource(name: String): String = {
+    readFile(Resource.getClass.getClassLoader.getResource(name))
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/resources/src/main/resources/foo.txt b/sbt/src/sbt-test/classloader-cache/resources/src/main/resources/foo.txt
new file mode 100644
index 000000000..88d050b19
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/src/main/resources/foo.txt
@@ -0,0 +1 @@
+main
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/src/main/scala/scripted/Main.scala b/sbt/src/sbt-test/classloader-cache/resources/src/main/scala/scripted/Main.scala
new file mode 100644
index 000000000..61b2fb6c9
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/src/main/scala/scripted/Main.scala
@@ -0,0 +1,10 @@
+package scripted
+
+import resource.Resource
+
+object Main {
+  def main(args: Array[String]): Unit = {
+    val Array(resource, expected) = args
+    assert(Resource.getStringResource(resource) == expected)
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/resources/src/test/resources/bar.txt b/sbt/src/sbt-test/classloader-cache/resources/src/test/resources/bar.txt
new file mode 100644
index 000000000..30d74d258
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/src/test/resources/bar.txt
@@ -0,0 +1 @@
+test
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/resources/src/test/scala/scripted/ResourceTest.scala b/sbt/src/sbt-test/classloader-cache/resources/src/test/scala/scripted/ResourceTest.scala
new file mode 100644
index 000000000..980fd37bc
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/src/test/scala/scripted/ResourceTest.scala
@@ -0,0 +1,9 @@
+package scripted
+
+import org.scalatest.FlatSpec
+
+class ResourceTest extends FlatSpec {
+  "test resources" should "load" in {
+    Main.main(Array("bar.txt", "test"))
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/resources/test b/sbt/src/sbt-test/classloader-cache/resources/test
new file mode 100644
index 000000000..57e1f61f5
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/resources/test
@@ -0,0 +1,15 @@
+> run foo.txt main
+
+$ copy-file changes/updated-main.txt src/main/resources/foo.txt
+
+> run foo.txt updated-main
+
+> test
+
+$ copy-file changes/updated-test.txt src/test/resources/bar.txt
+
+-> test
+
+$ copy-file changes/UpdatedResourceTest.scala src/test/scala/scripted/ResourceTest.scala
+
+> test
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/runtime-layers/build.sbt b/sbt/src/sbt-test/classloader-cache/runtime-layers/build.sbt
new file mode 100644
index 000000000..45c966d82
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/runtime-layers/build.sbt
@@ -0,0 +1,6 @@
+val layeringStrategyTest = (project in file(".")).settings(
+  name := "layering-strategy-test",
+  scalaVersion := "2.12.12",
+  organization := "sbt",
+  libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.5.16",
+)
diff --git a/sbt/src/sbt-test/classloader-cache/runtime-layers/src/main/scala/AkkaTest.scala b/sbt/src/sbt-test/classloader-cache/runtime-layers/src/main/scala/AkkaTest.scala
new file mode 100644
index 000000000..971b0341c
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/runtime-layers/src/main/scala/AkkaTest.scala
@@ -0,0 +1,15 @@
+package sbt.scripted
+
+import akka.actor.ActorSystem
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+object AkkaTest {
+  def main(args: Array[String]): Unit = {
+    val now = System.nanoTime
+    val system = ActorSystem("akka")
+    Await.result(system.terminate(), 5.seconds)
+    val elapsed = System.nanoTime - now
+    println(s"Run took ${elapsed / 1.0e6} ms")
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/runtime-layers/src/test/scala/TestAkkaTest.scala b/sbt/src/sbt-test/classloader-cache/runtime-layers/src/test/scala/TestAkkaTest.scala
new file mode 100644
index 000000000..e17c9962f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/runtime-layers/src/test/scala/TestAkkaTest.scala
@@ -0,0 +1,15 @@
+package sbt.scripted
+
+import akka.actor.ActorSystem
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+object TestAkkaTest {
+  def main(args: Array[String]): Unit = {
+    val now = System.nanoTime
+    val system = ActorSystem("akka")
+    Await.result(system.terminate(), 5.seconds)
+    val elapsed = System.nanoTime - now
+    println(s"Test run took ${elapsed / 1.0e6} ms")
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/runtime-layers/test b/sbt/src/sbt-test/classloader-cache/runtime-layers/test
new file mode 100644
index 000000000..c6234883b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/runtime-layers/test
@@ -0,0 +1,25 @@
+> run
+
+> set Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat
+
+> run
+
+> set Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary
+
+> run
+
+> set Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+> run
+
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat
+
+> Test / runMain sbt.scripted.TestAkkaTest
+
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary
+
+> Test / runMain sbt.scripted.TestAkkaTest
+
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+> Test / runMain sbt.scripted.TestAkkaTest
diff --git a/sbt/src/sbt-test/classloader-cache/scalatest/build.sbt b/sbt/src/sbt-test/classloader-cache/scalatest/build.sbt
new file mode 100644
index 000000000..b32a1cd0b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/scalatest/build.sbt
@@ -0,0 +1,3 @@
+val test = (project in file(".")).settings(
+  libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.7" % Test
+)
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/scalatest/changes/bad.scala b/sbt/src/sbt-test/classloader-cache/scalatest/changes/bad.scala
new file mode 100644
index 000000000..508806fe4
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/scalatest/changes/bad.scala
@@ -0,0 +1,9 @@
+package sbt
+
+import org.scalatest.{ FlatSpec, Matchers }
+
+class ScalatestTest extends FlatSpec with Matchers {
+  "scalatest" should "fail" in {
+    1 shouldBe 2
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/scalatest/src/test/scala/sbt/ScalatestTest.scala b/sbt/src/sbt-test/classloader-cache/scalatest/src/test/scala/sbt/ScalatestTest.scala
new file mode 100644
index 000000000..afdcfe9e4
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/scalatest/src/test/scala/sbt/ScalatestTest.scala
@@ -0,0 +1,9 @@
+package sbt
+
+import org.scalatest.{ FlatSpec, Matchers }
+
+class ScalatestTest extends FlatSpec with Matchers {
+  "scalatest" should "work" in {
+    1 shouldBe 1
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/scalatest/test b/sbt/src/sbt-test/classloader-cache/scalatest/test
new file mode 100644
index 000000000..055516751
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/scalatest/test
@@ -0,0 +1,23 @@
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+> test
+
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat
+
+> test
+
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary
+
+> test
+
+$ copy-file changes/bad.scala src/test/scala/sbt/ScalatestTest.scala
+
+-> test
+
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat
+
+-> test
+
+> set Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+-> test
diff --git a/sbt/src/sbt-test/classloader-cache/service-loader/build.sbt b/sbt/src/sbt-test/classloader-cache/service-loader/build.sbt
new file mode 100644
index 000000000..ecc5e2814
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/service-loader/build.sbt
@@ -0,0 +1,4 @@
+val dependency = project.settings(exportJars := true)
+val descendant = project.dependsOn(dependency).settings(
+  libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.5" % "test"
+)
diff --git a/sbt/src/sbt-test/classloader-cache/service-loader/dependency/src/main/java/dependency/Runnable.java b/sbt/src/sbt-test/classloader-cache/service-loader/dependency/src/main/java/dependency/Runnable.java
new file mode 100644
index 000000000..24ebaaa9a
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/service-loader/dependency/src/main/java/dependency/Runnable.java
@@ -0,0 +1,6 @@
+package dependency;
+
+public class Runnable implements java.lang.Runnable {
+    public void run() {}
+}
+
diff --git a/sbt/src/sbt-test/classloader-cache/service-loader/dependency/src/main/resources/META-INF/services/java.lang.Runnable b/sbt/src/sbt-test/classloader-cache/service-loader/dependency/src/main/resources/META-INF/services/java.lang.Runnable
new file mode 100644
index 000000000..087785aad
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/service-loader/dependency/src/main/resources/META-INF/services/java.lang.Runnable
@@ -0,0 +1 @@
+dependency.Runnable
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/main/resources/META-INF/services/java.lang.Runnable b/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/main/resources/META-INF/services/java.lang.Runnable
new file mode 100644
index 000000000..d7cfd1185
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/main/resources/META-INF/services/java.lang.Runnable
@@ -0,0 +1 @@
+descendant.Runnable
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/main/scala/test/Runnable.scala b/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/main/scala/test/Runnable.scala
new file mode 100644
index 000000000..732e07dd7
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/main/scala/test/Runnable.scala
@@ -0,0 +1,6 @@
+package descendant
+
+class Runnable extends java.lang.Runnable {
+  override def run(): Unit = ()
+}
+
diff --git a/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/test/scala/test/ServiceLoaderTest.scala b/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/test/scala/test/ServiceLoaderTest.scala
new file mode 100644
index 000000000..b51a67f1a
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/service-loader/descendant/src/test/scala/test/ServiceLoaderTest.scala
@@ -0,0 +1,20 @@
+package test
+
+import collection.JavaConverters._
+import org.scalatest._
+
+class ServiceLoaderTest extends FlatSpec {
+  val expected = Set(classOf[dependency.Runnable], classOf[descendant.Runnable])
+
+  val descendantClassLoader = classOf[descendant.Runnable].getClassLoader
+  val descendantRunnableLoader = java.util.ServiceLoader.load(classOf[java.lang.Runnable], descendantClassLoader)
+  val descendantLoadedClasses = descendantRunnableLoader.iterator().asScala.map(_.getClass).toSet
+  assert(descendantLoadedClasses == expected)
+
+  // this was the actual problem, when classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+  val dependencyClassLoader = classOf[dependency.Runnable].getClassLoader
+  val dependencyRunnableLoader = java.util.ServiceLoader.load(classOf[java.lang.Runnable], dependencyClassLoader)
+  val dependencyLoadedClasses = dependencyRunnableLoader.iterator().asScala.map(_.getClass).toSet
+  assert(dependencyLoadedClasses == expected)
+}
+
diff --git a/sbt/src/sbt-test/classloader-cache/service-loader/test b/sbt/src/sbt-test/classloader-cache/service-loader/test
new file mode 100644
index 000000000..8b963f2d2
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/service-loader/test
@@ -0,0 +1,7 @@
+> set descendant / Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+> test
+
+> set descendant / Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary
+
+> test
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/build.sbt b/sbt/src/sbt-test/classloader-cache/snapshot/build.sbt
new file mode 100644
index 000000000..1a921e076
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/build.sbt
@@ -0,0 +1,27 @@
+ThisBuild / turbo := true
+
+import java.nio.file.Files
+import java.nio.file.attribute.FileTime
+import scala.collection.JavaConverters._
+val rewriteIvy = inputKey[Unit]("Rewrite ivy directory")
+
+ThisBuild / useCoursier := false
+
+val snapshot = (project in file(".")).settings(
+  name := "akka-test",
+  scalaVersion := "2.12.12",
+  libraryDependencies ++= Seq(
+    "com.lihaoyi" %% "utest" % "0.6.6" % "test"
+  ),
+  testFrameworks += TestFramework("utest.runner.Framework"),
+  resolvers += "Local Maven" at file("ivy").toURI.toURL.toString,
+  libraryDependencies += "sbt" %% "foo-lib" % "0.1.0-SNAPSHOT",
+  rewriteIvy := {
+    val dir = Def.spaceDelimited().parsed.head
+    sbt.IO.delete(baseDirectory.value / "ivy")
+    sbt.IO.copyDirectory(baseDirectory.value / s"libraries/library-$dir/ivy", baseDirectory.value / "ivy")
+    Files.walk(file("ivy").getCanonicalFile.toPath).iterator.asScala.foreach { f =>
+     Files.setLastModifiedTime(f, FileTime.fromMillis(System.currentTimeMillis + 3000))
+    }
+  }
+)
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/build.sbt b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/build.sbt
new file mode 100644
index 000000000..55109c35f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/build.sbt
@@ -0,0 +1,5 @@
+name := "foo-lib"
+
+organization := "sbt"
+
+publishTo := Some(Resolver.file("test-resolver", file("").getCanonicalFile / "ivy"))
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar
new file mode 100644
index 000000000..6ca76e2fd
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.md5
new file mode 100644
index 000000000..bc15f9443
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.md5
@@ -0,0 +1 @@
+397429ea4a937c9ad21268ac7f294c9b
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.sha1
new file mode 100644
index 000000000..c36a79d59
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.sha1
@@ -0,0 +1 @@
+183362cade58c89ae813465e7c509a3346515e39
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar
new file mode 100644
index 000000000..f7acb17ad
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.md5
new file mode 100644
index 000000000..9cadb3a11
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.md5
@@ -0,0 +1 @@
+9c46dbde2cd9c996c37c7ba4461eec7c
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.sha1
new file mode 100644
index 000000000..b4a982ea0
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.sha1
@@ -0,0 +1 @@
+b5725ff80281d86491166550058b56c6b0b7dd2d
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar
new file mode 100644
index 000000000..197c6e591
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.md5
new file mode 100644
index 000000000..0861ac32f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.md5
@@ -0,0 +1 @@
+c39385e52b24880f549e1c01642ed010
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.sha1
new file mode 100644
index 000000000..5d81c7d99
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.sha1
@@ -0,0 +1 @@
+de497479331da6c5dff72b6c1cfa5fca1634933f
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom
new file mode 100644
index 000000000..d5fedc71b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom
@@ -0,0 +1,20 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>sbt</groupId>
+    <artifactId>foo-lib_2.12</artifactId>
+    <packaging>jar</packaging>
+    <description>foo-lib</description>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>foo-lib</name>
+    <organization>
+        <name>sbt</name>
+    </organization>
+    <dependencies>
+        <dependency>
+            <groupId>org.scala-lang</groupId>
+            <artifactId>scala-library</artifactId>
+            <version>2.12.12</version>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.md5
new file mode 100644
index 000000000..394b7d529
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.md5
@@ -0,0 +1 @@
+ada0c2e0276459449bf25a4f99aab3f6
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.sha1
new file mode 100644
index 000000000..7162aec5e
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.sha1
@@ -0,0 +1 @@
+466216207d16d3e0daf0b2b18e67b20882f7f1b5
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/project/build.properties b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/project/build.properties
new file mode 100644
index 000000000..7c58a83ab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.6
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/src/main/scala/sbt/Foo.scala b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/src/main/scala/sbt/Foo.scala
new file mode 100644
index 000000000..7b95dd3d2
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-1/src/main/scala/sbt/Foo.scala
@@ -0,0 +1,5 @@
+package sbt
+
+object Foo {
+  def x: Int = 1
+}
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/build.sbt b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/build.sbt
new file mode 100644
index 000000000..55109c35f
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/build.sbt
@@ -0,0 +1,5 @@
+name := "foo-lib"
+
+organization := "sbt"
+
+publishTo := Some(Resolver.file("test-resolver", file("").getCanonicalFile / "ivy"))
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar
new file mode 100644
index 000000000..8505dca48
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.md5
new file mode 100644
index 000000000..249153493
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.md5
@@ -0,0 +1 @@
+260c1aab64032676c2c5b7d3c2a8e385
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.sha1
new file mode 100644
index 000000000..ceb465ee3
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-javadoc.jar.sha1
@@ -0,0 +1 @@
+44c78fcc5a2918bc4b33afb7419ac9d643bbac26
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar
new file mode 100644
index 000000000..5ef80e248
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.md5
new file mode 100644
index 000000000..8a81b3699
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.md5
@@ -0,0 +1 @@
+39c7358e50708bc3da53ffe34eb876d6
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.sha1
new file mode 100644
index 000000000..263e42fd8
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT-sources.jar.sha1
@@ -0,0 +1 @@
+64e078d3fed51c0ef3d8abdb096ab1406e44ee1c
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar
new file mode 100644
index 000000000..c41eddd31
Binary files /dev/null and b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar differ
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.md5
new file mode 100644
index 000000000..c7bb182af
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.md5
@@ -0,0 +1 @@
+763822fba242624131cf0706be56dabf
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.sha1
new file mode 100644
index 000000000..6c5f9adf1
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.jar.sha1
@@ -0,0 +1 @@
+22192abf4b52e85b9f979aa883ab42ce33bc51cd
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom
new file mode 100644
index 000000000..d5fedc71b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom
@@ -0,0 +1,20 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>sbt</groupId>
+    <artifactId>foo-lib_2.12</artifactId>
+    <packaging>jar</packaging>
+    <description>foo-lib</description>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>foo-lib</name>
+    <organization>
+        <name>sbt</name>
+    </organization>
+    <dependencies>
+        <dependency>
+            <groupId>org.scala-lang</groupId>
+            <artifactId>scala-library</artifactId>
+            <version>2.12.12</version>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.md5 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.md5
new file mode 100644
index 000000000..394b7d529
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.md5
@@ -0,0 +1 @@
+ada0c2e0276459449bf25a4f99aab3f6
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.sha1 b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.sha1
new file mode 100644
index 000000000..7162aec5e
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/ivy/sbt/foo-lib_2.12/0.1.0-SNAPSHOT/foo-lib_2.12-0.1.0-SNAPSHOT.pom.sha1
@@ -0,0 +1 @@
+466216207d16d3e0daf0b2b18e67b20882f7f1b5
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/project/build.properties b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/project/build.properties
new file mode 100644
index 000000000..7c58a83ab
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.6
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/src/main/scala/sbt/Foo.scala b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/src/main/scala/sbt/Foo.scala
new file mode 100644
index 000000000..75cca6b19
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/libraries/library-2/src/main/scala/sbt/Foo.scala
@@ -0,0 +1,5 @@
+package sbt
+
+object Foo {
+  def x: Int = 2
+}
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/src/test/scala/sbt/SnapshotTest.scala b/sbt/src/sbt-test/classloader-cache/snapshot/src/test/scala/sbt/SnapshotTest.scala
new file mode 100644
index 000000000..fe242766a
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/src/test/scala/sbt/SnapshotTest.scala
@@ -0,0 +1,11 @@
+package sbt
+
+import utest._
+
+object SnapshotTest extends TestSuite {
+  val tests: Tests = Tests {
+    'foo - {
+      com.swoval.Foo.x ==> 1
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/test b/sbt/src/sbt-test/classloader-cache/snapshot/test
new file mode 100644
index 000000000..179d9c36c
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/snapshot/test
@@ -0,0 +1,5 @@
+> rewriteIvy 1
+# If the ClassLoaderCache is not correctly set up, then the sbt testing framework fails to work correctly
+> test
+> rewriteIvy 2
+-> test
diff --git a/sbt/src/sbt-test/classloader-cache/spark/build.sbt b/sbt/src/sbt-test/classloader-cache/spark/build.sbt
new file mode 100644
index 000000000..af76b9d35
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/spark/build.sbt
@@ -0,0 +1,9 @@
+name := "Simple Project"
+
+version := "1.0"
+
+scalaVersion := "2.12.12"
+
+libraryDependencies += "org.apache.spark" %% "spark-sql" % "2.4.3"
+
+Compile / closeClassLoaders := false
diff --git a/sbt/src/sbt-test/classloader-cache/spark/log.txt b/sbt/src/sbt-test/classloader-cache/spark/log.txt
new file mode 100644
index 000000000..65b63b6d6
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/spark/log.txt
@@ -0,0 +1,7 @@
+a
+b
+c
+d
+e
+f
+g
\ No newline at end of file
diff --git a/sbt/src/sbt-test/classloader-cache/spark/src/main/scala/spark/SimpleApp.scala b/sbt/src/sbt-test/classloader-cache/spark/src/main/scala/spark/SimpleApp.scala
new file mode 100644
index 000000000..4f7dcce5b
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/spark/src/main/scala/spark/SimpleApp.scala
@@ -0,0 +1,14 @@
+import org.apache.spark.sql.SparkSession
+
+object SimpleApp {
+  def main(args: Array[String]) {
+    val logFile = "log.txt"
+    val spark = SparkSession.builder.appName("Simple Application").config("spark.master", "local").getOrCreate()
+    try {
+      val logData = spark.read.textFile(logFile).cache()
+      val numAs = logData.filter(line => line.contains("a")).count()
+      val numBs = logData.filter(line => line.contains("b")).count()
+      println(s"Lines with a: $numAs, Lines with b: $numBs")
+    } finally spark.stop()
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/spark/test b/sbt/src/sbt-test/classloader-cache/spark/test
new file mode 100644
index 000000000..9b368a1b1
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/spark/test
@@ -0,0 +1,11 @@
+> set classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.AllLibraryJars
+
+> run
+
+> set classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary
+
+> run
+
+> set classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat
+
+> run
diff --git a/sbt/src/sbt-test/classloader-cache/utest/build.sbt b/sbt/src/sbt-test/classloader-cache/utest/build.sbt
new file mode 100644
index 000000000..5745fe973
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/utest/build.sbt
@@ -0,0 +1,10 @@
+ThisBuild / turbo := true
+
+val utestTest = (project in file(".")).settings(
+  name := "utest-test",
+  scalaVersion := "2.12.12",
+  libraryDependencies ++= Seq(
+    "com.lihaoyi" %% "utest" % "0.6.6" % "test"
+  ),
+  testFrameworks += TestFramework("utest.runner.Framework")
+)
diff --git a/sbt/src/sbt-test/classloader-cache/utest/src/test/scala/sbt/UtestTest.scala b/sbt/src/sbt-test/classloader-cache/utest/src/test/scala/sbt/UtestTest.scala
new file mode 100644
index 000000000..caa8ff809
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/utest/src/test/scala/sbt/UtestTest.scala
@@ -0,0 +1,11 @@
+package sbt
+
+import utest._
+
+object UtestTest extends TestSuite {
+  val tests: Tests = Tests {
+    'foo - {
+      1 ==> 1
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/classloader-cache/utest/test b/sbt/src/sbt-test/classloader-cache/utest/test
new file mode 100644
index 000000000..a9bb439cf
--- /dev/null
+++ b/sbt/src/sbt-test/classloader-cache/utest/test
@@ -0,0 +1,2 @@
+# If the ClassLoaderCache is not correctly set up, then the sbt testing framework fails to work correctly
+> test
diff --git a/sbt/src/sbt-test/compiler-project/error-in-invalidated/build.sbt b/sbt/src/sbt-test/compiler-project/error-in-invalidated/build.sbt
index c92667cfa..c9260beeb 100644
--- a/sbt/src/sbt-test/compiler-project/error-in-invalidated/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/error-in-invalidated/build.sbt
@@ -1 +1,6 @@
-incOptions := xsbti.compile.IncOptionsUtil.defaultIncOptions
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file(".")).
+  settings(
+    incOptions := xsbti.compile.IncOptions.of()
+  )
diff --git a/sbt/src/sbt-test/compiler-project/error-in-invalidated/test b/sbt/src/sbt-test/compiler-project/error-in-invalidated/test
index 5f4cf63f8..9f4537091 100644
--- a/sbt/src/sbt-test/compiler-project/error-in-invalidated/test
+++ b/sbt/src/sbt-test/compiler-project/error-in-invalidated/test
@@ -1,9 +1,13 @@
 > compile
+
 # comment out `initialized` method in A
 $ copy-file changes/A1.scala src/main/scala/A.scala
+$ sleep 1000
 # compilation of A.scala succeeds but B.scala gets invalidated (properly) and B.scala fails to compile
 -> compile
+
 # we change A.scala to its original shape so compilation should succeed again
 $ copy-file changes/A2.scala src/main/scala/A.scala
+$ sleep 1000
 # this fails at the moment due to use of stale class file for A, see #958 for details
 > compile
diff --git a/sbt/src/sbt-test/compiler-project/inc-package-class-dependency/build.sbt b/sbt/src/sbt-test/compiler-project/inc-package-class-dependency/build.sbt
index 2b4c53c7c..a9b970121 100644
--- a/sbt/src/sbt-test/compiler-project/inc-package-class-dependency/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/inc-package-class-dependency/build.sbt
@@ -6,5 +6,7 @@ TaskKey[Unit]("verify-binary-deps") := {
   val base = baseDirectory.value
   val nestedPkgClass = classDir / "test/nested.class"
   val fooSrc = base / "src/main/scala/test/nested/Foo.scala"
-  assert(!a.relations.binaryDeps(fooSrc).contains(nestedPkgClass), a.relations.toString)
+  val converter = fileConverter.value
+  assert(!a.relations.libraryDeps(converter.toVirtualFile(fooSrc.toPath))
+    .contains(converter.toVirtualFile(nestedPkgClass.toPath)), a.relations.toString)
 }
diff --git a/sbt/src/sbt-test/compiler-project/inc-pickled-existential/build.sbt b/sbt/src/sbt-test/compiler-project/inc-pickled-existential/build.sbt
index f671d44fc..1284c994c 100644
--- a/sbt/src/sbt-test/compiler-project/inc-pickled-existential/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/inc-pickled-existential/build.sbt
@@ -1,12 +1,27 @@
 import sbt.internal.inc.Analysis
+import complete.DefaultParsers._
 
 logLevel := Level.Debug
 
-// dumps analysis into target/analysis-dump.txt file
-InputKey[Unit]("check-number-of-compiler-iterations") := (inputTask { (argTask: TaskKey[Seq[String]]) =>
-  (argTask, compile in Compile) map { case (args: Seq[String], a: Analysis) =>
-    assert(args.size == 1)
-    val expectedIterationsNumber = args(0).toInt
-    assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber))
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+    }
   }
-}).evaluated
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
+
+checkIterations := {
+  val expected: Int = (Space ~> NatBasic).parsed
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+  assert(expected == actual, s"Expected $expected compilations, got $actual")
+}
diff --git a/sbt/src/sbt-test/compiler-project/inc-pickled-existential/project/CompileState.scala b/sbt/src/sbt-test/compiler-project/inc-pickled-existential/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/compiler-project/inc-pickled-existential/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/compiler-project/inc-pickled-existential/test b/sbt/src/sbt-test/compiler-project/inc-pickled-existential/test
index b671a0166..cd9556fa5 100644
--- a/sbt/src/sbt-test/compiler-project/inc-pickled-existential/test
+++ b/sbt/src/sbt-test/compiler-project/inc-pickled-existential/test
@@ -2,6 +2,7 @@
 # do not introduce unnecessary compile iterations
 
 # introduces first compile iteration
+> recordPreviousIterations
 > compile
 # this change is local to a method and does not change the api so introduces
 # only one additional compile iteration
@@ -9,4 +10,4 @@ $ copy-file changes/B1.scala src/main/scala/B.scala
 # second iteration
 > compile
 # check if there are only two compile iterations being performed
-> checkNumberOfCompilerIterations 2
+> checkIterations 2
diff --git a/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/build.sbt b/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/build.sbt
index 66128f225..1036709cc 100644
--- a/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/build.sbt
@@ -1,9 +1,25 @@
 import sbt.internal.inc.Analysis
+import complete.DefaultParsers._
 
-InputKey[Unit]("check-number-of-compiler-iterations") := (inputTask { (argTask: TaskKey[Seq[String]]) =>
-  (argTask, compile in Compile) map { case (args: Seq[String], a: Analysis) =>
-    assert(args.size == 1)
-    val expectedIterationsNumber = args(0).toInt
-    assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber))
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+    }
   }
-}).evaluated
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
+
+checkIterations := {
+  val expected: Int = (Space ~> NatBasic).parsed
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+  assert(expected == actual, s"Expected $expected compilations, got $actual")
+}
diff --git a/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/project/CompileState.scala b/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/test b/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/test
index 110af1ccb..7a83d8efd 100644
--- a/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/test
+++ b/sbt/src/sbt-test/compiler-project/inc-pickled-refinement/test
@@ -4,6 +4,7 @@
 #     https://github.com/sbt/sbt/issues/610
 
 # introduces first compile iteration
+> recordPreviousIterations
 > compile
 # this change is local to method and does not change api so introduces
 # only one additional compile iteration
@@ -11,4 +12,4 @@ $ copy-file changes/Impl1.scala src/main/scala/Impl.scala
 # second iteration
 > compile
 # check if there are only two compile iterations performed
-> checkNumberOfCompilerIterations 2
+> checkIterations 2
diff --git a/sbt/src/sbt-test/compiler-project/macro-config/build.sbt b/sbt/src/sbt-test/compiler-project/macro-config/build.sbt
index 12abb53bd..248b7cb45 100644
--- a/sbt/src/sbt-test/compiler-project/macro-config/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/macro-config/build.sbt
@@ -1,24 +1,33 @@
-// Adds a "macro" configuration for macro dependencies.
+// Defines "macro" configuration.
 // By default, this includes the dependencies of the normal sources.
 // Drop the `extend(Compile)` to include no dependencies (not even scala-library) by default.
-ivyConfigurations += config("macro").hide.extend(Compile)
+val Macro = config("macro").hide.extend(Compile)
 
-// add the compiler as a dependency for src/macro/
-libraryDependencies +=
-  scalaVersion("org.scala-lang" % "scala-compiler" % _ % "macro").value
+lazy val root = (project in file("."))
+  .settings(
+    scalaVersion := "2.12.2",
 
-// adds standard compile, console, package tasks for src/macro/
-inConfig(config("macro"))(Defaults.configSettings)
+    // Adds a "macro" configuration for macro dependencies.
+    ivyConfigurations.value += Macro,
 
-// puts the compiled macro on the classpath for the main sources
-unmanagedClasspath in Compile ++=
-  (fullClasspath in config("macro")).value
+    // add the compiler as a dependency for src/macro/
+    libraryDependencies += {
+      "org.scala-lang" % "scala-compiler" % scalaVersion.value % Macro
+    },
 
-// includes sources in src/macro/ in the main source package
-mappings in (Compile, packageSrc) ++=
-  (mappings in (config("macro"), packageSrc)).value
+    // adds standard compile, console, package tasks for src/macro/
+    inConfig(Macro)(Defaults.configSettings),
 
-// Includes classes compiled from src/macro/ in the main binary
-// This can be omitted if the classes in src/macro/ aren't used at runtime
-mappings in (Compile, packageBin) ++=
-  (mappings in (config("macro"), packageBin)).value
+    // puts the compiled macro on the classpath for the main sources
+    unmanagedClasspath in Compile ++=
+      (fullClasspath in Macro).value,
+
+    // includes sources in src/macro/ in the main source package
+    mappings in (Compile, packageSrc) ++=
+      (mappings in (Macro, packageSrc)).value,
+
+    // Includes classes compiled from src/macro/ in the main binary
+    // This can be omitted if the classes in src/macro/ aren't used at runtime
+    mappings in (Compile, packageBin) ++=
+      (mappings in (Macro, packageBin)).value
+  )
diff --git a/sbt/src/sbt-test/compiler-project/macro-config/test b/sbt/src/sbt-test/compiler-project/macro-config/disabled
similarity index 100%
rename from sbt/src/sbt-test/compiler-project/macro-config/test
rename to sbt/src/sbt-test/compiler-project/macro-config/disabled
diff --git a/sbt/src/sbt-test/compiler-project/run-test/build.sbt b/sbt/src/sbt-test/compiler-project/run-test/build.sbt
index 52cd6d1f6..af714fb9e 100644
--- a/sbt/src/sbt-test/compiler-project/run-test/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/run-test/build.sbt
@@ -1,6 +1,9 @@
+scalaVersion in ThisBuild := "2.12.3"
+
 libraryDependencies ++= Seq(
-	"com.novocode" % "junit-interface" % "0.5" % "test",
-	"junit" % "junit" % "4.8" % "test"
+	"com.novocode" % "junit-interface" % "0.5" % Test,
+	"junit" % "junit" % "4.13.1" % Test,
+  "commons-io" % "commons-io" % "2.5" % Runtime,
 )
 
 libraryDependencies += scalaVersion("org.scala-lang" % "scala-compiler" % _ ).value
diff --git a/sbt/src/sbt-test/compiler-project/run-test/src/main/scala/Foo.scala b/sbt/src/sbt-test/compiler-project/run-test/src/main/scala/Foo.scala
index 872ab523e..4f45a02cc 100644
--- a/sbt/src/sbt-test/compiler-project/run-test/src/main/scala/Foo.scala
+++ b/sbt/src/sbt-test/compiler-project/run-test/src/main/scala/Foo.scala
@@ -28,10 +28,11 @@ class Foo {
 		catch { case _: URISyntaxException => new File(url.getPath) }
 }
 
-object Test
-{
-	def main(args: Array[String])
-	{
+object Test {
+	def main(args: Array[String]): Unit = {
+		// test that Runtime configuration is included
+		Class.forName("org.apache.commons.io.ByteOrderMark")
+		
 		val foo = new Foo
 		args.foreach { arg =>  foo.eval(arg) == arg.toInt }
 	}
diff --git a/sbt/src/sbt-test/compiler-project/scala3-tasty-management/build.sbt b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/build.sbt
new file mode 100644
index 000000000..8796ff21b
--- /dev/null
+++ b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/build.sbt
@@ -0,0 +1,8 @@
+import xsbti.compile.TastyFiles
+
+ThisBuild / scalaVersion := "3.0.0-M2"
+
+TaskKey[Unit]("check") := {
+  assert((Compile / auxiliaryClassFiles).value == Seq(TastyFiles.instance))
+  assert((Test / auxiliaryClassFiles).value == Seq(TastyFiles.instance))
+}
diff --git a/sbt/src/sbt-test/compiler-project/scala3-tasty-management/src/main/scala/A.scala b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/src/main/scala/A.scala
new file mode 100644
index 000000000..c52c45808
--- /dev/null
+++ b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+class A {
+	def initialized: Boolean = false
+}
diff --git a/sbt/src/sbt-test/compiler-project/scala3-tasty-management/src/main/scala/B.scala b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/src/main/scala/B.scala
new file mode 100644
index 000000000..066d5fc59
--- /dev/null
+++ b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/src/main/scala/B.scala
@@ -0,0 +1,3 @@
+class B {
+	def foo(a: A): Boolean = a.initialized
+}
diff --git a/sbt/src/sbt-test/compiler-project/scala3-tasty-management/test b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/test
new file mode 100644
index 000000000..52f74a532
--- /dev/null
+++ b/sbt/src/sbt-test/compiler-project/scala3-tasty-management/test
@@ -0,0 +1,12 @@
+> check
+> compile
+
+$ exists target/scala-3.0.0-M2/classes/A.tasty
+$ exists target/scala-3.0.0-M2/classes/B.tasty
+
+$ delete src/main/scala/B.scala
+
+> compile
+
+$ exists target/scala-3.0.0-M2/classes/A.tasty
+-$ exists target/scala-3.0.0-M2/classes/B.tasty
diff --git a/sbt/src/sbt-test/compiler-project/semantic-errors/build.sbt b/sbt/src/sbt-test/compiler-project/semantic-errors/build.sbt
index 4ce623f4f..019d06f89 100644
--- a/sbt/src/sbt-test/compiler-project/semantic-errors/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/semantic-errors/build.sbt
@@ -6,9 +6,9 @@ TaskKey[Unit]("checkJavaFailures") := {
   // First error should be on a specific line/file
   val first = ps(0)
   assert(first.position.line.get == 3, s"First failure position is not line 3, failure = $first")
-  val javaFile = baseDirectory.value / "src/main/java/bad.java"
-  val file = new File(first.position.sourcePath.get)
-  assert(file == javaFile, s"First failure file location is not $javaFile, $first")
+  val expected = "${BASE}/src/main/java/bad.java"
+  val sourcePath = first.position.sourcePath.get
+  assert(sourcePath == expected, s"$sourcePath == $expected was false")
 }
 
 TaskKey[Unit]("checkScalaFailures") := {
@@ -19,9 +19,7 @@ TaskKey[Unit]("checkScalaFailures") := {
   // First error should be on a specific line/file
   val first = ps(0)
   assert(first.position.line.get == 2, s"First failure position is not line 2, failure = $first")
-  val scalaFile = baseDirectory.value / "src/main/scala/bad.scala"
-  val file = new File(first.position.sourcePath.get)
-  assert(file == scalaFile, s"First failure file location is not $scalaFile, $first")
+  val expected = "${BASE}/src/main/scala/bad.scala"
+  val sourcePath = first.position.sourcePath.get
+  assert(sourcePath == expected, s"$sourcePath == $expected was false")
 }
-
-compileOrder := CompileOrder.Mixed
diff --git a/sbt/src/sbt-test/compiler-project/semantic-errors/project/src/main/scala/sbt/TestPlugin.scala b/sbt/src/sbt-test/compiler-project/semantic-errors/project/src/main/scala/sbt/TestPlugin.scala
index 4f3746d3e..d8c5e0c59 100644
--- a/sbt/src/sbt-test/compiler-project/semantic-errors/project/src/main/scala/sbt/TestPlugin.scala
+++ b/sbt/src/sbt-test/compiler-project/semantic-errors/project/src/main/scala/sbt/TestPlugin.scala
@@ -1,6 +1,5 @@
 package sbt
 
-import sbt.syntax._
 import sbt.Keys._
 import xsbti.{Position, Severity}
 
@@ -32,6 +31,9 @@ class CollectingReporter extends xsbti.Reporter {
   def printSummary(): Unit = ()
   def problems: Array[xsbti.Problem] = buffer.toArray
 
+  def log(problem: xsbti.Problem): Unit =
+    log(problem.position, problem.message, problem.severity)
+
   /** Logs a message. */
   def log(pos: xsbti.Position, msg: String, sev: xsbti.Severity): Unit = {
     object MyProblem extends xsbti.Problem {
diff --git a/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt b/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt
index c590b6d8f..804a1206d 100644
--- a/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt
@@ -1,12 +1,15 @@
-name := "foo"
+lazy val scala212 = "2.12.12"
+lazy val scala213 = "2.13.1"
+ThisBuild / scalaVersion := scala212
 
-scalaVersion := "2.10.4"
-
-crossScalaVersions := List("2.10.4", "2.11.0")
-
-incOptions := incOptions.value.withClassfileManagerType(
-  xsbti.Maybe.just(new xsbti.compile.TransactionalManagerType(
-    crossTarget.value / "classes.bak",
-    (streams in (Compile, compile)).value.log
-  ))
-)
+lazy val root = (project in file("."))
+  .settings(
+    name := "foo",
+    crossScalaVersions := List(scala212, scala213),
+    incOptions := incOptions.value.withClassfileManagerType(
+      Option(xsbti.compile.TransactionalManagerType.of(
+        crossTarget.value / "classes.bak",
+        (streams in (Compile, compile)).value.log
+      ): xsbti.compile.ClassFileManagerType).asJava
+    )
+  )
diff --git a/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/test b/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/test
index e76fa4b5c..40ef2a8c8 100644
--- a/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/test
+++ b/sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/test
@@ -1,3 +1,3 @@
 > + compile
-$ exists target/scala-2.10
-$ exists target/scala-2.11
+$ exists target/scala-2.12
+$ exists target/scala-2.13
diff --git a/sbt/src/sbt-test/compiler-project/src-dep-plugin/build.sbt b/sbt/src/sbt-test/compiler-project/src-dep-plugin/build.sbt
index 4871bbf58..ef1a97259 100644
--- a/sbt/src/sbt-test/compiler-project/src-dep-plugin/build.sbt
+++ b/sbt/src/sbt-test/compiler-project/src-dep-plugin/build.sbt
@@ -1,5 +1,5 @@
 import Configurations.{CompilerPlugin => CPlugin}
 
-lazy val use = project.dependsOn(file("def") % CPlugin).settings(
+lazy val use = project.dependsOn(RootProject(file("def")) % CPlugin).settings(
 	autoCompilerPlugins := true
 )
diff --git a/sbt/src/sbt-test/console/project-compiler-bridge/build.sbt b/sbt/src/sbt-test/console/project-compiler-bridge/build.sbt
new file mode 100644
index 000000000..3c4ba1908
--- /dev/null
+++ b/sbt/src/sbt-test/console/project-compiler-bridge/build.sbt
@@ -0,0 +1,5 @@
+scalaVersion := "2.13.1"
+
+// Send some bogus initial command so that it doesn't get stuck.
+// The task itself will still succeed.
+consoleProject / initialCommands := "bail!"
diff --git a/sbt/src/sbt-test/console/project-compiler-bridge/project/build.sbt b/sbt/src/sbt-test/console/project-compiler-bridge/project/build.sbt
new file mode 100644
index 000000000..366c27de7
--- /dev/null
+++ b/sbt/src/sbt-test/console/project-compiler-bridge/project/build.sbt
@@ -0,0 +1 @@
+scalaVersion := "2.12.12"
diff --git a/sbt/src/sbt-test/console/project-compiler-bridge/test b/sbt/src/sbt-test/console/project-compiler-bridge/test
new file mode 100644
index 000000000..b80db65f1
--- /dev/null
+++ b/sbt/src/sbt-test/console/project-compiler-bridge/test
@@ -0,0 +1 @@
+> consoleProject
diff --git a/sbt/src/sbt-test/dependency-graph/cachedResolution/build.sbt b/sbt/src/sbt-test/dependency-graph/cachedResolution/build.sbt
new file mode 100644
index 000000000..e4d1990a8
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/cachedResolution/build.sbt
@@ -0,0 +1,17 @@
+scalaVersion := "2.12.9"
+
+libraryDependencies += "org.slf4j" % "slf4j-api" % "1.7.28"
+updateOptions := updateOptions.value.withCachedResolution(true)
+
+TaskKey[Unit]("check") := {
+  val report = (Test / updateFull).value
+  val graph = (Test / dependencyTree / asString).value
+
+  def sanitize(str: String): String = str.split('\n').drop(1).mkString("\n")
+  val expectedGraph =
+    """default:cachedresolution_2.12:0.1.0-SNAPSHOT
+      |  +-org.slf4j:slf4j-api:1.7.28
+      |  """.stripMargin
+  require(sanitize(graph) == sanitize(expectedGraph), "Graph for report %s was '\n%s' but should have been '\n%s'" format (report, sanitize(graph), sanitize(expectedGraph)))
+  ()
+}
diff --git a/sbt/src/sbt-test/dependency-graph/cachedResolution/test b/sbt/src/sbt-test/dependency-graph/cachedResolution/test
new file mode 100644
index 000000000..a5912a391
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/cachedResolution/test
@@ -0,0 +1 @@
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt b/sbt/src/sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt
new file mode 100644
index 000000000..7e9f4cce2
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt
@@ -0,0 +1,25 @@
+scalaVersion := "2.9.2"
+
+libraryDependencies ++= Seq(
+  "org.slf4j" % "slf4j-api" % "1.7.2",
+  "ch.qos.logback" % "logback-classic" % "1.0.7"
+)
+
+TaskKey[Unit]("check") := {
+  val report = updateFull.value
+  val graph = (Test / dependencyTree / asString).value
+  def sanitize(str: String): String = str.split('\n').drop(1).map(_.trim).mkString("\n")
+  val expectedGraph =
+    """default:default-e95e05_2.9.2:0.1-SNAPSHOT [S]
+      |  +-ch.qos.logback:logback-classic:1.0.7
+      |  | +-ch.qos.logback:logback-core:1.0.7
+      |  | +-org.slf4j:slf4j-api:1.6.6 (evicted by: 1.7.2)
+      |  | +-org.slf4j:slf4j-api:1.7.2
+      |  |
+      |  +-org.slf4j:slf4j-api:1.7.2
+      |  """.stripMargin
+  IO.writeLines(file("/tmp/blib"), sanitize(graph).split("\n"))
+  IO.writeLines(file("/tmp/blub"), sanitize(expectedGraph).split("\n"))
+  require(sanitize(graph) == sanitize(expectedGraph), "Graph for report %s was '\n%s' but should have been '\n%s'" format (report, sanitize(graph), sanitize(expectedGraph)))
+  ()
+}
diff --git a/sbt/src/sbt-test/dependency-graph/ignoreScalaLibrary/test b/sbt/src/sbt-test/dependency-graph/ignoreScalaLibrary/test
new file mode 100644
index 000000000..a5912a391
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/ignoreScalaLibrary/test
@@ -0,0 +1 @@
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/showMissingUpdates/build.sbt b/sbt/src/sbt-test/dependency-graph/showMissingUpdates/build.sbt
new file mode 100644
index 000000000..192ecb0a9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/showMissingUpdates/build.sbt
@@ -0,0 +1,17 @@
+scalaVersion := "2.9.2"
+
+libraryDependencies +=
+  "at.blub" % "blib" % "1.2.3" % "test"
+
+TaskKey[Unit]("check") := {
+  val report = updateFull.value
+  val graph = (Test / dependencyTree / asString).value
+
+  def sanitize(str: String): String = str.split('\n').drop(1).mkString("\n")
+  val expectedGraph =
+    """default:default-91180e_2.9.2:0.1-SNAPSHOT
+      |  +-%sat.blub:blib:1.2.3 (error: not found)%s
+      |  """.stripMargin.format(scala.Console.RED, scala.Console.RESET)
+  require(sanitize(graph) == sanitize(expectedGraph), "Graph for report %s was '\n%s' but should have been '\n%s'" format (report, sanitize(graph), sanitize(expectedGraph)))
+  ()
+}
diff --git a/sbt/src/sbt-test/dependency-graph/showMissingUpdates/disabled b/sbt/src/sbt-test/dependency-graph/showMissingUpdates/disabled
new file mode 100644
index 000000000..a5912a391
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/showMissingUpdates/disabled
@@ -0,0 +1 @@
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/build.sbt b/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/build.sbt
new file mode 100644
index 000000000..fc61f4b22
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/build.sbt
@@ -0,0 +1,53 @@
+import scala.collection.mutable.ListBuffer
+
+ThisBuild / scalaVersion := "2.9.2"
+ThisBuild / version := "0.1-SNAPSHOT"
+
+lazy val justATransiviteDependencyEndpointProject = project
+
+lazy val justATransitiveDependencyProject = project
+  .dependsOn(justATransiviteDependencyEndpointProject)
+
+lazy val justADependencyProject = project
+
+lazy val test_project = project
+    .dependsOn(justADependencyProject, justATransitiveDependencyProject)
+    .settings(
+      TaskKey[Unit]("check") := {
+        val dotFile = (dependencyDot in Compile).value
+        val expectedGraph =
+          """digraph "dependency-graph" {
+            |    graph[rankdir="LR"]
+            |    edge [
+            |        arrowtail="none"
+            |    ]
+            |    "justadependencyproject:justadependencyproject_2.9.2:0.1-SNAPSHOT"[label=<justadependencyproject<BR/><B>justadependencyproject_2.9.2</B><BR/>0.1-SNAPSHOT> style=""]
+            |    "justatransitivedependencyproject:justatransitivedependencyproject_2.9.2:0.1-SNAPSHOT"[label=<justatransitivedependencyproject<BR/><B>justatransitivedependencyproject_2.9.2</B><BR/>0.1-SNAPSHOT> style=""]
+            |    "justatransivitedependencyendpointproject:justatransivitedependencyendpointproject_2.9.2:0.1-SNAPSHOT"[label=<justatransivitedependencyendpointproject<BR/><B>justatransivitedependencyendpointproject_2.9.2</B><BR/>0.1-SNAPSHOT> style=""]
+            |    "test_project:test_project_2.9.2:0.1-SNAPSHOT"[label=<test_project<BR/><B>test_project_2.9.2</B><BR/>0.1-SNAPSHOT> style=""]
+            |    "justatransitivedependencyproject:justatransitivedependencyproject_2.9.2:0.1-SNAPSHOT" -> "justatransivitedependencyendpointproject:justatransivitedependencyendpointproject_2.9.2:0.1-SNAPSHOT"
+            |    "test_project:test_project_2.9.2:0.1-SNAPSHOT" -> "justadependencyproject:justadependencyproject_2.9.2:0.1-SNAPSHOT"
+            |    "test_project:test_project_2.9.2:0.1-SNAPSHOT" -> "justatransitivedependencyproject:justatransitivedependencyproject_2.9.2:0.1-SNAPSHOT"
+            |}
+          """.stripMargin
+
+        val graph : String = scala.io.Source.fromFile(dotFile.getAbsolutePath).mkString
+        val errors = compareByLine(graph, expectedGraph)
+        require(errors.isEmpty , errors.mkString("\n"))
+        ()
+      }
+    )
+
+def compareByLine(got : String, expected : String) : Seq[String] = {
+  val errors = ListBuffer[String]()
+  got.split("\n").zip(expected.split("\n").toSeq).zipWithIndex.foreach { case((got_line : String, expected_line : String), i : Int) =>
+    if(got_line != expected_line) {
+      errors.append(
+        """not matching lines at line %s
+          |expected: %s
+          |got:      %s
+          |""".stripMargin.format(i,expected_line, got_line))
+    }
+  }
+  errors
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/project/plugins.sbt b/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/project/plugins.sbt
new file mode 100644
index 000000000..93c66d2a9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/project/plugins.sbt
@@ -0,0 +1 @@
+addDependencyTreePlugin
diff --git a/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/test b/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/test
new file mode 100644
index 000000000..cc5aac014
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/testDotFileGeneration/test
@@ -0,0 +1 @@
+> test_project/check
diff --git a/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/build.sbt b/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/build.sbt
new file mode 100644
index 000000000..bd4cf6257
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/build.sbt
@@ -0,0 +1,156 @@
+import scala.collection.mutable.ListBuffer
+
+ThisBuild / scalaVersion := "2.9.2"
+ThisBuild / version := "0.1-SNAPSHOT"
+
+lazy val justATransiviteDependencyEndpointProject = project
+
+lazy val justATransitiveDependencyProject = project
+  .dependsOn(justATransiviteDependencyEndpointProject)
+
+lazy val justADependencyProject = project
+
+lazy val test_project = project
+    .dependsOn(justADependencyProject, justATransitiveDependencyProject)
+    .settings(
+      TaskKey[Unit]("check") := {
+        val htmlFile = (dependencyBrowseGraphHTML in Compile).value
+        val expectedHtml =
+          """<!doctype html>
+            |
+            |<!--
+            |
+            |Based on https://github.com/cpettitt/dagre-d3/blob/d215446e7e40ebfca303f4733e746e96420e3b46/demo/interactive-demo.html
+            |which is published under this license:
+            |
+            |Copyright (c) 2013 Chris Pettitt
+            |
+            |Permission is hereby granted, free of charge, to any person obtaining a copy
+            |of this software and associated documentation files (the "Software"), to deal
+            |in the Software without restriction, including without limitation the rights
+            |to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+            |copies of the Software, and to permit persons to whom the Software is
+            |furnished to do so, subject to the following conditions:
+            |
+            |The above copyright notice and this permission notice shall be included in
+            |all copies or substantial portions of the Software.
+            |
+            |THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+            |IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+            |FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+            |AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+            |LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+            |OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+            |THE SOFTWARE.
+            |
+            |-->
+            |
+            |<meta charset="utf-8">
+            |<title>Dependency Graph</title>
+            |
+            |<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.17/d3.min.js"></script>
+            |<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
+            |<script src="https://cdnjs.cloudflare.com/ajax/libs/dagre-d3/0.4.16/dagre-d3.min.js"></script>
+            |<script src="https://dagrejs.github.io/project/graphlib-dot/v0.6.3/graphlib-dot.min.js"></script>
+            |<script src="dependencies.dot.js"></script>
+            |
+            |<style>
+            |    body {
+            |        margin: 0;
+            |        overflow: hidden;
+            |    }
+            |    .node {
+            |        white-space: nowrap;
+            |    }
+            |
+            |    .node rect,
+            |    .node circle,
+            |    .node ellipse {
+            |        stroke: #333;
+            |        fill: #fff;
+            |        stroke-width: 1.5px;
+            |    }
+            |
+            |    .cluster rect {
+            |        stroke: #333;
+            |        fill: #000;
+            |        fill-opacity: 0.1;
+            |        stroke-width: 1.5px;
+            |    }
+            |
+            |    .edgePath path.path {
+            |        stroke: #333;
+            |        stroke-width: 1.5px;
+            |        fill: none;
+            |    }
+            |</style>
+            |
+            |<style>
+            |    h1, h2 {
+            |        color: #333;
+            |    }
+            |</style>
+            |
+            |<body onLoad="initialize()">
+            |
+            |<svg width=1280 height=1024>
+            |    <g/>
+            |</svg>
+            |
+            |<script>
+            |function initialize() {
+            |    // Set up zoom support
+            |    var svg = d3.select("svg"),
+            |        inner = d3.select("svg g"),
+            |        zoom = d3.behavior.zoom().on("zoom", function() {
+            |          inner.attr("transform", "translate(" + d3.event.translate + ")" +
+            |                                      "scale(" + d3.event.scale + ")");
+            |        });
+            |    svg.attr("width", window.innerWidth);
+            |
+            |    svg.call(zoom);
+            |    // Create and configure the renderer
+            |    var render = dagreD3.render();
+            |    function tryDraw(inputGraph) {
+            |      var g;
+            |      {
+            |        g = graphlibDot.read(inputGraph);
+            |        g.graph().rankdir = "LR";
+            |        d3.select("svg g").call(render, g);
+            |
+            |        // Center the graph
+            |        var initialScale = 0.10;
+            |        zoom
+            |          .translate([(svg.attr("width") - g.graph().width * initialScale) / 2, 20])
+            |          .scale(initialScale)
+            |          .event(svg);
+            |        svg.attr('height', g.graph().height * initialScale + 40);
+            |      }
+            |    }
+            |    tryDraw(decodeURIComponent(data));
+            |}
+            |</script>
+            |</body>
+            |
+          """.stripMargin
+
+        val html : String = scala.io.Source.fromFile(htmlFile).mkString
+        val errors = compareByLine(html, expectedHtml)
+        require(errors.isEmpty , errors.mkString("\n"))
+        ()
+      }
+    )
+
+def compareByLine(got : String, expected : String) : Seq[String] = {
+  val errors = ListBuffer[String]()
+  got.split("\n").zip(expected.split("\n").toSeq).zipWithIndex.foreach { case((got_line : String, expected_line : String), i : Int) =>
+    if(got_line != expected_line) {
+      errors.append(
+        """not matching lines at line %s
+          |expected: %s
+          |got:      %s
+          |""".stripMargin.format(i,expected_line, got_line))
+    }
+  }
+  errors
+}
diff --git a/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/project/plugins.sbt b/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/project/plugins.sbt
new file mode 100644
index 000000000..93c66d2a9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/project/plugins.sbt
@@ -0,0 +1 @@
+addDependencyTreePlugin
diff --git a/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/test b/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/test
new file mode 100644
index 000000000..cc5aac014
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/testHtmlFileGeneration/test
@@ -0,0 +1 @@
+> test_project/check
diff --git a/sbt/src/sbt-test/dependency-graph/toFileSubTask/build.sbt b/sbt/src/sbt-test/dependency-graph/toFileSubTask/build.sbt
new file mode 100644
index 000000000..6b66e7321
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/toFileSubTask/build.sbt
@@ -0,0 +1,21 @@
+// ThisBuild / useCoursier := false
+ThisBuild / scalaVersion := "2.12.6"
+ThisBuild / organization := "org.example"
+ThisBuild / version := "0.1"
+
+name := "blubber"
+libraryDependencies += "org.typelevel" %% "cats-effect" % "2.2.0"
+TaskKey[Unit]("check") := {
+  val candidates = "tree list stats licenses".split(' ').map(_.trim)
+  candidates.foreach { c =>
+    val expected = new File(s"expected/$c.txt")
+    val actual = new File(s"target/$c.txt")
+
+    import sys.process._
+    val exit = s"diff -U3 ${expected.getPath} ${actual.getPath}".!
+    require(exit == 0, s"Diff was non-zero for ${actual.getName}")
+  }
+
+  //require(sanitize(graph) == sanitize(expectedGraph), "Graph for report %s was '\n%s' but should have been '\n%s'" format (report, sanitize(graph), sanitize(expectedGraph)))
+  ()
+}
diff --git a/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/licenses.txt b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/licenses.txt
new file mode 100644
index 000000000..87c4c5e6c
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/licenses.txt
@@ -0,0 +1,9 @@
+No license specified
+	 org.example:blubber_2.12:0.1
+
+Apache-2.0
+	 org.typelevel:cats-effect_2.12:2.2.0
+
+MIT
+	 org.typelevel:cats-core_2.12:2.2.0
+	 org.typelevel:cats-kernel_2.12:2.2.0
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/list.txt b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/list.txt
new file mode 100644
index 000000000..1a356d64b
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/list.txt
@@ -0,0 +1,4 @@
+org.example:blubber_2.12:0.1
+org.typelevel:cats-core_2.12:2.2.0
+org.typelevel:cats-effect_2.12:2.2.0
+org.typelevel:cats-kernel_2.12:2.2.0
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/stats.txt b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/stats.txt
new file mode 100644
index 000000000..3f3c415f0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/stats.txt
@@ -0,0 +1,12 @@
+   TotSize    JarSize #TDe #Dep Module
+ 11.177 MB ------- MB    3    1 org.example:blubber_2.12:0.1
+ 11.177 MB   1.185 MB    2    1 org.typelevel:cats-effect_2.12:2.2.0
+  9.992 MB   5.034 MB    1    1 org.typelevel:cats-core_2.12:2.2.0
+  4.958 MB   4.958 MB    0    0 org.typelevel:cats-kernel_2.12:2.2.0
+
+Columns are
+ - Jar-Size including dependencies
+ - Jar-Size
+ - Number of transitive dependencies
+ - Number of direct dependencies
+ - ModuleID
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/tree.txt b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/tree.txt
new file mode 100644
index 000000000..d639a0acb
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/toFileSubTask/expected/tree.txt
@@ -0,0 +1,5 @@
+org.example:blubber_2.12:0.1 [S]
+  +-org.typelevel:cats-effect_2.12:2.2.0 [S]
+    +-org.typelevel:cats-core_2.12:2.2.0 [S]
+      +-org.typelevel:cats-kernel_2.12:2.2.0 [S]
+      
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/toFileSubTask/project/plugins.sbt b/sbt/src/sbt-test/dependency-graph/toFileSubTask/project/plugins.sbt
new file mode 100644
index 000000000..93c66d2a9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/toFileSubTask/project/plugins.sbt
@@ -0,0 +1 @@
+addDependencyTreePlugin
diff --git a/sbt/src/sbt-test/dependency-graph/toFileSubTask/test b/sbt/src/sbt-test/dependency-graph/toFileSubTask/test
new file mode 100644
index 000000000..b905a41b8
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/toFileSubTask/test
@@ -0,0 +1,5 @@
+> dependencyTree/toFile target/tree.txt
+> dependencyList/toFile target/list.txt
+> dependencyStats/toFile target/stats.txt
+> dependencyLicenseInfo/toFile target/licenses.txt
+> check
diff --git a/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/build.sbt b/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/build.sbt
new file mode 100644
index 000000000..0586054cd
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/build.sbt
@@ -0,0 +1,58 @@
+ThisBuild / useCoursier := false
+
+version := "0.1.0-SNAPSHOT"
+
+organization := "default"
+
+name := "whatDependsOn"
+
+scalaVersion := "2.9.1"
+
+resolvers += "typesafe maven" at "https://repo.typesafe.com/typesafe/maven-releases/"
+
+libraryDependencies ++= Seq(
+  "com.codahale" % "jerkson_2.9.1" % "0.5.0",
+  "org.codehaus.jackson" % "jackson-mapper-asl" % "1.9.10" // as another version of asl
+)
+
+val check = TaskKey[Unit]("check")
+
+check := {
+  def sanitize(str: String): String = str.split('\n').map(_.trim).mkString("\n")
+  def checkOutput(output: String, expected: String): Unit =
+    require(sanitize(expected) == sanitize(output), s"Tree should have been [\n${sanitize(expected)}\n] but was [\n${sanitize(output)}\n]")
+
+  val withVersion =
+    (whatDependsOn in Compile)
+      .toTask(" org.codehaus.jackson jackson-core-asl 1.9.11")
+      .value
+  val expectedGraphWithVersion =
+    """org.codehaus.jackson:jackson-core-asl:1.9.11
+      |  +-com.codahale:jerkson_2.9.1:0.5.0 [S]
+      |  | +-default:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |  |
+      |  +-org.codehaus.jackson:jackson-mapper-asl:1.9.11
+      |    +-com.codahale:jerkson_2.9.1:0.5.0 [S]
+      |    | +-default:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |    |
+      |    +-default:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |  """.stripMargin
+
+  checkOutput(withVersion, expectedGraphWithVersion)
+
+  val withoutVersion =
+    (whatDependsOn in Compile)
+      .toTask(" org.codehaus.jackson jackson-mapper-asl")
+      .value
+  val expectedGraphWithoutVersion =
+    """org.codehaus.jackson:jackson-mapper-asl:1.9.11
+      | +-com.codahale:jerkson_2.9.1:0.5.0 [S]
+      | | +-default:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      | |
+      | +-default:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |
+      |org.codehaus.jackson:jackson-mapper-asl:1.9.10 (evicted by: 1.9.11)
+      | +-default:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |   """.stripMargin
+  checkOutput(withoutVersion, expectedGraphWithoutVersion)
+}
diff --git a/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/project/plugins.sbt b/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/project/plugins.sbt
new file mode 100644
index 000000000..93c66d2a9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/project/plugins.sbt
@@ -0,0 +1 @@
+addDependencyTreePlugin
diff --git a/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/test b/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/test
new file mode 100644
index 000000000..ddc84434f
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/test
@@ -0,0 +1,2 @@
+# same as whatDependsOn test but without the initialization to prime the parser
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-graph/whatDependsOn/build.sbt b/sbt/src/sbt-test/dependency-graph/whatDependsOn/build.sbt
new file mode 100644
index 000000000..8b3a0d5e1
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/whatDependsOn/build.sbt
@@ -0,0 +1,54 @@
+ThisBuild / version := "0.1.0-SNAPSHOT"
+ThisBuild / scalaVersion := "2.9.1"
+
+name := "whatDependsOn"
+
+resolvers += "typesafe maven" at "https://repo.typesafe.com/typesafe/maven-releases/"
+
+libraryDependencies ++= Seq(
+  "com.codahale" % "jerkson_2.9.1" % "0.5.0",
+  "org.codehaus.jackson" % "jackson-mapper-asl" % "1.9.10" // as another version of asl
+)
+
+val check = TaskKey[Unit]("check")
+
+check := {
+  def sanitize(str: String): String = str.split('\n').map(_.trim).mkString("\n")
+  def checkOutput(output: String, expected: String): Unit =
+    require(sanitize(expected) == sanitize(output), s"Tree should have been [\n${sanitize(expected)}\n] but was [\n${sanitize(output)}\n]")
+
+  val withVersion =
+    (whatDependsOn in Compile)
+      .toTask(" org.codehaus.jackson jackson-core-asl 1.9.10")
+      .value
+  val expectedGraphWithVersion =
+    """org.codehaus.jackson:jackson-core-asl:1.9.10
+      |  +-com.codahale:jerkson_2.9.1:0.5.0 [S]
+      |  | +-whatdependson:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |  |
+      |  +-org.codehaus.jackson:jackson-mapper-asl:1.9.10
+      |    +-com.codahale:jerkson_2.9.1:0.5.0 [S]
+      |    | +-whatdependson:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |    |
+      |    +-whatdependson:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |  """.stripMargin
+
+  checkOutput(withVersion, expectedGraphWithVersion)
+
+  val withoutVersion =
+    (whatDependsOn in Compile)
+      .toTask(" org.codehaus.jackson jackson-mapper-asl")
+      .value
+  val expectedGraphWithoutVersion =
+    """org.codehaus.jackson:jackson-mapper-asl:1.9.10
+      | +-com.codahale:jerkson_2.9.1:0.5.0 [S]
+      | | +-whatdependson:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      | |
+      | +-whatdependson:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |
+      |org.codehaus.jackson:jackson-mapper-asl:[1.9.0,2.0.0) (evicted by: 1.9.10)
+      | +-com.codahale:jerkson_2.9.1:0.5.0 [S]
+      | +-whatdependson:whatdependson_2.9.1:0.1.0-SNAPSHOT [S]
+      |   """.stripMargin
+  checkOutput(withoutVersion, expectedGraphWithoutVersion)
+}
diff --git a/sbt/src/sbt-test/dependency-graph/whatDependsOn/project/plugins.sbt b/sbt/src/sbt-test/dependency-graph/whatDependsOn/project/plugins.sbt
new file mode 100644
index 000000000..93c66d2a9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/whatDependsOn/project/plugins.sbt
@@ -0,0 +1 @@
+addDependencyTreePlugin
diff --git a/sbt/src/sbt-test/dependency-graph/whatDependsOn/test b/sbt/src/sbt-test/dependency-graph/whatDependsOn/test
new file mode 100644
index 000000000..111738e33
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-graph/whatDependsOn/test
@@ -0,0 +1,3 @@
+# to initialize parser with deps
+> Compile/dependencyTreeModuleGraph0
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt b/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt
new file mode 100644
index 000000000..67a22204e
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt
@@ -0,0 +1,6 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+libraryDependencies += ("com.rengwuxian.materialedittext" % "library" % "2.1.4")
+  .exclude("com.android.support", "support-v4")
+  .exclude("com.android.support", "support-annotations")
+  .exclude("com.android.support", "appcompat-v7")
diff --git a/sbt/src/sbt-test/dependency-management/aar-packaging/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/aar-packaging/src/main/scala/Main.scala
new file mode 100644
index 000000000..61295349d
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/aar-packaging/src/main/scala/Main.scala
@@ -0,0 +1,6 @@
+import java.io.File
+import java.nio.file.Files
+
+object Main extends App {
+  Files.write(new File("output").toPath, "OK".getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/aar-packaging/test b/sbt/src/sbt-test/dependency-management/aar-packaging/test
new file mode 100644
index 000000000..2182f57b0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/aar-packaging/test
@@ -0,0 +1,3 @@
+$ delete output
+> run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/artifact/build.sbt b/sbt/src/sbt-test/dependency-management/artifact/build.sbt
index 9307e2f78..d0d5afc46 100644
--- a/sbt/src/sbt-test/dependency-management/artifact/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/artifact/build.sbt
@@ -1,23 +1,50 @@
 import sbt.internal.inc.classpath.ClasspathUtilities
+import xsbti.AppConfiguration
 
 lazy val checkFull = taskKey[Unit]("")
 lazy val check = taskKey[Unit]("")
+lazy val checkArtifact = taskKey[Unit]("")
 
-lazy val root = (project in file(".")).
-  settings(
-    ivyPaths := ((baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache")))).value,
+ThisBuild / useCoursier := false
+ThisBuild / scalaVersion     := "2.12.12"
+ThisBuild / version          := "0.1.0-SNAPSHOT"
+ThisBuild / organization     := "com.example"
+ThisBuild / organizationName := "example"
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+lazy val Dev = config("dev").extend(Compile)
+  .describedAs("Dependencies required for development environments")
+
+lazy val root = (project in file("."))
+  .configs(Dev)
+  .settings(
+    ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
     publishTo := Some(Resolver.file("Test Publish Repo", file("test-repo"))),
-    resolvers += (baseDirectory { base => "Test Repo" at (base / "test-repo").toURI.toString }).value,
+    scalaCompilerBridgeResolvers += userLocalFileResolver(appConfiguration.value),
+    resolvers += baseDirectory { base => "Test Repo" at (base / "test-repo").toURI.toString }.value,
     moduleName := artifactID,
-    projectID := (baseDirectory { base => (if(base / "retrieve" exists) retrieveID else publishedID) }).value,
+    projectID := (if (baseDirectory.value / "retrieve" exists) retrieveID else publishedID),
     artifact in (Compile, packageBin) := mainArtifact,
-    libraryDependencies := ((libraryDependencies, baseDirectory) { (deps, base) =>
-      deps ++ (if(base / "retrieve" exists) publishedID :: Nil else Nil) }).value,
+    libraryDependencies ++= (if (baseDirectory.value / "retrieve" exists) publishedID :: Nil else Nil),
       // needed to add a jar with a different type to the managed classpath
-    unmanagedClasspath in Compile += scalaInstance.map(_.libraryJar).value,
+    unmanagedClasspath in Compile ++= scalaInstance.value.libraryJars.toSeq,
     classpathTypes := Set(tpe),
+
+    // custom configuration artifacts
+    inConfig(Dev)(Defaults.compileSettings),
+    addArtifact(Dev / packageBin / artifact, Dev / packageBin),
+    addArtifact(Dev / packageDoc / artifact, Dev / packageDoc),
+    addArtifact(Dev / packageSrc / artifact, Dev / packageSrc),
+    Dev / publishArtifact := true,
     check := checkTask(dependencyClasspath).value,
-    checkFull := checkTask(fullClasspath).value
+    checkFull := checkTask(fullClasspath).value,
+    checkArtifact := {
+      val d = (Dev / packageSrc / artifact).value
+      assert(d.`type` == "src", s"${d.`type`} is not src")
+
+      val t = (Test / packageSrc / artifact).value
+      assert(t.`type` == "src", s"${t.`type`} is not src")
+    }
   )
 
 // define strings for defining the artifact
@@ -35,8 +62,16 @@ def publishedID = org % artifactID % vers artifacts(mainArtifact)
 def retrieveID = org % "test-retrieve" % "2.0"
 
 // check that the test class is on the compile classpath, either because it was compiled or because it was properly retrieved
-def checkTask(classpath: TaskKey[Classpath]) = (classpath in Compile, scalaInstance) map { (cp, si) =>
-  val loader = ClasspathUtilities.toLoader(cp.files, si.loader)
+def checkTask(classpath: TaskKey[Classpath]) = Def.task {
+  val deps = libraryDependencies.value
+  val cp = (classpath in Compile).value.files
+  val loader = ClasspathUtilities.toLoader(cp, scalaInstance.value.loader)
   try { Class.forName("test.Test", false, loader); () }
-  catch { case _: ClassNotFoundException | _: NoClassDefFoundError => sys.error("Dependency not retrieved properly") }
+  catch { case _: ClassNotFoundException | _: NoClassDefFoundError => sys.error(s"Dependency not retrieved properly: $deps, $cp") }
+}
+
+// use the user local resolver to fetch the SNAPSHOT version of the compiler-bridge
+def userLocalFileResolver(appConfig: AppConfiguration): Resolver = {
+  val ivyHome = appConfig.provider.scalaProvider.launcher.ivyHome
+  Resolver.file("User Local", ivyHome / "local")(Resolver.defaultIvyPatterns)
 }
diff --git a/sbt/src/sbt-test/dependency-management/artifact/test b/sbt/src/sbt-test/dependency-management/artifact/test
index e944dd35b..27b8e52f3 100644
--- a/sbt/src/sbt-test/dependency-management/artifact/test
+++ b/sbt/src/sbt-test/dependency-management/artifact/test
@@ -15,5 +15,7 @@
 $ touch retrieve
 > reload
 
-# verify that artifact with extension, type, and classifier can be retreieved
+# verify that artifact with extension, type, and classifier can be retrieved
 > check
+
+> checkArtifact
diff --git a/sbt/src/sbt-test/dependency-management/auto-scala-library/build.sbt b/sbt/src/sbt-test/dependency-management/auto-scala-library/build.sbt
new file mode 100644
index 000000000..20969e7e5
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/auto-scala-library/build.sbt
@@ -0,0 +1,20 @@
+autoScalaLibrary := false
+libraryDependencies += "com.chuusai" % "shapeless_2.12" % "2.3.2"
+
+val checkScalaLibrary = TaskKey[Unit]("checkScalaLibrary")
+
+checkScalaLibrary := {
+  val scalaLibsJars = managedClasspath
+    .in(Compile)
+    .value
+    .map(_.data.getName)
+    .filter(_.startsWith("scala-library"))
+    .sorted
+  val expectedScalaLibsJars = Seq(
+    "scala-library-2.12.0.jar"
+  )
+  assert(
+    scalaLibsJars == expectedScalaLibsJars,
+    s"$scalaLibsJars != $expectedScalaLibsJars"
+  )
+}
diff --git a/sbt/src/sbt-test/dependency-management/auto-scala-library/test b/sbt/src/sbt-test/dependency-management/auto-scala-library/test
new file mode 100644
index 000000000..f56f5a75e
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/auto-scala-library/test
@@ -0,0 +1 @@
+> checkScalaLibrary
diff --git a/sbt/src/sbt-test/dependency-management/cache-classifiers/a/build.sbt b/sbt/src/sbt-test/dependency-management/cache-classifiers/a/build.sbt
deleted file mode 100644
index 6a81f8446..000000000
--- a/sbt/src/sbt-test/dependency-management/cache-classifiers/a/build.sbt
+++ /dev/null
@@ -1,11 +0,0 @@
-organization := "org.example"
-
-name := "artifacta"
-
-version := "1.0.0-SNAPSHOT"
-
-publishArtifact in (Test,packageBin) := true
-
-publishTo := Some(MavenCache("demo", ((baseDirectory in ThisBuild).value / "demo-repo")))
-
-//Resolver.file("demo", (baseDirectory in ThisBuild).value / "demo-repo"))
diff --git a/sbt/src/sbt-test/dependency-management/cache-classifiers/b/build.sbt b/sbt/src/sbt-test/dependency-management/cache-classifiers/b/build.sbt
deleted file mode 100644
index b57c5eff7..000000000
--- a/sbt/src/sbt-test/dependency-management/cache-classifiers/b/build.sbt
+++ /dev/null
@@ -1,7 +0,0 @@
-libraryDependencies += "org.example" %% "artifacta" % "1.0.0-SNAPSHOT" withSources() classifier("tests")
-
-externalResolvers := Seq(
-	MavenCache("demo", ((baseDirectory in ThisBuild).value / "demo-repo")),
-	DefaultMavenRepository
-)
-
diff --git a/sbt/src/sbt-test/dependency-management/cache-classifiers/changes/B.scala b/sbt/src/sbt-test/dependency-management/cache-classifiers/changes/B.scala
index 6ba7a4620..2da077284 100644
--- a/sbt/src/sbt-test/dependency-management/cache-classifiers/changes/B.scala
+++ b/sbt/src/sbt-test/dependency-management/cache-classifiers/changes/B.scala
@@ -1,3 +1,3 @@
-object B { 
+object B {
   val y = A.x
 }
diff --git a/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt b/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt
index b330dbad9..69771b0b8 100644
--- a/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt
@@ -1,6 +1,37 @@
-def localCache = 
-	ivyPaths := new IvyPaths(baseDirectory.value, Some((baseDirectory in ThisBuild).value / "ivy" / "cache"))
+import xsbti.AppConfiguration
 
-val b = project.settings(localCache)
+ThisBuild / scalaVersion := "2.12.12"
 
-val a = project.settings(localCache)
+// TTL of Coursier is 24h
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+def localCache =
+	ivyPaths := IvyPaths(baseDirectory.value, Some((baseDirectory in ThisBuild).value / "ivy" / "cache"))
+
+val b = project
+  .settings(
+    localCache,
+    libraryDependencies += "org.example" %% "artifacta" % "1.0.0-SNAPSHOT" withSources() classifier("tests"),
+    scalaCompilerBridgeResolvers += userLocalFileResolver(appConfiguration.value),
+    externalResolvers := Vector(
+      MavenCache("demo", ((baseDirectory in ThisBuild).value / "demo-repo")),
+      DefaultMavenRepository
+    )
+  )
+
+val a = project
+  .settings(
+    localCache,
+    organization := "org.example",
+    name := "artifacta",
+    version := "1.0.0-SNAPSHOT",
+    publishArtifact in (Test,packageBin) := true,
+    publishTo := Some(MavenCache("demo", ((baseDirectory in ThisBuild).value / "demo-repo")))
+  )
+
+// use the user local resolver to fetch the SNAPSHOT version of the compiler-bridge
+def userLocalFileResolver(appConfig: AppConfiguration): Resolver = {
+  val ivyHome = appConfig.provider.scalaProvider.launcher.ivyHome
+  Resolver.file("User Local", ivyHome / "local")(Resolver.defaultIvyPatterns)
+}
diff --git a/sbt/src/sbt-test/dependency-management/cache-local/cache.sbt b/sbt/src/sbt-test/dependency-management/cache-local/cache.sbt
index 70b089e70..0623e2bce 100644
--- a/sbt/src/sbt-test/dependency-management/cache-local/cache.sbt
+++ b/sbt/src/sbt-test/dependency-management/cache-local/cache.sbt
@@ -1 +1,2 @@
-ivyPaths := { new IvyPaths(baseDirectory.value, Some(target.value / ".ivy2")) }
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+ivyPaths := { IvyPaths(baseDirectory.value, Some(target.value / ".ivy2")) }
diff --git a/sbt/src/sbt-test/dependency-management/cache-resolver/cache.sbt b/sbt/src/sbt-test/dependency-management/cache-resolver/cache.sbt
index 1949b7de3..699a01ea0 100644
--- a/sbt/src/sbt-test/dependency-management/cache-resolver/cache.sbt
+++ b/sbt/src/sbt-test/dependency-management/cache-resolver/cache.sbt
@@ -1,7 +1,8 @@
-ivyPaths in ThisBuild := {
-	val base = (baseDirectory in ThisBuild).value
-	new IvyPaths(base, Some(base / "ivy-cache"))
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+ThisBuild / ivyPaths := {
+	val base = (ThisBuild / baseDirectory).value
+	IvyPaths(base, Some(base / "ivy-cache"))
 }
-managedScalaInstance in ThisBuild := false
-autoScalaLibrary in ThisBuild := false
-crossPaths in ThisBuild := false
+ThisBuild / managedScalaInstance := false
+ThisBuild / autoScalaLibrary  := false
+ThisBuild / crossPaths := false
diff --git a/sbt/src/sbt-test/dependency-management/cache-resolver/test b/sbt/src/sbt-test/dependency-management/cache-resolver/test
index ad07c2221..276a31136 100644
--- a/sbt/src/sbt-test/dependency-management/cache-resolver/test
+++ b/sbt/src/sbt-test/dependency-management/cache-resolver/test
@@ -32,7 +32,7 @@ $ copy-file changes/def/Def.java b/Def.java
 
 
 # Resolve from local again.  This will succeed, but the jars
-#  won't be on the classpath if the resolver isn't ignoredy.
+#  won't be on the classpath if the resolver isn't ignored.
 
 $ delete build.sbt
 $ delete b/Def.java
diff --git a/sbt/src/sbt-test/dependency-management/cache-update/build.sbt b/sbt/src/sbt-test/dependency-management/cache-update/build.sbt
index d2a434add..47d24a502 100644
--- a/sbt/src/sbt-test/dependency-management/cache-update/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/cache-update/build.sbt
@@ -1,33 +1,109 @@
-import sbt.internal.librarymanagement._
+ThisBuild / scalaVersion        := "2.10.4"
+ThisBuild / dependencyOverrides += "com.github.nscala-time" %% "nscala-time" % "1.0.0"
+ThisBuild / csrCacheDirectory   := (ThisBuild / baseDirectory).value / "coursier-cache"
 
-lazy val check = taskKey[Unit]("Runs the check")
-
-def commonSettings: Seq[Def.Setting[_]] =
-  Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
-    scalaVersion := "2.10.4",
-    resolvers += Resolver.sonatypeRepo("snapshots")
-  )
-
-// #1620
-lazy val root = (project in file(".")).
-  settings(
-    dependencyOverrides in ThisBuild += "com.github.nscala-time" %% "nscala-time" % "1.0.0",
+lazy val root = (project in file("."))
+  .dependsOn(p1 % Compile)
+  .settings(
+    inThisBuild(List(
+      organizationName := "eed3si9n",
+      organizationHomepage := Some(url("http://example.com/")),
+      homepage := Some(url("https://github.com/example/example")),
+      scmInfo := Some(ScmInfo(url("https://github.com/example/example"), "git@github.com:example/example.git")),
+      developers := List(
+        Developer("harrah", "Mark Harrah", "@harrah", url("https://github.com/harrah")),
+        Developer("eed3si9n", "Eugene Yokota", "@eed3si9n", url("https://github.com/eed3si9n")),
+        Developer("jsuereth", "Josh Suereth", "@jsuereth", url("https://github.com/jsuereth")),
+        Developer("dwijnand", "Dale Wijnand", "@dwijnand", url("https://github.com/dwijnand")),
+        Developer("gkossakowski", "Grzegorz Kossakowski", "@gkossakowski", url("https://github.com/gkossakowski")),
+        Developer("Duhemm", "Martin Duhem", "@Duhemm", url("https://github.com/Duhemm"))
+      ),
+      version := "0.3.1-SNAPSHOT",
+      description := "An HTTP client for Scala with Async Http Client underneath.",
+      licenses := Seq("Apache 2" -> new URL("http://www.apache.org/licenses/LICENSE-2.0.txt")),
+    )),
+    ivyPaths := IvyPaths(
+      (baseDirectory in ThisBuild).value,
+      Some((baseDirectory in LocalRootProject).value / "ivy-cache")
+    ),
     libraryDependencies += "com.github.nscala-time" %% "nscala-time" % "1.0.0",
-    check := {
-      import Cache._, CacheIvy.updateIC
-      implicit val updateCache = updateIC
-      type In = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil
+
+    // https://github.com/sbt/sbt/pull/1620
+    // sbt resolves dependencies every compile when using %% with dependencyOverrides
+    TaskKey[Unit]("check") := {
       val s = (streams in update).value
-      val cacheFile = s.cacheDirectory / updateCacheName.value
+
+      val cacheDirectory = crossTarget.value / "update" / updateCacheName.value
+      val cacheStoreFactory = sbt.util.CacheStoreFactory.directory(cacheDirectory)
       val module = ivyModule.value
-      val config = updateConfiguration.value
+      val updateConfig = updateConfiguration.value
+      val extraInputHash0 = module.extraInputHash
+      val moduleSettings0 = module.moduleSettings
+      val inline0 = moduleSettings0 match { case x: InlineConfiguration => x }
+      // Remove clock for caching purpose
+      val updateConfig0 = updateConfig
+        .withLogicalClock(LogicalClock.unknown)
+        .withMetadataDirectory(dependencyCacheDirectory.value)
+
+      import sbt.librarymanagement.{ ModuleSettings, UpdateConfiguration, LibraryManagementCodec }
+      type In = (Long, ModuleSettings, UpdateConfiguration)
+
+      import LibraryManagementCodec._
+
       val f: In => Unit =
-        Tracked.inputChanged(cacheFile / "inputs") { (inChanged: Boolean, in: In) =>
+        Tracked.inputChanged(cacheStoreFactory make "inputs") { (inChanged: Boolean, in: In) =>
+          val extraInputHash1 = in._1
+          val moduleSettings1 = in._2
+          val inline1 = moduleSettings1 match { case x: InlineConfiguration => x }
+          val updateConfig1 = in._3
+
           if (inChanged) {
-            sys.error(s"Update cache is invalidated: ${module.owner.configuration}, ${module.moduleSettings}, $config")
+            sys.error(s"""
+extraInputHash1 == extraInputHash0: ${extraInputHash1 == extraInputHash0}
+
+extraInputHash1:
+$extraInputHash1
+
+extraInputHash0
+$extraInputHash0
+-----
+inline1 == inline0: ${inline1 == inline0}
+
+inline1:
+$inline1
+
+inline0
+$inline0
+-----
+updateConfig1 == updateConfig0: ${updateConfig1 == updateConfig0}
+
+updateConfig1:
+$updateConfig1
+
+updateConfig0
+$updateConfig0
+""")
           }
         }
-      f(module.owner.configuration :+: module.moduleSettings :+: config :+: HNil)
+
+      f((extraInputHash0, (inline0: ModuleSettings), updateConfig0))
+    },
+
+    // https://github.com/sbt/sbt/issues/3226
+    // update caching is not working on sbt 1.0.x
+    TaskKey[Unit]("check2") := {
+      val ur = update.value
+      if (!ur.stats.cached) {
+        sys.error(s"update.value is not cached! $ur")
+      }
+      val tu = transitiveUpdate.value
+      if (tu.exists(!_.stats.cached)) {
+        sys.error(s"uncached transitiveUpdate exists! $tu")
+      }
     }
   )
+
+lazy val p1 = project
+  .settings(
+    libraryDependencies += "com.novocode" % "junit-interface" % "0.11"
+  )
diff --git a/sbt/src/sbt-test/dependency-management/cache-update/test b/sbt/src/sbt-test/dependency-management/cache-update/test
index e3bd83da1..086420496 100644
--- a/sbt/src/sbt-test/dependency-management/cache-update/test
+++ b/sbt/src/sbt-test/dependency-management/cache-update/test
@@ -1,2 +1,6 @@
 > compile
+$ sleep 2000
 > check
+$ sleep 2000
+> check
+> check2
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-circular/changes/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-circular/changes/multi.sbt
index b802f3e21..8b81f831e 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-circular/changes/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-circular/changes/multi.sbt
@@ -6,9 +6,11 @@ val summingbirdVersion = "0.4.0"
 val luceneVersion = "4.0.0"
 val akkaVersion = "2.3.1"
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
     scalaVersion := "2.10.4",
     fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project"),
     updateOptions := updateOptions.value.withCachedResolution(true)
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-circular/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-circular/multi.sbt
index a17acd76d..acd0593cf 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-circular/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-circular/multi.sbt
@@ -6,9 +6,11 @@ val summingbirdVersion = "0.4.0"
 val luceneVersion = "4.0.0"
 val akkaVersion = "2.3.1"
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
     scalaVersion := "2.10.4",
     fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project")
   )
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt
index fc62f5603..f9321ed10 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt
@@ -1,8 +1,12 @@
+ThisBuild / useCoursier := false
+
 lazy val check = taskKey[Unit]("Runs the check")
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
     dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
     scalaVersion := "2.10.4",
     resolvers += Resolver.sonatypeRepo("snapshots")
@@ -21,7 +25,7 @@ lazy val transitiveTest = project.
   settings(commonSettings: _*).
   settings(
     libraryDependencies := Seq(
-      "junit" % "junit" % "4.11" % "test"
+      "junit" % "junit" % "4.13.1" % "test"
     )
   )
 
@@ -69,9 +73,9 @@ lazy val root = (project in file(".")).
       if (!(acp contains "commons-io-1.4-sources.jar")) {
         sys.error("commons-io-1.4-sources not found when it should be included: " + acp.toString)
       }
-      if (!(acp contains "commons-io-1.4.jar")) {
-        sys.error("commons-io-1.4 not found when it should be included: " + acp.toString)
-      }
+      // if (!(acp contains "commons-io-1.4.jar")) {
+      //   sys.error("commons-io-1.4 not found when it should be included: " + acp.toString)
+      // }
       
       // stock Ivy implementation doesn't contain regular (non-source) jar, which probably is a bug
       val acpWithoutSource = acp filterNot { _ == "commons-io-1.4.jar"}
@@ -86,7 +90,7 @@ lazy val root = (project in file(".")).
       val atestcp = (externalDependencyClasspath in Test in a).value.map {_.data.getName}.sorted filterNot { _ == "commons-io-1.4.jar"}
       val btestcp = (externalDependencyClasspath in Test in b).value.map {_.data.getName}.sorted filterNot { _ == "commons-io-1.4.jar"}
       val ctestcp = (externalDependencyClasspath in Test in c).value.map {_.data.getName}.sorted filterNot { _ == "demo_2.10.jar"} filterNot { _ == "commons-io-1.4.jar"}
-      if (ctestcp contains "junit-4.11.jar") {
+      if (ctestcp contains "junit-4.13.1.jar") {
         sys.error("junit found when it should be excluded: " + ctestcp.toString)
       }
 
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/test b/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/test
index ccff5f24b..55cfc0713 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/test
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/test
@@ -1,5 +1,3 @@
-> debug
-
 > a/update
 
 > a/updateClassifiers
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/a/A.scala b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/a/A.scala
new file mode 100644
index 000000000..4e33d90d9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/a/A.scala
@@ -0,0 +1,5 @@
+package a
+
+object A {
+	romanowski.sbt.bug.MissingClass("A")
+}
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/b/B.scala b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/b/B.scala
new file mode 100644
index 000000000..acf3023b8
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/b/B.scala
@@ -0,0 +1,5 @@
+package b
+
+object B {
+	romanowski.sbt.bug.MissingClass("A")
+}
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/build.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/build.sbt
new file mode 100644
index 000000000..018bab537
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/build.sbt
@@ -0,0 +1,39 @@
+import xsbti.AppConfiguration
+
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+def commonSettings: Vector[Def.Setting[_]] =
+  Vector(
+    organization := "com.example",
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+    dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
+    scalaCompilerBridgeResolvers += userLocalFileResolver(appConfiguration.value),
+    resolvers += Resolver.file("buggy", (baseDirectory in LocalRootProject).value / "repo")(
+      Patterns(
+        ivyPatterns = Vector("[organization]/[module]/[revision]/ivy.xml"),
+        artifactPatterns = Vector("[organization]/[module]/[revision]/[artifact]"),
+        isMavenCompatible = false,
+        descriptorOptional = true,
+        skipConsistencyCheck = true
+      )
+    )
+  )
+
+lazy val a = project settings(
+  commonSettings,
+  updateOptions := updateOptions.value.withCachedResolution(true), //comment this line to make ws compile
+  libraryDependencies += "a" % "b" % "1.0.0" % "compile->runtime",
+  libraryDependencies += "a" % "b" % "1.0.0" % "compile->runtime2"
+)
+
+lazy val b = project dependsOn(a) settings(
+  commonSettings,
+  updateOptions := updateOptions.value.withCachedResolution(true), //comment this line to make ws compile
+  libraryDependencies += "a" % "b" % "1.0.1" % "compile->runtime"
+)
+
+// use the user local resolver to fetch the SNAPSHOT version of the compiler-bridge
+def userLocalFileResolver(appConfig: AppConfiguration): Resolver = {
+  val ivyHome = appConfig.provider.scalaProvider.launcher.ivyHome
+  Resolver.file("User Local", ivyHome / "local")(Resolver.defaultIvyPatterns)
+}
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b1.jar b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b1.jar
new file mode 100644
index 000000000..619fa9368
Binary files /dev/null and b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b1.jar differ
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b2.jar b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b2.jar
new file mode 100644
index 000000000..619fa9368
Binary files /dev/null and b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b2.jar differ
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b3.jar b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b3.jar
new file mode 100644
index 000000000..1c3f8c4e1
Binary files /dev/null and b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/b3.jar differ
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/ivy.xml b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/ivy.xml
new file mode 100644
index 000000000..19fab2e82
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.0/ivy.xml
@@ -0,0 +1,16 @@
+<ivy-module xmlns:e="http://ant.apache.org/ivy/extra" version="2.0">
+<info organisation="a" module="b" revision="1.0.0" status="release" publication="20160201120702">
+	<description>a</description>
+</info>
+<configurations>
+	<conf name="runtime" description="..."/>
+	<conf name="runtime2" description="..."/>
+</configurations>
+<publications>
+	<artifact name="b1.jar" type="jar" ext="jar" conf="runtime"/>
+	<artifact name="b2.jar" type="jar" ext="jar" conf="runtime"/>
+	<artifact name="b3.jar" type="jar" ext="jar" conf="runtime2"/>
+</publications>
+<dependencies>
+</dependencies>
+</ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b1.jar b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b1.jar
new file mode 100644
index 000000000..619fa9368
Binary files /dev/null and b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b1.jar differ
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b2.jar b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b2.jar
new file mode 100644
index 000000000..619fa9368
Binary files /dev/null and b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b2.jar differ
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b3.jar b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b3.jar
new file mode 100644
index 000000000..1c3f8c4e1
Binary files /dev/null and b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/b3.jar differ
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/ivy.xml b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/ivy.xml
new file mode 100644
index 000000000..a734f26d0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/repo/a/b/1.0.1/ivy.xml
@@ -0,0 +1,16 @@
+<ivy-module xmlns:e="http://ant.apache.org/ivy/extra" version="2.0">
+<info organisation="a" module="b" revision="1.0.1" status="release" publication="20160201120702">
+	<description>a</description>
+</info>
+<configurations>
+	<conf name="runtime" description="..."/>
+	<conf name="runtime2" description="..."/>
+</configurations>
+<publications>
+	<artifact name="b1.jar" type="jar" ext="jar" conf="runtime"/>
+	<artifact name="b2.jar" type="jar" ext="jar" conf="runtime"/>
+	<artifact name="b3.jar" type="jar" ext="jar" conf="runtime2"/>
+</publications>
+<dependencies>
+</dependencies>
+</ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/test b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/test
new file mode 100644
index 000000000..6fdf810e0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-configurations/test
@@ -0,0 +1,11 @@
+# In this test, we have a project `a`, on which a project `b` depends.
+# project `a` has a library dependency on:
+# - "a" % "b" % "1.0.0" % "compile->runtime"
+# - "a" % "b" % "1.0.0" % "compile->runtime2"
+# project "b" depends on:
+# - project `a`
+# - "b" % "b" % "1.0.1" % "compile->runtime"
+# "a" % "b" % "1.0.0" will be evicted in favor of "a" % "b" % "1.0.1", but we
+# have to keep the dependency on the two configurations "runtime" and "runtime2".
+# This test makes sure that we actually do.
+> compile
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/multi.sbt
index d1b098cf3..914681915 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/multi.sbt
@@ -1,68 +1,53 @@
 // https://github.com/sbt/sbt/issues/1710
 // https://github.com/sbt/sbt/issues/1760
-lazy val check = taskKey[Unit]("Runs the check")
 
-def commonSettings: Seq[Def.Setting[_]] =
-  Seq(
-    organization := "com.example",
-    version := "0.1.0",
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
-    dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
-    scalaVersion := "2.10.4",
-    fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project")
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+inThisBuild(Seq(
+  organization := "com.example",
+  version := "0.1.0",
+  scalaVersion := "2.10.4",
+  updateOptions := updateOptions.value.withCachedResolution(true)
+))
+
+def commonSettings: Seq[Def.Setting[_]] = Seq(
+  ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+  dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
+  fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project")
+)
+
+val x1 = project.settings(
+  commonSettings,
+  libraryDependencies += "com.example" %% "y1" % "0.1.0" % "compile;runtime->runtime",
+  libraryDependencies += "com.example" %% "y2" % "0.1.0" % "compile;runtime->runtime"
+)
+
+val y1 = project.settings(
+  commonSettings,
+  libraryDependencies ++= Seq(
+    "com.ning"        % "async-http-client"     % "1.8.14",         // this includes slf4j 1.7.5
+    "com.twitter"     % "summingbird-core_2.10" % "0.5.0",          // this includes slf4j 1.6.6
+    "org.slf4j"       % "slf4j-api"             % "1.6.6" force(),
+    "commons-logging" % "commons-logging"       % "1.1"             // this includes servlet-api 2.3
   )
+)
 
-lazy val X1 = project.
-  settings(
-    commonSettings,
-    libraryDependencies ++= Seq(
-      "com.example" %% "y1" % "0.1.0" % "compile->compile;runtime->runtime",
-      "com.example" %% "y2" % "0.1.0" % "compile->compile;runtime->runtime")
+val y2 = project.settings(
+  commonSettings,
+  libraryDependencies ++= Seq(
+    "com.twitter"     % "summingbird-core_2.10" % "0.5.0",  // this includes slf4j 1.6.6
+    "com.ning"        % "async-http-client"     % "1.8.14", // this includes slf4j 1.7.5
+    "commons-logging" % "commons-logging"       % "1.1.3"
   )
+)
 
-lazy val Y1 = project.
-  settings(
-    commonSettings,
-    name := "y1",
-    libraryDependencies ++= Seq(
-      // this includes slf4j 1.7.5
-      "com.ning" % "async-http-client" % "1.8.14",
-      // this includes slf4j 1.6.6
-      "com.twitter" % "summingbird-core_2.10" % "0.5.0",
-      "org.slf4j" % "slf4j-api" % "1.6.6" force(),
-      // this includes servlet-api 2.3
-      "commons-logging" % "commons-logging" % "1.1"
-    )
-  )
+TaskKey[Unit]("check") := {
+  val x1cp = (externalDependencyClasspath in Compile in x1).value.map(_.data.getName).sorted
+  def x1cpStr = x1cp.mkString("\n* ", "\n* ", "")
 
-lazy val Y2 = project.
-  settings(
-    commonSettings,
-    name := "y2",
-    libraryDependencies ++= Seq(
-      // this includes slf4j 1.6.6
-      "com.twitter" % "summingbird-core_2.10" % "0.5.0",
-      // this includes slf4j 1.7.5
-      "com.ning" % "async-http-client" % "1.8.14",
-      "commons-logging" % "commons-logging" % "1.1.3"
-    )
-  )
+  // if (!(x1cp contains "slf4j-api-1.6.6.jar"))
+  //  sys.error(s"slf4j-api-1.6.6.jar is not found on X1:$x1cpStr")
 
-lazy val root = (project in file(".")).
-  settings(inThisBuild(Seq(
-    organization := "org.example",
-    version := "1.0",
-    updateOptions := updateOptions.value.withCachedResolution(true),
-    check := {
-      val x1cp = (externalDependencyClasspath in Compile in X1).value.map {_.data.getName}.sorted
-      // sys.error("slf4j-api is not found on X1" + x1cp)
-      if (!(x1cp contains "slf4j-api-1.6.6.jar")) {
-        sys.error("slf4j-api-1.6.6.jar is not found on X1" + x1cp)
-      }
-
-      //sys.error(x1cp.toString)
-      if (x1cp contains "servlet-api-2.3.jar") {
-        sys.error("servlet-api-2.3.jar is found when it should be evicted:" + x1cp)
-      } 
-    }
-  )))
+  if (x1cp contains "servlet-api-2.3.jar")
+    sys.error(s"servlet-api-2.3.jar is found when it should be evicted:$x1cpStr")
+}
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/test b/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/test
index f91a13d11..1a1446f96 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/test
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/test
@@ -1,7 +1,3 @@
-> debug
-
-> Y1/publishLocal
-
-> Y2/publishLocal
-
+> y1/publishLocal
+> y2/publishLocal
 > check
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt
index d8e6f261d..cf58ed44a 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt
@@ -1,9 +1,12 @@
 // https://github.com/sbt/sbt/issues/1649
 lazy val check = taskKey[Unit]("Runs the check")
 
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
     dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
     scalaVersion := "2.10.4",
     resolvers += Resolver.sonatypeRepo("snapshots")
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-force/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-force/multi.sbt
index 380e0cc65..2d6a9f93a 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-force/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-force/multi.sbt
@@ -1,8 +1,10 @@
 lazy val check = taskKey[Unit]("Runs the check")
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
     dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
     scalaVersion := "2.10.4",
     resolvers += Resolver.sonatypeRepo("snapshots")
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/multi.sbt
index 50b154fbb..e5b6ea9d3 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/multi.sbt
@@ -1,24 +1,28 @@
 // https://github.com/sbt/sbt/issues/1730
 lazy val check = taskKey[Unit]("Runs the check")
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+val junit = "junit" % "junit" % "4.13.1"
+
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
 
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
     dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
-    scalaVersion := "2.11.4",
     resolvers += Resolver.sonatypeRepo("snapshots")
   )
 
 lazy val transitiveTest = project.
   settings(
     commonSettings,
-    libraryDependencies += "junit" % "junit" % "4.11" % Test
+    libraryDependencies += junit % Test
   )
 
 lazy val transitiveTestDefault = project.
   settings(
     commonSettings,
-    libraryDependencies += "org.scalatest" %% "scalatest" % "2.2.1"
+    libraryDependencies += scalatest
   )
 
 lazy val a = project.
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/test b/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/test
index f3d872ac0..15886c51a 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/test
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-interproj/test
@@ -1,4 +1,2 @@
-> debug
-
 > check
 
diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-overrides/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-overrides/multi.sbt
index 9e918f933..b452de8f3 100644
--- a/sbt/src/sbt-test/dependency-management/cached-resolution-overrides/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/cached-resolution-overrides/multi.sbt
@@ -1,8 +1,10 @@
 lazy val check = taskKey[Unit]("Runs the check")
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
     dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
     libraryDependencies := Seq(
       "net.databinder" %% "unfiltered-uploads" % "0.8.0",
@@ -16,7 +18,7 @@ def commonSettings: Seq[Def.Setting[_]] =
 
 def consolidatedResolutionSettings: Seq[Def.Setting[_]] =
   commonSettings ++ Seq(
-    updateOptions := updateOptions.value.withConsolidatedResolution(true)
+    updateOptions := updateOptions.value.withCachedResolution(true)
   )
 
 // overrides cached
diff --git a/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt b/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt
index f9454c341..1f60e00b8 100644
--- a/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt
@@ -1,9 +1,11 @@
 lazy val check = taskKey[Unit]("Runs the check")
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
-    scalaVersion in ThisBuild := "2.11.7",
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
+    scalaVersion in ThisBuild := "2.11.12",
     organization in ThisBuild := "com.example",
     version in ThisBuild := "0.1.0-SNAPSHOT",
     autoScalaLibrary := false,
diff --git a/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt b/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt
index 68ccf8107..6fc574134 100644
--- a/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt
@@ -1,8 +1,11 @@
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val check = taskKey[Unit]("Runs the check")
 
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
     scalaVersion := "2.10.4",
     fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project"),
     updateOptions := updateOptions.value.withCircularDependencyLevel(CircularDependencyLevel.Error)
diff --git a/sbt/src/sbt-test/dependency-management/circular-dependency/multi.sbt b/sbt/src/sbt-test/dependency-management/circular-dependency/multi.sbt
index 0a6454d57..632ea2264 100644
--- a/sbt/src/sbt-test/dependency-management/circular-dependency/multi.sbt
+++ b/sbt/src/sbt-test/dependency-management/circular-dependency/multi.sbt
@@ -1,8 +1,10 @@
 lazy val check = taskKey[Unit]("Runs the check")
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
     scalaVersion := "2.10.4",
     fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project")
   )
diff --git a/sbt/src/sbt-test/dependency-management/classifier/build.sbt b/sbt/src/sbt-test/dependency-management/classifier/build.sbt
index 72a1c94d1..f82acfadb 100644
--- a/sbt/src/sbt-test/dependency-management/classifier/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/classifier/build.sbt
@@ -1,3 +1,4 @@
-ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value
+ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
 
 libraryDependencies += "org.testng" % "testng" % "5.7" classifier "jdk15"
diff --git a/sbt/src/sbt-test/dependency-management/classifier2/build.sbt b/sbt/src/sbt-test/dependency-management/classifier2/build.sbt
new file mode 100644
index 000000000..133599913
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/classifier2/build.sbt
@@ -0,0 +1,2 @@
+ThisBuild / scalaVersion := "2.11.12"
+libraryDependencies += "org.jclouds.api" % "nova" % "1.5.9" classifier "tests"
diff --git a/sbt/src/sbt-test/dependency-management/classifier2/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/classifier2/src/main/scala/Main.scala
new file mode 100644
index 000000000..b1a40797d
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/classifier2/src/main/scala/Main.scala
@@ -0,0 +1,18 @@
+import java.io.File
+import java.nio.file.Files
+
+import scala.util.Try
+
+object Main extends App {
+
+  def classFound(clsName: String) = Try(
+    Thread.currentThread()
+      .getContextClassLoader()
+      .loadClass(clsName)
+  ).toOption.nonEmpty
+
+  val name = "org.jclouds.openstack.nova.functions.ParseServerFromJsonResponseTest"
+  val classifierTest = classFound(name)
+
+  assert(classifierTest, s"Couldn't find $name")
+}
diff --git a/sbt/src/sbt-test/dependency-management/classifier2/test b/sbt/src/sbt-test/dependency-management/classifier2/test
new file mode 100644
index 000000000..62ea636c1
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/classifier2/test
@@ -0,0 +1 @@
+> run
diff --git a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/A.scala b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/A.scala
new file mode 100644
index 000000000..69c493db2
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/A.scala
@@ -0,0 +1 @@
+object A
diff --git a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt
new file mode 100644
index 000000000..5f6646644
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt
@@ -0,0 +1,25 @@
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val check = taskKey[Unit]("")
+
+// We can't use "%%" here without breaking the "== bridgeModule" check below
+val bridgeModule = "org.scala-sbt" % "compiler-bridge_2.12" % "1.3.0"
+
+libraryDependencies += bridgeModule % Configurations.ScalaTool
+
+scalaCompilerBridgeSource := "shouldnotbeused" % "dummy" % "dummy"
+
+scalaCompilerBridgeBinaryJar := {
+  for {
+    toolReport <- update.value.configuration(Configurations.ScalaTool)
+    m <- toolReport.modules.find(m => m.module.name == bridgeModule.name)
+    (_, file) <- m.artifacts.find(art => art._1.`type` == Artifact.DefaultType)
+  } yield file
+}
+
+check := {
+  val toolReport = update.value.configuration(Configurations.ScalaTool).get
+  val m = toolReport.modules.find(m => m.module.name == bridgeModule.name)
+  val bridge = scalaCompilerBridgeBinaryJar.value
+  bridge.getOrElse(sys.error(s"bridge JAR is missing: $toolReport"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/disabled b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/disabled
new file mode 100644
index 000000000..5f1fbe2c5
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/disabled
@@ -0,0 +1,2 @@
+> check
+> compile
diff --git a/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt b/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt
index 1cddfa1fc..d03c0f295 100644
--- a/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt
@@ -1,11 +1,11 @@
-configurationsToRetrieve := Some(Set(Compile))
+ThisBuild / useCoursier := false
 
-retrieveManaged := true
-
-libraryDependencies += "log4j" % "log4j" % "1.2.16" % "compile"
-
-autoScalaLibrary := false
-
-managedDirectory := file("dependencies")
-
-retrievePattern := "[conf]/[artifact]-[revision](-[classifier]).[ext]"
\ No newline at end of file
+lazy val root = (project in file("."))
+  .settings(
+    configurationsToRetrieve := Some(Vector(Compile)),
+    retrieveManaged := true,
+    libraryDependencies += "log4j" % "log4j" % "1.2.16" % "compile",
+    autoScalaLibrary := false,
+    managedDirectory := file("dependencies"),
+    retrievePattern := "[conf]/[artifact]-[revision](-[classifier]).[ext]",
+  )
diff --git a/sbt/src/sbt-test/dependency-management/configurations/pending b/sbt/src/sbt-test/dependency-management/configurations/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/configurations/pending
rename to sbt/src/sbt-test/dependency-management/configurations/disabled
diff --git a/sbt/src/sbt-test/dependency-management/conflict-coursier/build.sbt b/sbt/src/sbt-test/dependency-management/conflict-coursier/build.sbt
new file mode 100644
index 000000000..c03c939e6
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/conflict-coursier/build.sbt
@@ -0,0 +1,5 @@
+ThisBuild / scalaVersion := "2.12.12"
+libraryDependencies ++= List(
+  "org.webjars.npm" % "randomatic" % "1.1.7",
+  "org.webjars.npm" % "is-odd"     % "2.0.0",
+)
diff --git a/sbt/src/sbt-test/dependency-management/dynamic-revision/test b/sbt/src/sbt-test/dependency-management/conflict-coursier/test
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/dynamic-revision/test
rename to sbt/src/sbt-test/dependency-management/conflict-coursier/test
diff --git a/sbt/src/sbt-test/dependency-management/conflict-manager-with-org/build.sbt b/sbt/src/sbt-test/dependency-management/conflict-manager-with-org/build.sbt
index 01013eaa4..0975aea0a 100644
--- a/sbt/src/sbt-test/dependency-management/conflict-manager-with-org/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/conflict-manager-with-org/build.sbt
@@ -1,5 +1,5 @@
 scalaVersion := "2.10.4"
 
-conflictManager := ConflictManager.strict.copy(organization = "^(?!org\\.scala-lang).*$")
+conflictManager := ConflictManager.strict.withOrganization("^(?!org\\.scala-lang).*$")
 
 libraryDependencies += "org.specs2" %% "specs2" % "2.3.10-scalaz-7.1.0-M6" % "test"
diff --git a/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt b/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt
index b5cfdf07b..0dc7a72fc 100644
--- a/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / useCoursier := false
+
 libraryDependencies ++= Seq(
 	"org.spark-project" %% "spark-core" % "0.5.1",
 	"log4j" % "log4j" % "1.2.17"
diff --git a/sbt/src/sbt-test/dependency-management/cp-order/build.sbt b/sbt/src/sbt-test/dependency-management/cp-order/build.sbt
new file mode 100644
index 000000000..3ea183127
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cp-order/build.sbt
@@ -0,0 +1,5 @@
+scalaVersion := "2.13.1"
+csrConfiguration := csrConfiguration.value.withCache(target.value / "coursier-cache")
+
+libraryDependencies += "com.typesafe.play" %% "play-test" % "2.8.0-RC1" % Test // worked around in 2.8.0
+libraryDependencies += "org.scalatest"     %% "scalatest" % "3.0.8"     % Test
diff --git a/sbt/src/sbt-test/dependency-management/cp-order/pending b/sbt/src/sbt-test/dependency-management/cp-order/pending
new file mode 100644
index 000000000..499682d37
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cp-order/pending
@@ -0,0 +1,5 @@
+# https://github.com/coursier/coursier/issues/1466
+# aka https://github.com/sbt/sbt/issues/5282
+> test
+> set csrConfiguration ~= (_.withClasspathOrder(false))
+-> test
diff --git a/sbt/src/sbt-test/dependency-management/cp-order/src/test/scala/t/UnitSpec.scala b/sbt/src/sbt-test/dependency-management/cp-order/src/test/scala/t/UnitSpec.scala
new file mode 100644
index 000000000..d1735b308
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/cp-order/src/test/scala/t/UnitSpec.scala
@@ -0,0 +1,20 @@
+package t
+
+import com.typesafe.config.ConfigFactory
+import org.scalatest.{ MustMatchers, WordSpec }
+
+class UnitSpec extends WordSpec with MustMatchers {
+  def conf = ConfigFactory.defaultReference()
+
+  "Config" should {
+    "return Akka HTTP server provider" in {
+      val serverProvider = conf.getString("play.server.provider")
+      serverProvider mustBe "play.core.server.AkkaHttpServerProvider"
+    }
+
+    "be able to load Netty settings" in {
+      val nettyTransport = conf.getString("play.server.netty.transport")
+      nettyTransport mustBe "jdk"
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/dependency-management/credentials/build.sbt b/sbt/src/sbt-test/dependency-management/credentials/build.sbt
new file mode 100644
index 000000000..81394881e
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/credentials/build.sbt
@@ -0,0 +1,7 @@
+ThisBuild / scalaVersion := "2.13.0"
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
+
+// don't blow up when credential file doesn't exist
+// https://github.com/sbt/sbt/issues/4882
+credentials += Credentials(baseDirectory.value / "nonexistent")
diff --git a/sbt/src/sbt-test/dependency-management/credentials/test b/sbt/src/sbt-test/dependency-management/credentials/test
new file mode 100644
index 000000000..103bd8d2f
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/credentials/test
@@ -0,0 +1 @@
+> update
diff --git a/sbt/src/sbt-test/dependency-management/cross-conflict/build.sbt b/sbt/src/sbt-test/dependency-management/cross-conflict/build.sbt
deleted file mode 100644
index 2e19d296a..000000000
--- a/sbt/src/sbt-test/dependency-management/cross-conflict/build.sbt
+++ /dev/null
@@ -1,5 +0,0 @@
-scalaVersion := "2.10.6"
-libraryDependencies ++= Seq(
-  "org.scalatest" %% "scalatest" % "1.9.1" % "test",
-  "org.scalamock" %% "scalamock-scalatest-support" % "3.0" % "test"
-)
diff --git a/sbt/src/sbt-test/dependency-management/cross-conflict/changes/no-conflict-error.sbt b/sbt/src/sbt-test/dependency-management/cross-conflict/changes/no-conflict-error.sbt
deleted file mode 100644
index 8ebdf0f5e..000000000
--- a/sbt/src/sbt-test/dependency-management/cross-conflict/changes/no-conflict-error.sbt
+++ /dev/null
@@ -1 +0,0 @@
-conflictWarning ~= { _.copy(failOnConflict = false) }
diff --git a/sbt/src/sbt-test/dependency-management/cross-conflict/test b/sbt/src/sbt-test/dependency-management/cross-conflict/test
deleted file mode 100644
index 23768a9a5..000000000
--- a/sbt/src/sbt-test/dependency-management/cross-conflict/test
+++ /dev/null
@@ -1,5 +0,0 @@
--> update
-$ copy-file changes/no-conflict-error.sbt no-conflict-error.sbt
-
-> reload
-> update
diff --git a/sbt/src/sbt-test/dependency-management/custom-config/build.sbt b/sbt/src/sbt-test/dependency-management/custom-config/build.sbt
new file mode 100644
index 000000000..427d4c5fe
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/custom-config/build.sbt
@@ -0,0 +1,49 @@
+// Custom configurations
+lazy val Common = config("common").describedAs("Dependencies required in all configurations.")
+lazy val Scalate = config("scalate").extend(Common).describedAs("Dependencies for using Scalate utilities.")
+lazy val Saxon = config("saxon").extend(Common).describedAs("Dependencies for using Saxon utilities.")
+
+// Define a customized compile configuration that includes
+// dependencies defined in our other custom configurations
+lazy val CustomCompile = config("compile").extend(Saxon, Common, Scalate)
+
+// factor out common settings
+ThisBuild / organization := "com.example"
+ThisBuild / scalaVersion := "2.10.6"
+ThisBuild / version      := "0.1.0-SNAPSHOT"
+
+// An example project that only uses the Scalate utilities.
+lazy val a = (project in file("a"))
+  .dependsOn(utils % "compile->scalate")
+
+// An example project that uses the Scalate and Saxon utilities.
+// For the configurations defined here, this is equivalent to doing dependsOn(utils),
+//  but if there were more configurations, it would select only the Scalate and Saxon
+//  dependencies.
+lazy val b = (project in file("b"))
+  .dependsOn(utils % "compile->scalate,saxon")
+
+// Defines the utilities project
+lazy val utils = (project in file("utils"))
+  .settings(
+    inConfig(Common)(Defaults.configSettings),  // Add the src/common/scala/ compilation configuration.
+    addArtifact(Common / packageBin / artifact, Common / packageBin), // Publish the common artifact
+
+    // We want our Common sources to have access to all of the dependencies on the classpaths
+    //   for compile and test, but when depended on, it should only require dependencies in 'common'
+    Common / classpathConfiguration := CustomCompile,
+
+    // Modify the default Ivy configurations.
+    // 'overrideConfigs' ensures that Compile is replaced by CustomCompile
+    ivyConfigurations := overrideConfigs(Scalate, Saxon, Common, CustomCompile)(ivyConfigurations.value),
+
+    // Put all dependencies without an explicit configuration into Common (optional)
+    defaultConfiguration := Some(Common),
+
+    // Declare dependencies in the appropriate configurations
+    libraryDependencies ++= Seq(
+      "org.fusesource.scalate" % "scalate-core" % "1.5.0" % Scalate,
+      "org.squeryl" %% "squeryl" % "0.9.5-6" % Scalate,
+      "net.sf.saxon" % "saxon" % "8.7" % Saxon
+    )
+  )
diff --git a/sbt/src/sbt-test/project-load/sha-conflict/pending b/sbt/src/sbt-test/dependency-management/custom-config/test
similarity index 100%
rename from sbt/src/sbt-test/project-load/sha-conflict/pending
rename to sbt/src/sbt-test/dependency-management/custom-config/test
diff --git a/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt b/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt
index 89ca8a589..c7fe3b549 100644
--- a/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt
@@ -1,11 +1,13 @@
+ThisBuild / useCoursier := false
+
 resolvers += Resolver.file("buggy", file("repo"))(
-	Patterns(
-		ivyPatterns =  Seq("[organization]/[module]/[revision]/ivy.xml"),
-		artifactPatterns = Seq("[organization]/[module]/[revision]/[artifact].[ext]"),
-		isMavenCompatible = false,
-		descriptorOptional = true,
-		skipConsistencyCheck = true
-	)
+  Patterns(
+    ivyPatterns = Vector("[organization]/[module]/[revision]/ivy.xml"),
+    artifactPatterns = Vector("[organization]/[module]/[revision]/[artifact].[ext]"),
+    isMavenCompatible = false,
+    descriptorOptional = true,
+    skipConsistencyCheck = true
+  )
 )
 
 libraryDependencies += "a" % "b" % "1.0.0" % "compile->runtime" artifacts(Artifact("b1", "jar", "jar"))
diff --git a/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml b/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml
index 53fe74fc9..165b4c192 100644
--- a/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml
+++ b/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml
@@ -1,13 +1,13 @@
 <ivy-module xmlns:e="http://ant.apache.org/ivy/extra" version="2.0">
 <info organisation="a" module="b" revision="1.0.0" status="release" publication="20160201120702">
-	<description>a</description>
+  <description>a</description>
 </info>
 <configurations>
-	<conf name="runtime" description="..."/>
+  <conf name="runtime" description="..."/>
 </configurations>
 <publications>
-	<artifact name="b1.jar" type="jar" ext="jar" conf="runtime"/>
-	<artifact name="b2.jar" type="jar" ext="jar" conf="runtime"/>
+  <artifact name="b1" type="jar" ext="jar" conf="runtime"/>
+  <artifact name="fake" type="jar" ext="jar" conf="runtime"/>
 </publications>
 <dependencies>
 </dependencies>
diff --git a/sbt/src/sbt-test/dependency-management/default-resolvers/test b/sbt/src/sbt-test/dependency-management/default-resolvers/test
index 0d310c9f5..769501c0a 100644
--- a/sbt/src/sbt-test/dependency-management/default-resolvers/test
+++ b/sbt/src/sbt-test/dependency-management/default-resolvers/test
@@ -9,3 +9,7 @@
 > set resolvers += Resolver.jcenterRepo
 
 > check2
+
+## HTTP
+> set resolvers += ("old_typesafe" at "http://repo.typesafe.com/typesafe/")
+-> update
diff --git a/sbt/src/sbt-test/dependency-management/deliver-artifacts/build.sbt b/sbt/src/sbt-test/dependency-management/deliver-artifacts/build.sbt
index b95cda3c2..69da3bd1a 100644
--- a/sbt/src/sbt-test/dependency-management/deliver-artifacts/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/deliver-artifacts/build.sbt
@@ -1,3 +1,7 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+ThisBuild / organization := "org.example"
+ThisBuild / version := "1.0"
+
 lazy val a = project.settings(common: _*).settings(
 	// verifies that a can be published as an ivy.xml file and preserve the extra artifact information,
 	//   such as a classifier
@@ -10,12 +14,8 @@ lazy val b = project.settings(common: _*).settings(
 	libraryDependencies := Seq(organization.value %% "a" % version.value)
 )
 
-organization in ThisBuild := "org.example"
-
-version in ThisBuild := "1.0"
-
 lazy val common = Seq(
 	autoScalaLibrary := false, // avoid downloading fresh scala-library/scala-compiler
 	managedScalaInstance := false,
-	ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache"))
+	ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache"))
 )
diff --git a/sbt/src/sbt-test/dependency-management/dynamic-revision/disabled b/sbt/src/sbt-test/dependency-management/dynamic-revision/disabled
new file mode 100644
index 000000000..103bd8d2f
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/dynamic-revision/disabled
@@ -0,0 +1 @@
+> update
diff --git a/sbt/src/sbt-test/dependency-management/evicted-semver-spec/build.sbt b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/build.sbt
new file mode 100644
index 000000000..9460b811d
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/build.sbt
@@ -0,0 +1,75 @@
+import xsbti.AppConfiguration
+// ThisBuild / useCoursier := false
+ThisBuild / organization := "com.example"
+ThisBuild / scalaVersion := "2.13.3"
+ThisBuild / versionScheme := Some("semver-spec")
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+def commonSettings: Seq[Def.Setting[_]] =
+  Seq(
+    fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project"),
+    publishTo := Some(MavenCache("local-maven", (LocalRootProject / target).value / "local-maven")),
+    scalaCompilerBridgeResolvers += userLocalFileResolver(appConfiguration.value),
+    resolvers += MavenCache("local-maven", (LocalRootProject / target).value / "local-maven"),
+  )
+
+lazy val root = (project in file("."))
+  .settings(commonSettings)
+
+val `v1-0-0` = (project in file("v1.0.0"))
+  .settings(commonSettings)
+  .settings(
+    name := "semver-spec-test",
+    version := "1.0.0",
+  )
+
+val `v1-1-0` = (project in file("v1.1.0"))
+  .settings(commonSettings)
+  .settings(
+    name := "semver-spec-test",
+    version := "1.1.0",
+  )
+
+val middle = project
+  .settings(commonSettings)
+  .settings(
+    name := "middle",
+    version := "1.0.0",
+    libraryDependencies += "com.example" %% "semver-spec-test" % "1.0.0",
+  )
+
+val use = project
+  .settings(commonSettings)
+  .settings(
+    name := "use",
+    libraryDependencies ++= Seq(
+      "com.example" %% "semver-spec-test" % "1.1.0",
+      "com.example" %% "middle" % "1.0.0",
+    ),
+    TaskKey[Unit]("check") := {
+      val report = updateFull.value
+      val log = streams.value.log
+      val extraAttributes = (report.allModules flatMap { _.extraAttributes}) collect {
+          case ("info.versionScheme", v) => v
+        }
+      log.info(s"extraAttributes = $extraAttributes")
+      assert(extraAttributes.nonEmpty, s"$extraAttributes is empty")
+    },
+  )
+
+val use2 = project
+  .settings(commonSettings)
+  .settings(
+    name := "use2",
+    libraryDependencies ++= Seq(
+      "org.http4s" %% "http4s-blaze-server" % "0.21.11",
+      // https://repo1.maven.org/maven2/org/typelevel/cats-effect_2.13/3.0.0-M4/cats-effect_2.13-3.0.0-M4.pom
+      // is published with early-semver
+      "org.typelevel" %% "cats-effect" % "3.0.0-M4",
+    ),
+  )
+// use the user local resolver to fetch the SNAPSHOT version of the compiler-bridge
+def userLocalFileResolver(appConfig: AppConfiguration): Resolver = {
+  val ivyHome = appConfig.provider.scalaProvider.launcher.ivyHome
+  Resolver.file("User Local", ivyHome / "local")(Resolver.defaultIvyPatterns)
+}
diff --git a/sbt/src/sbt-test/dependency-management/evicted-semver-spec/test b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/test
new file mode 100644
index 000000000..93ed91f57
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/test
@@ -0,0 +1,6 @@
+> v1-0-0/publish
+> v1-1-0/publish
+> middle/publish
+
+> use/check
+-> use2/update
diff --git a/sbt/src/sbt-test/dependency-management/evicted-semver-spec/v1.0.0/LibraryTest.scala b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/v1.0.0/LibraryTest.scala
new file mode 100644
index 000000000..fbfda9e74
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/v1.0.0/LibraryTest.scala
@@ -0,0 +1,3 @@
+package example
+
+trait Foo {}
diff --git a/sbt/src/sbt-test/dependency-management/evicted-semver-spec/v1.1.0/LibraryTest.scala b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/v1.1.0/LibraryTest.scala
new file mode 100644
index 000000000..fbfda9e74
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/evicted-semver-spec/v1.1.0/LibraryTest.scala
@@ -0,0 +1,3 @@
+package example
+
+trait Foo {}
diff --git a/sbt/src/sbt-test/dependency-management/exclude-bundle/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-bundle/build.sbt
index 2652a7fd6..ac5aa4f28 100644
--- a/sbt/src/sbt-test/dependency-management/exclude-bundle/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/exclude-bundle/build.sbt
@@ -1,3 +1,3 @@
 libraryDependencies += "org.vaadin" % "dontpush-addon-ozonelayer" % "0.4.6"
 
-resolvers += "asdf" at "http://maven.vaadin.com/vaadin-addons"
+resolvers += "asdf" at "https://maven.vaadin.com/vaadin-addons"
diff --git a/sbt/src/sbt-test/dependency-management/exclude-bundle/changes/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-bundle/changes/build.sbt
index fec4bc3f6..d6348fa72 100644
--- a/sbt/src/sbt-test/dependency-management/exclude-bundle/changes/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/exclude-bundle/changes/build.sbt
@@ -1,3 +1,3 @@
 libraryDependencies += "org.vaadin" % "dontpush-addon-ozonelayer" % "0.4.6" exclude("org.atmosphere", "atmosphere-compat-jetty")
 
-resolvers += "asdf" at "http://maven.vaadin.com/vaadin-addons"
+resolvers += "asdf" at "https://maven.vaadin.com/vaadin-addons"
diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt
index 547dc29ff..15e4df170 100644
--- a/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt
@@ -1,6 +1,6 @@
 import scala.xml.{ Node, _ }
 import scala.xml.Utility.trim
-import sbt.internal.librarymanagement.{ IvySbt, MakePomConfiguration, MakePom }
+import sbt.internal.librarymanagement.{ IvySbt, MakePom }
 
 lazy val check = taskKey[Unit]("check")
 
@@ -9,14 +9,14 @@ val repatchTwitter = "com.eed3si9n" %% "repatch-twitter-core" % "dispatch0.11.1_
 
 lazy val a = (project in file("a")).
   settings(
-    scalaVersion := "2.11.4",
+    scalaVersion := "2.11.12",
     libraryDependencies += dispatch,
     excludeDependencies += "org.slf4j"
   )
 
 lazy val b = (project in file("b")).
   settings(
-    scalaVersion := "2.11.4",
+    scalaVersion := "2.11.12",
     libraryDependencies += repatchTwitter,
     excludeDependencies += "net.databinder.dispatch" %% "dispatch-core"
   )
@@ -59,6 +59,6 @@ def makePomXml(log: Logger, makePomConfig: MakePomConfiguration, ivyModule: IvyS
   ivyModule.withModule[Node](log) { (ivy, md, default) =>
     import makePomConfig._
     new MakePom(log).toPom(
-      ivy, md, moduleInfo, configurations, includeTypes, extra, filterRepositories, allRepositories)
+      ivy, md, moduleInfo.get, configurations, includeTypes, extra.get, filterRepositories, allRepositories)
   }
 }
diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt
new file mode 100644
index 000000000..7b75a187f
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt
@@ -0,0 +1,11 @@
+
+ThisBuild / scalaVersion := "2.11.12"
+
+organization := "io.get-coursier.test"
+name := "sbt-coursier-exclude-dependencies"
+version := "0.1.0-SNAPSHOT"
+
+libraryDependencies += "com.github.alexarchambault" %% "argonaut-shapeless_6.1" % "1.0.0-RC1"
+
+excludeDependencies += sbt.ExclusionRule("com.chuusai", "shapeless_2.11")
+excludeDependencies += "io.argonaut" %% "argonaut"
diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/coursier b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/coursier
new file mode 100755
index 000000000..6cada6f8b
Binary files /dev/null and b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/coursier differ
diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/src/main/scala/Main.scala
new file mode 100644
index 000000000..1bc056610
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/src/main/scala/Main.scala
@@ -0,0 +1,32 @@
+import java.io.File
+import java.nio.file.Files
+
+import scala.util.Try
+
+object Main extends App {
+
+  def classFound(clsName: String) = Try(
+    Thread.currentThread()
+      .getContextClassLoader()
+      .loadClass(clsName)
+  ).toOption.nonEmpty
+
+  val shapelessFound = classFound("shapeless.HList")
+  val argonautFound = classFound("argonaut.Json")
+  val argonautShapelessFound = classFound("argonaut.derive.MkEncodeJson")
+
+  assert(
+    argonautShapelessFound,
+    "Expected to find class from argonaut-shapeless"
+  )
+  assert(
+    !shapelessFound,
+    "Expected not to find classes from shapeless"
+  )
+  assert(
+    !argonautFound,
+    "Expected not to find classes from argonaut"
+  )
+
+  Files.write(new File("output").toPath, "OK".getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/test b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/test
new file mode 100644
index 000000000..2182f57b0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/test
@@ -0,0 +1,3 @@
+$ delete output
+> run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/exclude-scala/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-scala/build.sbt
index 7697c37e6..338b358ab 100644
--- a/sbt/src/sbt-test/dependency-management/exclude-scala/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/exclude-scala/build.sbt
@@ -6,7 +6,7 @@ lazy val root = (project in file(".")).
   settings(
     libraryDependencies ++= baseDirectory(dependencies).value,
     scalaVersion := "2.9.2",
-    ivyScala := { ivyScala.value map {_.copy(overrideScalaVersion = sbtPlugin.value)} },
+    scalaModuleInfo := scalaModuleInfo.value map (_.withOverrideScalaVersion(sbtPlugin.value)),
     autoScalaLibrary := baseDirectory(base => !(base / "noscala").exists ).value,
     scalaOverride := check("scala.App").value
   )
diff --git a/sbt/src/sbt-test/dependency-management/exclude-transitive/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-transitive/build.sbt
index 820eaecc9..cd6c3ec92 100644
--- a/sbt/src/sbt-test/dependency-management/exclude-transitive/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/exclude-transitive/build.sbt
@@ -1,6 +1,8 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val root = (project in file(".")).
   settings(
-    ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value,
+    ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
     libraryDependencies += baseDirectory(transitive("javax.mail" % "mail" % "1.4.1")).value,
     TaskKey[Unit]("checkTransitive") := check(true).value,
     TaskKey[Unit]("checkIntransitive") := check(false).value
diff --git a/sbt/src/sbt-test/dependency-management/exclude-transitive/test b/sbt/src/sbt-test/dependency-management/exclude-transitive/test
index bf78e6c17..6a468595d 100644
--- a/sbt/src/sbt-test/dependency-management/exclude-transitive/test
+++ b/sbt/src/sbt-test/dependency-management/exclude-transitive/test
@@ -1,4 +1,3 @@
-> debug
 # load the project definition with transitive dependencies enabled
 # and check that they are not downloaded
 #$ pause
@@ -15,6 +14,7 @@ $ touch transitive
 # load the project definition with transitive dependencies disabled
 # and check that they are not downloaded
 
+$ delete coursier-cache
 $ delete ivy-cache
 $ delete transitive
 > reload
diff --git a/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt b/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt
index 494d0b654..d3253a483 100644
--- a/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt
@@ -1,3 +1,7 @@
-scalaVersion := "2.10.6"
+ThisBuild / useCoursier := false
 
-externalPom()
+lazy val root = (project in file("."))
+  .settings(
+    scalaVersion := "2.12.6",
+    externalPom()
+  )
diff --git a/sbt/src/sbt-test/dependency-management/ext-pom-classifier/pom.xml b/sbt/src/sbt-test/dependency-management/ext-pom-classifier/pom.xml
index 414bc70fc..9fd80ac18 100644
--- a/sbt/src/sbt-test/dependency-management/ext-pom-classifier/pom.xml
+++ b/sbt/src/sbt-test/dependency-management/ext-pom-classifier/pom.xml
@@ -70,7 +70,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.11</version>
+      <version>4.13.1</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
diff --git a/sbt/src/sbt-test/dependency-management/extra/DefineColor.sbt b/sbt/src/sbt-test/dependency-management/extra/DefineColor.sbt
index be9c65205..bd3c981bc 100644
--- a/sbt/src/sbt-test/dependency-management/extra/DefineColor.sbt
+++ b/sbt/src/sbt-test/dependency-management/extra/DefineColor.sbt
@@ -1,15 +1,18 @@
-ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
 
-publishMavenStyle := false
-
-publishTo := (baseDirectory { base =>
-	Some(Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns))
-}).value
-
-projectID := (projectID { _.extra("e:color" -> "red") }).value
-
-organization := "org.scala-sbt"
-
-version := "1.0"
-
-name := "define-color"
\ No newline at end of file
+lazy val root = (project in file("."))
+  .settings(
+    organization := "com.example",
+    version := "1.0",
+    name := "define-color",
+    projectID := {
+      val old = projectID.value
+      old.extra("e:color" -> "red")
+    },
+    ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
+    publishMavenStyle := false,
+    publishTo := {
+      val base = baseDirectory.value
+      Some(Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns))
+    }
+  )
diff --git a/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt b/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt
index 59e2cabac..f77e05981 100644
--- a/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt
+++ b/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt
@@ -1,17 +1,19 @@
-ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache")) ).value
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
 
-publishMavenStyle := false
-
-resolvers := baseDirectory( base => 
-	Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns) :: Nil
-).value
-
-libraryDependencies := (baseDirectory { base =>
-	val color = IO.read(base / "color")
-	val dep = "org.scala-sbt" %% "define-color" % "1.0" extra("e:color" -> color)
-	dep :: Nil
-}).value
-
-organization := "org.example"
-
-name := "use-color"
\ No newline at end of file
+lazy val root = (project in file("."))
+  .settings(
+    organization := "org.example",
+    name := "use-color",
+    ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
+    publishMavenStyle := false,
+    resolvers := baseDirectory( base => 
+      Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns) :: Nil
+    ).value,
+    libraryDependencies := {
+      val base = baseDirectory.value
+      val color = IO.read(base / "color")
+      val dep = "com.example" %% "define-color" % "1.0" extra("e:color" -> color)
+      dep :: Nil
+    }
+  )
diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/a/src/main/scala/A.scala b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/a/src/main/scala/A.scala
new file mode 100644
index 000000000..954405774
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/a/src/main/scala/A.scala
@@ -0,0 +1,6 @@
+
+case class A(msg: String)
+
+object A {
+  def default = A("OK")
+}
diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/b/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/b/src/main/scala/Main.scala
new file mode 100644
index 000000000..59bb6d372
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/b/src/main/scala/Main.scala
@@ -0,0 +1,9 @@
+import java.io.File
+import java.nio.file.Files
+
+object Main extends App {
+
+  val msg = shapeless.Generic[A].to(A.default).head
+  
+  Files.write(new File("output").toPath, msg.getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt
new file mode 100644
index 000000000..98731216b
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt
@@ -0,0 +1,13 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+lazy val a = project
+  .settings(
+    libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.234" from "https://oss.sonatype.org/content/repositories/releases/com/chuusai/shapeless_2.11/2.3.1/shapeless_2.11-2.3.1.jar"
+  )
+
+lazy val b = project
+  .dependsOn(a)
+
+lazy val root = project
+  .in(file("."))
+  .aggregate(a, b)
diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/test b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/test
new file mode 100644
index 000000000..ea53e1abb
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/test
@@ -0,0 +1,3 @@
+$ delete output
+> b/run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt b/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt
index b7505be1d..11bcdf94e 100644
--- a/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt
@@ -1,13 +1,17 @@
+ThisBuild / useCoursier := false
+
 libraryDependencies += "log4j" % "log4j" % "1.2.16" % "compile"
 
 autoScalaLibrary := false
 
+crossPaths := false
+
 TaskKey[Unit]("check-last-update-time") := (streams map { (s) =>
   val fullUpdateOutput = s.cacheDirectory / "out"
   val timeDiff = System.currentTimeMillis()-fullUpdateOutput.lastModified()
   val exists = fullUpdateOutput.exists()
   s.log.info(s"Amount of time since last full update: $timeDiff")
   if (exists && timeDiff > 5000) {
-    sys.error("Full update not perfomed")
+    sys.error("Full update not performed")
   }
 }).value
diff --git a/sbt/src/sbt-test/dependency-management/force/build.sbt b/sbt/src/sbt-test/dependency-management/force/build.sbt
index 819a04d06..2a8a64b04 100644
--- a/sbt/src/sbt-test/dependency-management/force/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/force/build.sbt
@@ -1,6 +1,8 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val root = (project in file(".")).
   settings(
-    ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value,
+    ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
     libraryDependencies ++= baseDirectory (libraryDeps).value,
     TaskKey[Unit]("checkForced") := check("1.2.14").value,
     TaskKey[Unit]("checkDepend") := check("1.2.13").value
@@ -17,5 +19,5 @@ def check(ver: String) =
       case f if f.getName contains "log4j-" => f.getName
     }
     if (log4j.size != 1 || !log4j.head.contains(ver))
-      error("Did not download the correct jar.")
+      sys.error("Did not download the correct jar.")
   }
diff --git a/sbt/src/sbt-test/dependency-management/gh-1484-npe/build.sbt b/sbt/src/sbt-test/dependency-management/gh-1484-npe/build.sbt
index e9cd1a4f4..f876295d2 100644
--- a/sbt/src/sbt-test/dependency-management/gh-1484-npe/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/gh-1484-npe/build.sbt
@@ -1,7 +1,7 @@
 lazy val check = taskKey[Unit]("tests update")
 
 def commonSettings: Seq[Def.Setting[_]] = Seq(
-    resolvers ++= Resolver.typesafeIvyRepo("releases") :: Resolver.typesafeRepo("releases") :: Resolver.sbtPluginRepo("releases") :: Nil,
+    resolvers ++= Vector(Resolver.typesafeIvyRepo("releases"), Resolver.typesafeRepo("releases"), Resolver.sbtPluginRepo("releases")),
     check := {
       val ur = update.value
       import sbinary._, Operations._, DefaultProtocol._
diff --git a/sbt/src/sbt-test/dependency-management/gh-1484-npe/pending b/sbt/src/sbt-test/dependency-management/gh-1484-npe/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/gh-1484-npe/pending
rename to sbt/src/sbt-test/dependency-management/gh-1484-npe/disabled
diff --git a/sbt/src/sbt-test/dependency-management/global-plugins/build.sbt b/sbt/src/sbt-test/dependency-management/global-plugins/build.sbt
new file mode 100644
index 000000000..366c27de7
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/global-plugins/build.sbt
@@ -0,0 +1 @@
+scalaVersion := "2.12.12"
diff --git a/sbt/src/sbt-test/dependency-management/global-plugins/global/plugins/metals.sbt b/sbt/src/sbt-test/dependency-management/global-plugins/global/plugins/metals.sbt
new file mode 100644
index 000000000..8aae08736
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/global-plugins/global/plugins/metals.sbt
@@ -0,0 +1,2 @@
+addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % "1.2.5")
+addSbtPlugin("org.scalameta" % "sbt-metals" % "0.4.4")
diff --git a/sbt/src/sbt-test/dependency-management/global-plugins/test b/sbt/src/sbt-test/dependency-management/global-plugins/test
new file mode 100644
index 000000000..67a8b1ff1
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/global-plugins/test
@@ -0,0 +1,2 @@
+> metalsEnable
+> bloopInstall
diff --git a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt
new file mode 100644
index 000000000..8e7c4a097
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt
@@ -0,0 +1,3 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+libraryDependencies += "org.apache.hadoop" % "hadoop-yarn-server-resourcemanager" % "2.7.1"
diff --git a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/src/main/scala/Main.scala
new file mode 100644
index 000000000..032874759
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/src/main/scala/Main.scala
@@ -0,0 +1,8 @@
+import java.io.File
+import java.nio.file.Files
+
+import org.apache.zookeeper.ZooKeeper
+
+object Main extends App {
+  Files.write(new File("output").toPath, classOf[ZooKeeper].getSimpleName.getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/test b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/test
new file mode 100644
index 000000000..2182f57b0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/test
@@ -0,0 +1,3 @@
+$ delete output
+> run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/info/build.sbt b/sbt/src/sbt-test/dependency-management/info/build.sbt
index 6644b2c30..5ae25bd00 100644
--- a/sbt/src/sbt-test/dependency-management/info/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/info/build.sbt
@@ -1,14 +1,17 @@
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 import scala.xml._
 
 lazy val root = (project in file(".")).
   settings(
-    ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value,
-    ivyXML := ((customInfo, organization, moduleName, version) apply inlineXML).value,
+    ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
+    ivyXML := inlineXML(customInfo.value, organization.value, moduleName.value, version.value),
     scalaVersion := "2.9.1",
     projectID ~= (_ cross false),
-    customInfo := (baseDirectory{_ / "info" exists }).value,
+    customInfo := (baseDirectory.value / "info").exists,
     TaskKey[Unit]("check-download") := checkDownload.value,
-    delivered := (deliverLocal map XML.loadFile).value,
+    delivered := (XML loadFile deliverLocal.value),
     TaskKey[Unit]("check-info") := checkInfo.value
   )
 
@@ -16,10 +19,10 @@ lazy val delivered = taskKey[NodeSeq]("")
 lazy val customInfo = settingKey[Boolean]("")
 
 def inlineXML(addInfo: Boolean, organization: String, moduleID: String, version: String): NodeSeq =
-  if(addInfo)
+  if (addInfo)
     (<info organisation={organization} module={moduleID} revision={version}>
-      <license name="Two-clause BSD-style" url="http://github.com/szeiger/scala-query/blob/master/LICENSE.txt" />
-      <description homepage="http://github.com/szeiger/scala-query/">
+      <license name="Two-clause BSD-style" url="https://github.com/szeiger/scala-query/blob/master/LICENSE.txt" />
+      <description homepage="https://github.com/szeiger/scala-query/">
         ScalaQuery is a type-safe database query API for Scala.
       </description>
     </info>
@@ -27,14 +30,19 @@ def inlineXML(addInfo: Boolean, organization: String, moduleID: String, version:
   else
     <dependency org="org.scala-tools.testing" name="scalacheck_2.9.1" rev="1.9"/>
 
-def checkDownload = (dependencyClasspath in Compile) map { cp => if(cp.isEmpty) sys.error("Dependency not downloaded"); () }
-def checkInfo = (customInfo, delivered) map { (addInfo, d) =>
-  if((d \ "info").isEmpty)
-    sys.error("No info tag generated")
-  else if(addInfo) {
-    if( !deliveredWithCustom(d) ) sys.error("Expected 'license' and 'description' tags in info tag, got: \n" + (d \ "info")) else ()
-  } else
-    if( deliveredWithCustom(d) ) sys.error("Expected empty 'info' tag, got: \n" + (d \ "info")) else ()
+def checkDownload = Def task {
+  if ((dependencyClasspath in Compile).value.isEmpty) sys.error("Dependency not downloaded"); ()
 }
-def deliveredWithCustom(d: NodeSeq) = (d \ "info" \ "license").nonEmpty && (d \ "info" \ "description").nonEmpty
 
+def checkInfo = Def task {
+  val d = delivered.value
+  val addInfo = customInfo.value
+  if ((d \ "info").isEmpty)
+    sys.error("No info tag generated")
+  else if (addInfo) {
+    if (!deliveredWithCustom(d)) sys.error("Expected 'license' and 'description' tags in info tag, got: \n" + (d \ "info")) else ()
+  } else
+    if (deliveredWithCustom(d)) sys.error("Expected empty 'info' tag, got: \n" + (d \ "info")) else ()
+}
+
+def deliveredWithCustom(d: NodeSeq) = (d \ "info" \ "license").nonEmpty && (d \ "info" \ "description").nonEmpty
diff --git a/sbt/src/sbt-test/dependency-management/inline-dependencies-a/build.sbt b/sbt/src/sbt-test/dependency-management/inline-dependencies-a/build.sbt
index 9f7a50a6a..fb1c5ca87 100644
--- a/sbt/src/sbt-test/dependency-management/inline-dependencies-a/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/inline-dependencies-a/build.sbt
@@ -1,8 +1,8 @@
-import sbt.internal.librarymanagement.syntax._
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
 
 libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5"
 
-ivyPaths := baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy-home"))).value
+ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy-home"))).value
 
 TaskKey[Unit]("check") := {
   val report = update.value
diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/a/src/main/scala/A.scala b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/a/src/main/scala/A.scala
new file mode 100644
index 000000000..954405774
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/a/src/main/scala/A.scala
@@ -0,0 +1,6 @@
+
+case class A(msg: String)
+
+object A {
+  def default = A("OK")
+}
diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/b/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/b/src/main/scala/Main.scala
new file mode 100644
index 000000000..f2c112187
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/b/src/main/scala/Main.scala
@@ -0,0 +1,14 @@
+import java.io.File
+import java.nio.file.Files
+
+import scalaz.stream._
+import scalaz.concurrent.Task
+
+object Main extends App {
+
+  val pch = Process.constant((i:Int) => Task.now(())).take(3)
+  val count = Process.constant(1).toSource.to(pch).runLog.run.size
+  assert(count == 3)
+
+  Files.write(new File("output").toPath, A.default.msg.getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt
new file mode 100644
index 000000000..625c7c0d2
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt
@@ -0,0 +1,17 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+lazy val a = project
+  .settings(
+    resolvers += "Scalaz Bintray Repo" at "https://dl.bintray.com/scalaz/releases"
+  )
+
+lazy val b = project
+  .dependsOn(a)
+  .settings(
+    // resolver added in inter-project dependency only - should still be fine
+    libraryDependencies += "org.scalaz.stream" %% "scalaz-stream" % "0.7.1a"
+  )
+
+lazy val root = project
+  .in(file("."))
+  .aggregate(a, b)
diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/test b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/test
new file mode 100644
index 000000000..ea53e1abb
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/test
@@ -0,0 +1,3 @@
+$ delete output
+> b/run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/inter-project/a/src/main/scala/A.scala b/sbt/src/sbt-test/dependency-management/inter-project/a/src/main/scala/A.scala
new file mode 100644
index 000000000..5308caa95
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project/a/src/main/scala/A.scala
@@ -0,0 +1,6 @@
+
+object A {
+
+  def msg = "OK"
+
+}
diff --git a/sbt/src/sbt-test/dependency-management/inter-project/b/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/inter-project/b/src/main/scala/Main.scala
new file mode 100644
index 000000000..624039aa5
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project/b/src/main/scala/Main.scala
@@ -0,0 +1,13 @@
+import java.io.File
+import java.nio.file.Files
+
+import argonaut._, Argonaut._, ArgonautShapeless._
+
+object Main extends App {
+
+  case class CC(i: Int, s: String)
+
+  val msg = CC(2, A.msg).asJson.spaces2
+
+  Files.write(new File("output").toPath, msg.getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/inter-project/build.sbt b/sbt/src/sbt-test/dependency-management/inter-project/build.sbt
new file mode 100644
index 000000000..800464482
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project/build.sbt
@@ -0,0 +1,26 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+/** Module with the same Maven coordinates as shapeless 2.3.1 */
+lazy val `shapeless-mock` = project
+  .settings(
+    organization := "com.chuusai",
+    name := "shapeless",
+    version := "2.3.1"
+  )
+
+lazy val a = project
+  .settings(
+    organization := "com.pany",
+    name := "a",
+    version := "0.0.1"
+  )
+
+/** Transitively depends on the - real - shapeless 2.3.1 */
+lazy val b = project
+  .dependsOn(a)
+  .settings(
+    organization := "com.pany",
+    name := "b",
+    version := "0.0.1",
+    libraryDependencies += "com.github.alexarchambault" %% "argonaut-shapeless_6.2" % "1.2.0-M1"
+  )
diff --git a/sbt/src/sbt-test/dependency-management/inter-project/test b/sbt/src/sbt-test/dependency-management/inter-project/test
new file mode 100644
index 000000000..ea53e1abb
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/inter-project/test
@@ -0,0 +1,3 @@
+$ delete output
+> b/run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/invalidate-internal/changes/b.sbt b/sbt/src/sbt-test/dependency-management/invalidate-internal/changes/b.sbt
index 6d4e04264..25f96212f 100644
--- a/sbt/src/sbt-test/dependency-management/invalidate-internal/changes/b.sbt
+++ b/sbt/src/sbt-test/dependency-management/invalidate-internal/changes/b.sbt
@@ -1 +1 @@
-libraryDependencies += "junit" % "junit" % "4.5"
+libraryDependencies += "junit" % "junit" % "4.13.1"
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-a/auto-instance.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-a/auto-instance.sbt
index dff729e11..9c0f64094 100644
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-a/auto-instance.sbt
+++ b/sbt/src/sbt-test/dependency-management/ivy-settings-a/auto-instance.sbt
@@ -1 +1 @@
-managedScalaInstance := false
\ No newline at end of file
+managedScalaInstance := false
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt
index ed427e146..aabb0862d 100644
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt
@@ -1,8 +1,10 @@
-import sbt.internal.librarymanagement.syntax._
+ThisBuild / useCoursier := false
 
-seq(externalIvySettings(), externalIvyFile())
+externalIvySettings()
+externalIvyFile()
 
 TaskKey[Unit]("check") := {
-	val files = update.value.matching( moduleFilter(organization = "org.scalacheck", name = "scalacheck*", revision = "1.11.4") )
-	assert(files.nonEmpty, "ScalaCheck module not found in update report")
-}
\ No newline at end of file
+  val ur = update.value
+  val files = ur.matching( moduleFilter(organization = "org.scalacheck", name = "scalacheck*", revision = "1.13.4") )
+  assert(files.nonEmpty, "ScalaCheck module not found in update report")
+}
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-a/changes/scalacheck-ivy.xml b/sbt/src/sbt-test/dependency-management/ivy-settings-a/changes/scalacheck-ivy.xml
index 4084d70ff..7ecfcab28 100644
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-a/changes/scalacheck-ivy.xml
+++ b/sbt/src/sbt-test/dependency-management/ivy-settings-a/changes/scalacheck-ivy.xml
@@ -2,6 +2,6 @@
 <ivy-module version="2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation= "http://ant.apache.org/ivy/schemas/ivy.xsd">
 	<info organisation="org" module="ivy-settings-test"/>
 	<dependencies>
-		<dependency org="org.scalacheck" name="scalacheck_2.11" rev="1.11.4"/>
+		<dependency org="org.scalacheck" name="scalacheck_2.12" rev="1.13.4"/>
 	</dependencies>
 </ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-a/test b/sbt/src/sbt-test/dependency-management/ivy-settings-a/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/ivy-settings-a/test
rename to sbt/src/sbt-test/dependency-management/ivy-settings-a/disabled
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt
deleted file mode 100644
index 17de0f07f..000000000
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt
+++ /dev/null
@@ -1,12 +0,0 @@
-import sbt.internal.librarymanagement.syntax._
-
-externalIvySettings()
-
-libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5"
-
-TaskKey[Unit]("check") := {
-  val base = baseDirectory.value
-  val report = update.value
-	val files = report.matching( moduleFilter(organization = "org.scalacheck", name = "scalacheck", revision = "1.5") )
-	assert(files.nonEmpty, "ScalaCheck module not found in update report")
-}
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-b/changes/scala-tools-ivysettings.xml b/sbt/src/sbt-test/dependency-management/ivy-settings-b/changes/scala-tools-ivysettings.xml
deleted file mode 100644
index ea1584c39..000000000
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-b/changes/scala-tools-ivysettings.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<ivysettings>
-	<settings defaultResolver="test-chain"/>
-	<include url="${ivy.default.settings.dir}/ivysettings-public.xml"/>
-	<include url="${ivy.default.settings.dir}/ivysettings-shared.xml"/>
-	<include url="${ivy.default.settings.dir}/ivysettings-local.xml"/>
-	<include url="${ivy.default.settings.dir}/ivysettings-main-chain.xml"/>
-	<include url="${ivy.default.settings.dir}/ivysettings-default-chain.xml"/>
-	
-	<caches defaultCacheDir="${ivy.settings.dir}/target/cache"/>
-	<resolvers>
-		<ibiblio name="scala-tools" m2compatible="true" root="http://scala-tools.org/repo-releases/"/>
-		<chain name="test-chain" returnFirst="true" checkmodified="true">
-			<resolver ref="local"/>
-			<resolver ref="shared"/>
-			<resolver ref="main"/>
-			<resolver ref="scala-tools"/>
-		</chain>
-	</resolvers>
-</ivysettings> 
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-b/ivysettings.xml b/sbt/src/sbt-test/dependency-management/ivy-settings-b/ivysettings.xml
deleted file mode 100644
index 03b905979..000000000
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-b/ivysettings.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<ivysettings>
-	<caches defaultCacheDir="${ivy.settings.dir}/target/cache"/>
-</ivysettings>
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-b/test b/sbt/src/sbt-test/dependency-management/ivy-settings-b/test
deleted file mode 100644
index 892c26c06..000000000
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-b/test
+++ /dev/null
@@ -1,4 +0,0 @@
--> update
-
-$ copy-file changes/scala-tools-ivysettings.xml ivysettings.xml
-> check
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt
index a8425099e..2e7cbd392 100644
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt
@@ -1,6 +1,8 @@
+ThisBuild / useCoursier := false
+
 lazy val commonSettings = Seq(
   autoScalaLibrary := false,
-  ivyScala := None,
+  scalaModuleInfo := None,
   unmanagedJars in Compile ++= (scalaInstance map (_.allJars.toSeq)).value,
   publishArtifact in packageSrc := false,
   publishArtifact in packageDoc := false,
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt
index d218debd4..f06c111fb 100644
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / useCoursier := false
+
 lazy val commonSettings = Seq(
   autoScalaLibrary := false,
   unmanagedJars in Compile ++= (scalaInstance map (_.allJars.toSeq)).value
@@ -14,6 +16,6 @@ lazy val use = project.
   dependsOn(dep).
   settings(
     commonSettings,
-    libraryDependencies += "junit" % "junit" % "4.5",
+    libraryDependencies += "junit" % "junit" % "4.13.1",
     externalIvySettings()
   )
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/test b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/test
rename to sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/disabled
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt
index 8a7846582..94a522095 100644
--- a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt
@@ -1,5 +1,7 @@
+ThisBuild / useCoursier := false
+
 lazy val a = (project in file(".")).
   settings(externalIvySettings()) dependsOn(b)
 
 lazy val b = (project in file("b")).
-  settings(externalIvySettings( (baseDirectory in ThisBuild) / "ivysettings.xml" ))
+  settings(externalIvySettings( Def setting ((baseDirectory in ThisBuild).value / "ivysettings.xml") ))
diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/test b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/test
rename to sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/disabled
diff --git a/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt b/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt
index 777b3f0ae..175234505 100644
--- a/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt
+++ b/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt
@@ -1,3 +1,5 @@
+ThisBuild / useCoursier := false
+
 addSbtPlugin("org.example" % "def" % "latest.integration")
 
 resolvers ++= {
diff --git a/sbt/src/sbt-test/dependency-management/make-ivy-xml/build.sbt b/sbt/src/sbt-test/dependency-management/make-ivy-xml/build.sbt
new file mode 100644
index 000000000..98c0eadcb
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/make-ivy-xml/build.sbt
@@ -0,0 +1,24 @@
+import scala.xml.XML
+
+val descriptionValue = "This is just a test"
+val homepageValue = "http://example.com"
+
+lazy val root = (project in file(".")) settings(
+  name := "ivy-xml-test",
+  description := descriptionValue,
+  homepage := Some(url(homepageValue)),
+
+  TaskKey[Unit]("checkIvyXml") := {
+    val ivyXml = XML.loadFile(makeIvyXml.value)
+    val description = (ivyXml \ "info" \ "description").head
+    val homepage = (description \ "@homepage").head
+
+    if (description.text != descriptionValue)
+      sys.error(s"Unexpected description: ${description.text}")
+
+    if (homepage.text != homepageValue)
+      sys.error(s"Unexpected homepage: ${homepage.text}")
+
+    ()
+  }
+)
diff --git a/sbt/src/sbt-test/dependency-management/make-ivy-xml/test b/sbt/src/sbt-test/dependency-management/make-ivy-xml/test
new file mode 100644
index 000000000..0c84f997a
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/make-ivy-xml/test
@@ -0,0 +1 @@
+> checkIvyXml
diff --git a/sbt/src/sbt-test/dependency-management/make-pom/build.sbt b/sbt/src/sbt-test/dependency-management/make-pom/build.sbt
index adc041a9c..f0bfc1f18 100644
--- a/sbt/src/sbt-test/dependency-management/make-pom/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/make-pom/build.sbt
@@ -1,15 +1,17 @@
 import scala.xml._
 
-lazy val root = (project in file(".")).
-  settings(
-    readPom := (makePom map XML.loadFile).value,
-    TaskKey[Unit]("checkPom") := checkPom.value,
-    TaskKey[Unit]("checkExtra") := checkExtra.value,
-    TaskKey[Unit]("checkVersionPlusMapping") := checkVersionPlusMapping.value,
-    resolvers += Resolver.sonatypeRepo("snapshots"),
-    makePomConfiguration ~= { _.copy(extra = <extra-tag/>) },
-    libraryDependencies += "com.google.code.findbugs" % "jsr305" % "1.3.+"
-  )
+lazy val root = (project in file(".")) settings (
+  readPom := (makePom map XML.loadFile).value,
+  TaskKey[Unit]("checkPom") := checkPom.value,
+  TaskKey[Unit]("checkExtra") := checkExtra.value,
+  TaskKey[Unit]("checkVersionPlusMapping") := checkVersionPlusMapping.value,
+  resolvers += Resolver.sonatypeRepo("snapshots"),
+  makePomConfiguration := {
+    val p = makePomConfiguration.value
+    p.withExtra(<extra-tag/>)
+  },
+  libraryDependencies += "com.google.code.findbugs" % "jsr305" % "1.3.+"
+)
 
 val readPom = TaskKey[Elem]("read-pom")
 
@@ -18,18 +20,19 @@ val fakeURL = "http://example.org"
 val fakeRepo = fakeName at fakeURL
 def extraTagName = "extra-tag"
 
-def checkProject(pom: Elem) = if(pom.label != "project") sys.error("Top level element was not 'project': " + pom.label)
+def checkProject(pom: Elem) =
+  if (pom.label != "project") sys.error("Top level element was not 'project': " + pom.label)
 
-def withRepositories[T](pomXML: Elem)(f: NodeSeq => T) =
-{
+def withRepositories[T](pomXML: Elem)(f: NodeSeq => T) = {
   val repositoriesElement = pomXML \ "repositories"
-  if(repositoriesElement.size == 1) f(repositoriesElement) else sys.error("'repositories' element not found in generated pom")
+  if (repositoriesElement.size == 1) f(repositoriesElement)
+  else sys.error("'repositories' element not found in generated pom")
 }
 
 lazy val checkExtra = readPom map { pomXML =>
   checkProject(pomXML)
   val extra =  pomXML \ extraTagName
-  if(extra.isEmpty) sys.error("'" + extraTagName + "' not found in generated pom.xml.") else ()
+  if (extra.isEmpty) sys.error("'" + extraTagName + "' not found in generated pom.xml.") else ()
 }
 
 lazy val checkVersionPlusMapping = (readPom) map { (pomXml) =>
@@ -43,18 +46,20 @@ lazy val checkVersionPlusMapping = (readPom) map { (pomXml) =>
   ()
 }
 
-lazy val checkPom = (readPom, fullResolvers) map { (pomXML, ivyRepositories) =>
+lazy val checkPom = Def task {
+  val pomXML = readPom.value
   checkProject(pomXML)
+  val ivyRepositories = fullResolvers.value
   withRepositories(pomXML) { repositoriesElement =>
     val repositories =  repositoriesElement \ "repository"
     val writtenRepositories = repositories.map(read).distinct
     val mavenStyleRepositories = ivyRepositories.collect {
-      case x: MavenRepository if (x.name != "public") && (x.name != "jcenter") => normalize(x)
+      case x: MavenRepository if (x.name != "public") && (x.name != "jcenter") && !(x.root startsWith "file:") => normalize(x)
     } distinct;
 
     lazy val explain = (("Written:" +: writtenRepositories) ++ ("Declared:" +: mavenStyleRepositories)).mkString("\n\t")
 
-    if( writtenRepositories != mavenStyleRepositories )
+    if (writtenRepositories != mavenStyleRepositories)
       sys.error("Written repositories did not match declared repositories.\n\t" + explain)
     else
       ()
@@ -64,9 +69,9 @@ lazy val checkPom = (readPom, fullResolvers) map { (pomXML, ivyRepositories) =>
 def read(repository: xml.Node): MavenRepository =
   (repository \ "name").text at normalize((repository \ "url").text)
 
-def normalize(url: String): String =
-  {
-    val base = uri( url ).normalize.toString
-    if(base.endsWith("/")) base else (base + "/")
-  }
-def normalize(repo: MavenRepository): MavenRepository = new MavenRepository(repo.name, normalize(repo.root))
+def normalize(url: String): String = {
+  val base = uri(url).normalize.toString
+  if (base.endsWith("/")) base else s"$base/"
+}
+
+def normalize(repo: MavenRepository): MavenRepository = MavenRepository(repo.name, normalize(repo.root))
diff --git a/sbt/src/sbt-test/dependency-management/metadata-only-resolver/build.sbt b/sbt/src/sbt-test/dependency-management/metadata-only-resolver/build.sbt
index 05b5fd161..b3d5e6d75 100644
--- a/sbt/src/sbt-test/dependency-management/metadata-only-resolver/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/metadata-only-resolver/build.sbt
@@ -1,6 +1,8 @@
-ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / ".ivy2"))).value
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / ".ivy2"))
 
 // not in the default repositories
 libraryDependencies += "com.sun.jmx" % "jmxri" % "1.2.1"
 
-autoScalaLibrary := false
\ No newline at end of file
+autoScalaLibrary := false
diff --git a/sbt/src/sbt-test/dependency-management/metadata-only-resolver/test b/sbt/src/sbt-test/dependency-management/metadata-only-resolver/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/metadata-only-resolver/test
rename to sbt/src/sbt-test/dependency-management/metadata-only-resolver/disabled
diff --git a/sbt/src/sbt-test/dependency-management/missingok/build.sbt b/sbt/src/sbt-test/dependency-management/missingok/build.sbt
new file mode 100644
index 000000000..51257fd6e
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/missingok/build.sbt
@@ -0,0 +1,40 @@
+ThisBuild / scalaVersion := "2.13.2"
+libraryDependencies ++= Seq(
+  "com.chuusai" %% "shapeless" % "2.3.3",
+  // non-existing
+  "org.webjars" % "npm" % "0.0.99"
+)
+updateConfiguration := updateConfiguration.value.withMissingOk(true)
+
+lazy val check = taskKey[Unit]("")
+
+check := {
+  val updateReport = update.value
+  val updateClassifiersReport = updateClassifiers.value
+
+  val compileReport = updateReport
+    .configuration(Compile)
+    .getOrElse {
+      sys.error("Compile configuration not found in update report")
+    }
+
+  val compileClassifiersReport = updateClassifiersReport
+    .configuration(Compile)
+    .getOrElse {
+      sys.error("Compile configuration not found in update classifiers report")
+    }
+
+  val shapelessModule = compileReport
+    .modules
+    .find(_.module.name == "shapeless_2.13")
+    .getOrElse {
+      sys.error(s"shapeless module not found in ${compileReport.modules.map(_.module)}")
+    }
+
+  val shapelessClassifiersModule = compileClassifiersReport
+    .modules
+    .find(_.module.name == "shapeless_2.13")
+    .getOrElse {
+      sys.error(s"shapeless module not found in ${compileClassifiersReport.modules.map(_.module)}")
+    }
+}
diff --git a/sbt/src/sbt-test/dependency-management/missingok/test b/sbt/src/sbt-test/dependency-management/missingok/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/missingok/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/dependency-management/module-confs/common.sbt b/sbt/src/sbt-test/dependency-management/module-confs/common.sbt
index c24da6b6e..86036e170 100644
--- a/sbt/src/sbt-test/dependency-management/module-confs/common.sbt
+++ b/sbt/src/sbt-test/dependency-management/module-confs/common.sbt
@@ -1,8 +1,10 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 ivyScala ~= { (is: Option[IvyScala]) => is.map(_.copy(checkExplicit = false, overrideScalaVersion = false, filterImplicit = false)) }
 
-ivyPaths := baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy-home"))).value
+ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy-home"))).value
 
-libraryDependencies += "junit" % "junit" % "4.8"
+libraryDependencies += "junit" % "junit" % "4.13.1"
 
 autoScalaLibrary := false
 
diff --git a/sbt/src/sbt-test/dependency-management/module-confs/pending b/sbt/src/sbt-test/dependency-management/module-confs/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/module-confs/pending
rename to sbt/src/sbt-test/dependency-management/module-confs/disabled
diff --git a/sbt/src/sbt-test/dependency-management/module-name/build.sbt b/sbt/src/sbt-test/dependency-management/module-name/build.sbt
index 95bc29025..4b8870e04 100644
--- a/sbt/src/sbt-test/dependency-management/module-name/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/module-name/build.sbt
@@ -4,8 +4,10 @@ moduleName := "asdf"
 
 crossPaths := false
 
-TaskKey[Unit]("checkName") := ((moduleName, name, packageBin in Compile) map { (module, n, f) =>
-  val path = f.getAbsolutePath 
-  assert(path contains module, "Path " + path + " did not contain module name " + module)
-  assert(!path.contains(n), "Path " + path + " contained " + n)
-}).value
+TaskKey[Unit]("checkName") := Def task {
+  val path = (packageBin in Compile).value.getAbsolutePath
+  val module = moduleName.value
+  val n = name.value
+  assert(path contains module, s"Path $path did not contain module name $module")
+  assert(!path.contains(n), s"Path $path contained $n")
+}
diff --git a/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt b/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt
index edfe34b9c..914cd1837 100644
--- a/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt
@@ -1,6 +1,8 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def commonSettings: Seq[Def.Setting[_]] =
   Seq(
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),
     dependencyCacheDirectory := (baseDirectory in LocalRootProject).value / "dependency",
     scalaVersion := "2.10.4",
     organization in ThisBuild := "org.example",
diff --git a/sbt/src/sbt-test/dependency-management/mvn-local/changes/libDeps.sbt b/sbt/src/sbt-test/dependency-management/mvn-local/changes/libDeps.sbt
index f61fd2191..25f96212f 100644
--- a/sbt/src/sbt-test/dependency-management/mvn-local/changes/libDeps.sbt
+++ b/sbt/src/sbt-test/dependency-management/mvn-local/changes/libDeps.sbt
@@ -1 +1 @@
-libraryDependencies += "junit" % "junit" % "4.11"
+libraryDependencies += "junit" % "junit" % "4.13.1"
diff --git a/sbt/src/sbt-test/dependency-management/mvn-local/disabled b/sbt/src/sbt-test/dependency-management/mvn-local/disabled
index 190bf8a89..b7eb9f51f 100644
--- a/sbt/src/sbt-test/dependency-management/mvn-local/disabled
+++ b/sbt/src/sbt-test/dependency-management/mvn-local/disabled
@@ -3,7 +3,7 @@
 
 > library/publishM2
 
-# should suceed because local Ivy repository works
+# should succeed because local Ivy repository works
 > main/update
 
 # should succeed when local Maven repository is added
@@ -19,7 +19,6 @@ $ copy-file changes/mainB1.scala main/B.scala
 -> main/compile
 
 $ copy-file changes/libA.scala library/A.scala
-> debug
 > library/publishM2
 # should succeed even without 'update' because Ivy should use the jar from the origin and not copy it to its cache
 > main/compile
diff --git a/sbt/src/sbt-test/dependency-management/no-file-fails-publish/build.sbt b/sbt/src/sbt-test/dependency-management/no-file-fails-publish/build.sbt
index 15c50d013..f02e86fd9 100644
--- a/sbt/src/sbt-test/dependency-management/no-file-fails-publish/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/no-file-fails-publish/build.sbt
@@ -1,4 +1,6 @@
-ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
 
 organization := "org.example"
 
@@ -9,4 +11,4 @@ autoScalaLibrary := false
 addArtifact(
 	name { n => Artifact(n, "txt", "txt") },
 	baseDirectory map { _ / "topublish.txt" }
-)
\ No newline at end of file
+)
diff --git a/sbt/src/sbt-test/dependency-management/no-pom-artifact/build.sbt b/sbt/src/sbt-test/dependency-management/no-pom-artifact/build.sbt
new file mode 100644
index 000000000..7465c34d7
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/no-pom-artifact/build.sbt
@@ -0,0 +1,30 @@
+
+lazy val noPomCheck = TaskKey[Unit]("noPomCheck")
+
+noPomCheck := {
+
+  val log = streams.value.log
+
+  val configReport = update.value
+    .configuration(Compile)
+    .getOrElse {
+      throw new Exception(
+        "compile configuration not found in update report"
+      )
+    }
+
+  val artifacts = configReport
+    .modules
+    .flatMap(_.artifacts)
+    .map(_._1)
+
+  val pomArtifacts = artifacts
+    .filter { a =>
+      a.`type` == "pom" && a.classifier.isEmpty
+    }
+
+  for (a <- pomArtifacts)
+    log.error(s"Found POM artifact $a")
+
+  assert(pomArtifacts.isEmpty)
+}
diff --git a/sbt/src/sbt-test/dependency-management/no-pom-artifact/test b/sbt/src/sbt-test/dependency-management/no-pom-artifact/test
new file mode 100644
index 000000000..67b4dc666
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/no-pom-artifact/test
@@ -0,0 +1 @@
+> noPomCheck
diff --git a/sbt/src/sbt-test/dependency-management/override/build.sbt b/sbt/src/sbt-test/dependency-management/override/build.sbt
index ba454e7d3..0508fa0d7 100644
--- a/sbt/src/sbt-test/dependency-management/override/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/override/build.sbt
@@ -1,16 +1,22 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 autoScalaLibrary := false
 
-ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value
+ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
 
-ivyScala := ((scalaVersion in update, scalaBinaryVersion in update) { (fv, bv) =>
-	Some(new IvyScala(fv, bv, Nil, filterImplicit = false, checkExplicit = false, overrideScalaVersion = false))
-}).value
+scalaModuleInfo := Some(sbt.librarymanagement.ScalaModuleInfo(
+  (scalaVersion in update).value,
+  (scalaBinaryVersion in update).value,
+  Vector.empty,
+  checkExplicit = false,
+  filterImplicit = false,
+  overrideScalaVersion = false
+))
 
-InputKey[Unit]("check") := (inputTask { args => 
-	(update, args) map {
-		case (report, Seq(expected, _*)) =>
-			report.allModules.forall(_.revision == expected)
-	}
-}).evaluated
+InputKey[Unit]("check") := {
+  val args = Def.spaceDelimited().parsed
+  val Seq(expected, _*) = args
+  update.value.allModules.forall(_.revision == expected)
+}
 
-scalaVersion := "2.9.1"
\ No newline at end of file
+scalaVersion := "2.9.1"
diff --git a/sbt/src/sbt-test/dependency-management/override/test b/sbt/src/sbt-test/dependency-management/override/test
index dfcf1da95..c2a6eea44 100644
--- a/sbt/src/sbt-test/dependency-management/override/test
+++ b/sbt/src/sbt-test/dependency-management/override/test
@@ -1,19 +1,19 @@
 > 'set libraryDependencies := Seq("junit" % "junit" % "3.8.1" % "test")'
 > check 3.8.1
-> 'set dependencyOverrides := Set("junit" % "junit" % "4.5")'
+> 'set dependencyOverrides := Vector("junit" % "junit" % "4.5")'
 > check 4.5
 
 > 'set libraryDependencies := Seq("junit" % "junit" % "4.5" % "test")'
 > check 4.5
-> 'set dependencyOverrides := Set("junit" % "junit" % "3.8.1")'
+> 'set dependencyOverrides := Vector("junit" % "junit" % "3.8.1")'
 > check 3.8.1
 
 > 'set libraryDependencies := Seq("net.databinder" %% "dispatch-http" % "0.8.7")'
 > check 0.8.7
-> 'set dependencyOverrides := Set("net.databinder" %% "dispatch-http" % "0.8.6")'
+> 'set dependencyOverrides := Vector("net.databinder" %% "dispatch-http" % "0.8.6")'
 > check 0.8.6
 
 > 'set libraryDependencies := Seq("net.databinder" %% "dispatch-http" % "0.8.6")'
 > check 0.8.6
-> 'set dependencyOverrides := Set("net.databinder" %% "dispatch-http" % "0.8.7")'
+> 'set dependencyOverrides := Vector("net.databinder" %% "dispatch-http" % "0.8.7")'
 > check 0.8.7
diff --git a/sbt/src/sbt-test/dependency-management/override2/build.sbt b/sbt/src/sbt-test/dependency-management/override2/build.sbt
index f4ff463f6..4a4cee7c6 100644
--- a/sbt/src/sbt-test/dependency-management/override2/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/override2/build.sbt
@@ -1,11 +1,14 @@
-sbtBinaryVersion := "0.11.2"
+lazy val check = taskKey[Unit]("Runs the check")
 
-addSbtPlugin("com.typesafe.sbtscalariform" % "sbtscalariform" % "0.3.0", sbtVersion = "0.11.2", scalaVersion = "2.9.1")
-
-scalaBinaryVersion := "2.9.1"
-
-resolvers += Classpaths.typesafeResolver
-
-dependencyOverrides := Set("com.typesafe.sbtscalariform" % "sbtscalariform" % "0.3.1")
-
-autoScalaLibrary := false
\ No newline at end of file
+lazy val root = (project in file("."))
+  .settings(
+    autoScalaLibrary := false, 
+    libraryDependencies += "org.webjars.npm" % "is-odd" % "2.0.0",
+    dependencyOverrides += "org.webjars.npm" % "is-number" % "5.0.0",
+    check := {
+      val cp = (Compile / externalDependencyClasspath).value.map {_.data.getName}.sorted
+      if (!(cp contains "is-number-5.0.0.jar")) {
+        sys.error("is-number-5.0.0 not found when it should be included: " + cp.toString)
+      }
+    }
+  )
diff --git a/sbt/src/sbt-test/dependency-management/override2/test b/sbt/src/sbt-test/dependency-management/override2/test
index 103bd8d2f..15675b169 100644
--- a/sbt/src/sbt-test/dependency-management/override2/test
+++ b/sbt/src/sbt-test/dependency-management/override2/test
@@ -1 +1 @@
-> update
+> check
diff --git a/sbt/src/sbt-test/dependency-management/pom-advanced/build.sbt b/sbt/src/sbt-test/dependency-management/pom-advanced/build.sbt
index 8db20a07c..0fd69fb42 100644
--- a/sbt/src/sbt-test/dependency-management/pom-advanced/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/pom-advanced/build.sbt
@@ -1,33 +1,42 @@
 import complete.DefaultParsers._
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val root = (project in file(".")).
   settings(
     resolvers ++= Seq(local, Resolver.sonatypeRepo("releases"), Resolver.sonatypeRepo("snapshots")),
-    InputKey[Unit]("checkPom") := (InputTask(_ => spaceDelimited("<args>")) { result => (makePom, result, streams) map checkPomRepositories }).evaluated,
-    makePomConfiguration := ((makePomConfiguration, baseDirectory) { (conf, base) =>
-      conf.copy(filterRepositories = pomIncludeRepository(base, conf.filterRepositories) )
-    }).value,
-    ivyPaths := baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy-home"))).value
+    InputKey[Unit]("checkPom") := {
+      val result = spaceDelimited("<args>").parsed
+      checkPomRepositories(makePom.value, result, streams.value)
+    },
+    makePomConfiguration := {
+      val conf = makePomConfiguration.value
+      conf
+        .withFilterRepositories(pomIncludeRepository(baseDirectory.value, conf.filterRepositories))
+    },
+    ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy-home"))).value
   )
 
 val local = "local-maven-repo" at "file://" + (Path.userHome / ".m2" /"repository").absolutePath
 
-def pomIncludeRepository(base: File, prev: MavenRepository => Boolean) = (r: MavenRepository) =>
-  if(base / "repo.none" exists) false else if(base / "repo.all" exists) true else prev(r)
+def pomIncludeRepository(base: File, prev: MavenRepository => Boolean): MavenRepository => Boolean = {
+  case r: MavenRepository if (r.name == "local-preloaded") => false
+  case r: MavenRepository if (base  / "repo.none" exists)  => false
+  case r: MavenRepository if (base / "repo.all" exists)    => true
+  case r: MavenRepository => prev(r)
+}
 
-def addSlash(s: String): String =
-  s match {
-    case s if s endsWith "/" => s
-    case _ => s + "/"
-  }
+def addSlash(s: String): String = s match {
+  case s if s endsWith "/" => s
+  case _ => s + "/"
+}
 
-def checkPomRepositories(file: File, args: Seq[String], s: TaskStreams)
-{
+def checkPomRepositories(file: File, args: Seq[String], s: TaskStreams) {
   val repositories = scala.xml.XML.loadFile(file) \\ "repository"
   val extracted = repositories.map { repo => MavenRepository(repo \ "name" text, addSlash(repo \ "url" text)) }
   val expected = args.map(GlobFilter.apply)
   s.log.info("Extracted: " + extracted.mkString("\n\t", "\n\t", "\n"))
   s.log.info("Expected: " + args.mkString("\n\t", "\n\t", "\n"))
   extracted.find { e => !expected.exists(_.accept(e.root)) } map { "Repository should not be exported: " + _ } orElse
-    (expected.find { e => !extracted.exists(r => e.accept(r.root)) } map { "Repository should be exported: " + _ } ) foreach error
+    (expected.find { e => !extracted.exists(r => e.accept(r.root)) } map { "Repository should be exported: " + _ } ) foreach sys.error
 }
diff --git a/sbt/src/sbt-test/dependency-management/pom-advanced/test b/sbt/src/sbt-test/dependency-management/pom-advanced/test
index 7d6449de8..1fb460f11 100644
--- a/sbt/src/sbt-test/dependency-management/pom-advanced/test
+++ b/sbt/src/sbt-test/dependency-management/pom-advanced/test
@@ -1,11 +1,10 @@
 # write the default pom.  The only repositories should be Scala Tools Releases and Snapshots
-> checkPom https://oss.sonatype.org/content/repositories/releases/ https://oss.sonatype.org/content/repositories/snapshots/
+> checkPom https://scala-ci.typesafe.com/artifactory/scala-integration/ https://scala-ci.typesafe.com/artifactory/scala-pr-validation-snapshots/ https://oss.sonatype.org/content/repositories/releases/ https://oss.sonatype.org/content/repositories/snapshots/
 
 # include file:// repositories.  The generated repositories section should include the local Maven repository as well
 $ touch repo.all
-> checkPom https://oss.sonatype.org/content/repositories/releases/ https://oss.sonatype.org/content/repositories/snapshots/ file://*.m2/repository/
+> checkPom https://scala-ci.typesafe.com/artifactory/scala-integration/ https://scala-ci.typesafe.com/artifactory/scala-pr-validation-snapshots/ https://oss.sonatype.org/content/repositories/releases/ https://oss.sonatype.org/content/repositories/snapshots/ file://*.m2/repository/
 
-# include file:// repositories.  The generated repositories section should include the local Maven repository as well
 $ delete repo.all
 $ touch repo.none
 > checkPom
diff --git a/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt b/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt
index ea5889151..8e57b688a 100644
--- a/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / useCoursier := false
+
 import complete._
 import complete.DefaultParsers._
 
@@ -6,20 +8,20 @@ lazy val root = (project in file(".")).
     externalPom(),
     scalaVersion := "2.9.0-1",
     check := checkTask.evaluated,
-    managedClasspath in Provided := ((classpathTypes, update) map { (cpts, report) => Classpaths.managedJars(Provided, cpts, report) }).value
+    managedClasspath in Provided := Classpaths.managedJars(Provided, classpathTypes.value, update.value)
   )
 
-def checkTask = InputTask(_ => parser ) { result =>
-    (result, managedClasspath in Provided, fullClasspath in Compile, fullClasspath in Test, fullClasspath in Runtime) map { case ((conf, names), p, c, t, r) =>
-      println("Checking: " + conf.name)
-      checkClasspath(conf match {
-        case Provided => p
-        case Compile => c
-        case Test => t
-        case Runtime => r
-      }, names.toSet)
-    }
-  }
+def checkTask = Def.inputTask {
+  val result = parser.parsed
+  val (conf, names) = result
+  println("Checking: " + conf.name)
+  checkClasspath(conf match {
+    case Provided => managedClasspath in Provided value
+    case Compile  => fullClasspath in Compile value
+    case Test     => fullClasspath in Test value
+    case Runtime  => fullClasspath in Runtime value
+  }, names.toSet)
+}
 
 lazy val check = InputKey[Unit]("check")
 def parser: Parser[(Configuration,Seq[String])] = (Space ~> token(cp(Compile) | cp(Runtime) | cp(Provided) | cp(Test))) ~ spaceDelimited("<module-names>")
diff --git a/sbt/src/sbt-test/dependency-management/pom-packaging/build.sbt b/sbt/src/sbt-test/dependency-management/pom-packaging/build.sbt
index 547d5bc8a..174a827f3 100644
--- a/sbt/src/sbt-test/dependency-management/pom-packaging/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/pom-packaging/build.sbt
@@ -1,35 +1,21 @@
-import sbt.Def.Initialize
+val root = project in file(".")
 
-lazy val checkPom = taskKey[Unit]("")
+val subJar = project in file("subJar")
 
-lazy val root = (project in file(".")).
-  settings(
-    checkPom in ThisBuild := checkPomTask.value
-  )
+def warArtifact = artifact in (Compile, packageBin) ~= (_ withType "war" withExtension "war")
+val subWar = project in file("subWar") settings warArtifact
 
-lazy val subJar = (project in file("subJar"))
+val subParent = project in file("subParent") settings (publishArtifact in Compile := false)
 
-lazy val subWar = (project in file("subWar")).
-  settings(
-    warArtifact
-  )
-
-lazy val subParent = (project in file("subParent")).
-  settings(
-    publishArtifact in Compile := false
-  )
-
-def art(p: ProjectReference) = makePom in p
-def checkPomTask: Initialize[Task[Unit]] =
-  (art(subJar), art(subWar), art(subParent)) map { (jar, war, pom) =>
-    checkPackaging(jar, "jar")
-    checkPackaging(war, "war")
-    checkPackaging(pom, "pom")
-  }
-
-def checkPackaging(pom: File, expected: String) =
-{
-  val packaging = (xml.XML.loadFile(pom) \\ "packaging").text
-  if(packaging != expected) sys.error("Incorrect packaging for '" + pom + "'.  Expected '" + expected + "', but got '" + packaging + "'")
+val checkPom = taskKey[Unit]("")
+checkPom in ThisBuild := {
+  checkPackaging((makePom in subJar).value, "jar")
+  checkPackaging((makePom in subWar).value, "war")
+  checkPackaging((makePom in subParent).value, "pom")
+}
+
+def checkPackaging(pom: File, expected: String) = {
+  val packaging = (xml.XML.loadFile(pom) \\ "packaging").text
+  if (packaging != expected)
+    sys error s"Incorrect packaging for '$pom'.  Expected '$expected', but got '$packaging'"
 }
-def warArtifact = artifact in (Compile, packageBin) ~= { _.copy(`type` = "war", extension = "war") }
diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt b/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt
index e190be9b2..32ba36863 100644
--- a/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt
@@ -1,24 +1,28 @@
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 val checkIvyXml = taskKey[Unit]("Checks the ivy.xml transform was correct")
 
 lazy val root = (project in file(".")).
   settings(
     name := "test-parent-pom",
-    ivyPaths := new IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
+    ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
     resolvers += MavenCache("Maven2 Local Test", baseDirectory.value / "local-repo"),
     libraryDependencies += "com.example" % "example-child" % "1.0-SNAPSHOT",
     libraryDependencies += "org.apache.geronimo.specs" % "geronimo-jta_1.1_spec" % "1.1.1",
     version := "1.0-SNAPSHOT",
     autoScalaLibrary := false,
     checkIvyXml := {
+      val resolverConverter = updateOptions.value.resolverConverter
       ivySbt.value.withIvy(streams.value.log) { ivy =>
         val cacheDir = ivy.getSettings.getDefaultRepositoryCacheBasedir
         val xmlFile  =
           cacheDir / "org.apache.geronimo.specs" / "geronimo-jta_1.1_spec" / "ivy-1.1.1.xml"
         val lines = IO.read(xmlFile)
         if(lines.isEmpty) sys.error(s"Unable to read $xmlFile, could not resolve geronimo...")
-        // Note: We do not do this if the maven plguin is enabled, because there is no rewrite of ivy.xml, extra attribtues
+        // Note: We do not do this if the maven plugin is enabled, because there is no rewrite of ivy.xml, extra attributes
         // are handled in a different mechanism.  This is a hacky mechanism to detect that.
-        val isMavenResolver = updateOptions.value.resolverConverter != PartialFunction.empty
+        val isMavenResolver = resolverConverter != PartialFunction.empty
         if(!isMavenResolver) assert(lines contains "xmlns:e", s"Failed to appropriately modify ivy.xml file for sbt extra attributes!\n$lines")
 
         val xmlFile2 = cacheDir / "com.example" / "example-child" / "ivy-1.0-SNAPSHOT.xml"
diff --git a/sbt/src/sbt-test/dependency-management/pom-scope/build.sbt b/sbt/src/sbt-test/dependency-management/pom-scope/build.sbt
index 6977b4fea..a1df43ecb 100644
--- a/sbt/src/sbt-test/dependency-management/pom-scope/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/pom-scope/build.sbt
@@ -1,15 +1,19 @@
-lazy val custom = config("custom")
+lazy val Custom = config("custom")
 
 lazy val root = (project in file(".")).
-  configs(custom).
+  configs(Custom).
   settings(
     TaskKey[Unit]("checkPom") := checkPom.value,
+    makePomConfiguration := {
+      val p = makePomConfiguration.value
+      p.withConfigurations(Configurations.defaultMavenConfigurations :+ Custom)
+    },
     libraryDependencies ++= Seq(
       "a" % "a" % "1.0",
       "b" % "b" % "1.0" % "runtime,optional",
       "c" % "c" % "1.0" % "optional",
       "d" % "d" % "1.0" % "test",
-      "e" % "e" % "1.0" % "custom",
+      "e" % "e" % "1.0" % Custom,
       "f" % "f" % "1.0" % "custom,optional,runtime",
       "g" % "g" % "1.0" % "custom,runtime" classifier "foo",
       "h" % "h" % "1.0" % "custom,optional,runtime" classifier "foo"
diff --git a/sbt/src/sbt-test/dependency-management/profiles/build.sbt b/sbt/src/sbt-test/dependency-management/profiles/build.sbt
new file mode 100644
index 000000000..33b6f2f72
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/profiles/build.sbt
@@ -0,0 +1,5 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat
+libraryDependencies += "org.apache.spark" %% "spark-sql" % "1.6.2"
+csrMavenProfiles += "hadoop-2.6"
diff --git a/sbt/src/sbt-test/dependency-management/profiles/output b/sbt/src/sbt-test/dependency-management/profiles/output
new file mode 100644
index 000000000..a0aba9318
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/profiles/output
@@ -0,0 +1 @@
+OK
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/profiles/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/profiles/src/main/scala/Main.scala
new file mode 100644
index 000000000..9ac86fe34
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/profiles/src/main/scala/Main.scala
@@ -0,0 +1,19 @@
+import java.io.File
+import java.nio.file.Files
+
+object Main extends App {
+  val p = new java.util.Properties
+  p.load(
+    Thread.currentThread()
+      .getContextClassLoader
+      .getResource("common-version-info.properties")
+      .openStream()
+  )
+
+  val hadoopVersion = p.getProperty("version")
+  Console.err.println(s"Found hadoop version $hadoopVersion")
+
+  assert(hadoopVersion == "2.6.0")
+
+  Files.write(new File("output").toPath, "OK".getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/profiles/test b/sbt/src/sbt-test/dependency-management/profiles/test
new file mode 100644
index 000000000..2182f57b0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/profiles/test
@@ -0,0 +1,3 @@
+$ delete output
+> run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/provided-multi/changes/p.sbt b/sbt/src/sbt-test/dependency-management/provided-multi/changes/p.sbt
index 33584366f..4765c39d3 100644
--- a/sbt/src/sbt-test/dependency-management/provided-multi/changes/p.sbt
+++ b/sbt/src/sbt-test/dependency-management/provided-multi/changes/p.sbt
@@ -1,5 +1,5 @@
 def configIvyScala =
-  ivyScala ~= { _.map(_.copy(checkExplicit = false)) }
+  scalaModuleInfo ~= (_ map (_ withCheckExplicit false))
 
 val declared = SettingKey[Boolean]("declared")
 lazy val a = project.
diff --git a/sbt/src/sbt-test/dependency-management/provided/build.sbt b/sbt/src/sbt-test/dependency-management/provided/build.sbt
index fd7634e61..3f01f3c0d 100644
--- a/sbt/src/sbt-test/dependency-management/provided/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/provided/build.sbt
@@ -5,26 +5,30 @@ val check = InputKey[Unit]("check")
 
 lazy val root = (project in file(".")).
   settings(
-    provided := baseDirectory(_ / "useProvided" exists).value,
-    configuration := provided(p => if(p) Provided else Compile).value,
-    libraryDependencies += configuration(c => "javax.servlet" % "servlet-api" % "2.5" % c.name).value,
-    managedClasspath in Provided := ((classpathTypes, update) map { (cpts, report) => Classpaths.managedJars(Provided, cpts, report) }).value,
-    check := (InputTask(_ => Space ~> token(Compile.name.id | Runtime.name | Provided.name | Test.name) ~ token(Space ~> Bool)) { result =>
-      (result, managedClasspath in Provided, fullClasspath in Runtime, fullClasspath in Compile, fullClasspath in Test) map { case ((conf, expected), p, r, c, t) =>
-        val cp = if(conf == Compile.name) c else if(conf == Runtime.name) r else if(conf == Provided.name) p else if(conf == Test.name) t else sys.error("Invalid config: " + conf)
-        checkServletAPI(cp.files, expected, conf)
+    provided := (baseDirectory.value / "useProvided" exists),
+    configuration := (if (provided.value) Provided else Compile),
+    libraryDependencies += "javax.servlet" % "servlet-api" % "2.5" % configuration.value.name,
+    managedClasspath in Provided := Classpaths.managedJars(Provided, classpathTypes.value, update.value),
+    check := {
+      val result = (
+        Space ~> token(Compile.name.id | Runtime.name | Provided.name | Test.name) ~ token(Space ~> Bool)
+      ).parsed
+      val (conf, expected) = result
+      val cp = conf match {
+        case Compile.name  => (fullClasspath in Compile).value
+        case Runtime.name  => (fullClasspath in Runtime).value
+        case Provided.name => (managedClasspath in Provided).value
+        case Test.name     => (fullClasspath in Test).value
+        case _             => sys.error(s"Invalid config: $conf")
       }
-    }).evaluated
+      checkServletAPI(cp.files, expected, conf)
+    }
   )
 
-def checkServletAPI(paths: Seq[File], shouldBeIncluded: Boolean, label: String) =
-  {
-    val servletAPI = paths.find(_.getName contains "servlet-api")
-    if(shouldBeIncluded)
-    {
-      if(servletAPI.isEmpty)
-        sys.error("Servlet API should have been included in " + label + ".")
-    }
-    else
-      servletAPI.foreach(s => sys.error(s + " incorrectly included in " + label + "."))
-  }
+def checkServletAPI(paths: Seq[File], shouldBeIncluded: Boolean, label: String) = {
+  val servletAPI = paths.find(_.getName contains "servlet-api")
+  if (shouldBeIncluded) {
+    if (servletAPI.isEmpty) sys.error(s"Servlet API should have been included in $label.")
+  } else
+    servletAPI foreach (s => sys.error(s"$s incorrectly included in $label."))
+}
diff --git a/sbt/src/sbt-test/dependency-management/publish-local/build.sbt b/sbt/src/sbt-test/dependency-management/publish-local/build.sbt
index d7aaf442c..8076f5a1b 100644
--- a/sbt/src/sbt-test/dependency-management/publish-local/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/publish-local/build.sbt
@@ -1,10 +1,12 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val root = (project in file(".")).
   dependsOn(sub).
   aggregate(sub).
   settings(inThisBuild(List(
       organization := "A",
       version := "1.0",
-      ivyPaths := baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy" / "cache")) ).value,
+      ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy" / "cache")) ).value,
       externalResolvers := (baseDirectory map { base => Resolver.file("local", base / "ivy" / "local" asFile)(Resolver.ivyStylePatterns) :: Nil }).value
     )),
     mavenStyle,
diff --git a/sbt/src/sbt-test/dependency-management/publish-local/changes/RetrieveTest.sbt b/sbt/src/sbt-test/dependency-management/publish-local/changes/RetrieveTest.sbt
index 9f1617128..c7ee8cd16 100644
--- a/sbt/src/sbt-test/dependency-management/publish-local/changes/RetrieveTest.sbt
+++ b/sbt/src/sbt-test/dependency-management/publish-local/changes/RetrieveTest.sbt
@@ -1,8 +1,10 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val root = (project in file(".")).
   settings(inThisBuild(List(
       organization := "A",
       version := "1.0",
-      ivyPaths := baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy" / "cache")) ).value,
+      ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy" / "cache")) ).value,
       externalResolvers := (baseDirectory map { base => Resolver.file("local", base / "ivy" / "local" asFile)(Resolver.ivyStylePatterns) :: Nil }).value
     )),
     mavenStyle,
diff --git a/sbt/src/sbt-test/dependency-management/resolvers-plugin/build.sbt b/sbt/src/sbt-test/dependency-management/resolvers-plugin/build.sbt
new file mode 100644
index 000000000..5d76d6c17
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/resolvers-plugin/build.sbt
@@ -0,0 +1,7 @@
+lazy val check = taskKey[Unit]("")
+ThisBuild / includePluginResolvers := true
+
+check := {
+  val rs = fullResolvers.value
+  assert(rs exists (_.name == "bintray-eed3si9n-sbt-plugins"), s"$rs does not include bintray")
+}
diff --git a/sbt/src/sbt-test/dependency-management/resolvers-plugin/project/plugins.sbt b/sbt/src/sbt-test/dependency-management/resolvers-plugin/project/plugins.sbt
new file mode 100644
index 000000000..ec0f62ee9
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/resolvers-plugin/project/plugins.sbt
@@ -0,0 +1 @@
+resolvers += Resolver.bintrayRepo("eed3si9n", "sbt-plugins")
diff --git a/sbt/src/sbt-test/dependency-management/resolvers-plugin/test b/sbt/src/sbt-test/dependency-management/resolvers-plugin/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/resolvers-plugin/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt b/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt
index 4568f6663..980fcc3cd 100644
--- a/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / useCoursier := false
+
 retrieveManaged := true
 
 libraryDependencies += "log4j" % "log4j" % "1.2.16"
diff --git a/sbt/src/sbt-test/dependency-management/scala-home/changes/real-build.sbt b/sbt/src/sbt-test/dependency-management/scala-home/changes/real-build.sbt
index 7055185a2..1d278bf35 100644
--- a/sbt/src/sbt-test/dependency-management/scala-home/changes/real-build.sbt
+++ b/sbt/src/sbt-test/dependency-management/scala-home/changes/real-build.sbt
@@ -1,5 +1,3 @@
-import sbt.internal.librarymanagement.syntax._
-
 scalaHome := Some(baseDirectory.value / "home")
 
 val checkUpdate = taskKey[Unit]("Ensures that resolved Scala artifacts are replaced with ones from the configured Scala home directory")
diff --git a/sbt/src/sbt-test/dependency-management/scala-organization-version-check/build.sbt b/sbt/src/sbt-test/dependency-management/scala-organization-version-check/build.sbt
new file mode 100644
index 000000000..c969842f7
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala-organization-version-check/build.sbt
@@ -0,0 +1,23 @@
+scalaOrganization := "org.other"
+
+scalaArtifacts += "thing"
+
+ThisBuild / scalaVersion := "2.11.12"
+
+libraryDependencies ++= Seq(
+  "org.other" % "thing" % "1.2.3",
+  "org.other" %% "wotsit" % "4.5.6"
+)
+
+lazy val check = taskKey[Unit]("Runs the check")
+
+check := {
+  val lastLog = BuiltinCommands lastLogFile state.value
+  val last = IO read lastLog.get
+  def containsWarn1 = last contains "Binary version (1.2.3) for dependency org.other#thing;1.2.3"
+  def containsWarn2 = last contains "Binary version (4.5.6) for dependency org.other#wotsit_2.11;4.5.6"
+  def containsWarn3 = last contains "differs from Scala binary version in project (2.11)."
+  if (!containsWarn1) sys error "thing should not be exempted from the Scala binary version check"
+  if (containsWarn2)  sys error "wotsit should be exempted from the Scala binary version check"
+  if (!containsWarn3) sys error "Binary version check failed"
+}
diff --git a/sbt/src/sbt-test/dependency-management/scala-organization-version-check/test b/sbt/src/sbt-test/dependency-management/scala-organization-version-check/test
new file mode 100644
index 000000000..760ba6309
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala-organization-version-check/test
@@ -0,0 +1,3 @@
+> clean
+
+> check
diff --git a/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt b/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt
index 217b3f4d7..068fe0611 100644
--- a/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / useCoursier := false
+
 organization := "org.dummy"
 
 scalaOrganization := "org.other"
@@ -6,8 +8,8 @@ scalaVersion := "2.11.8"
 
 resolvers += Resolver.file("buggy", (baseDirectory in LocalRootProject).value / "repo")(
   Patterns(
-    ivyPatterns = Seq("[organization]/[module]/[revision]/ivy.xml"),
-    artifactPatterns = Seq("[organization]/[module]/[revision]/dummy.jar"),
+    ivyPatterns = Vector("[organization]/[module]/[revision]/ivy.xml"),
+    artifactPatterns = Vector("[organization]/[module]/[revision]/dummy.jar"),
     isMavenCompatible = false,
     descriptorOptional = true,
     skipConsistencyCheck = true
@@ -16,7 +18,7 @@ resolvers += Resolver.file("buggy", (baseDirectory in LocalRootProject).value /
 
 libraryDependencies += "org.typelevel" %% "cats" % "0.6.0"
 
-val checkDependencies = taskKey[Unit]("Checks that dependcies are correct.")
+val checkDependencies = taskKey[Unit]("Checks that dependencies are correct.")
 
 checkDependencies := {
   val expected: Set[ModuleID] = Set(
@@ -48,7 +50,7 @@ checkDependencies := {
       c <- update.value.configurations
       m <- c.modules
       if !m.evicted
-    } yield m.module.copy(extraAttributes = Map.empty)).toSet
+    } yield m.module.withExtraAttributes(Map.empty)).toSet
 
-  assert(resolved == expected)
+  assert(resolved == expected, s"$resolved != $expected")
 }
diff --git a/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-compiler/2.11.8/ivy.xml b/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-compiler/2.11.8/ivy.xml
index c0252721f..06e878d64 100644
--- a/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-compiler/2.11.8/ivy.xml
+++ b/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-compiler/2.11.8/ivy.xml
@@ -1,8 +1,8 @@
 <?xml version='1.0' encoding='ISO-8859-1'?>
 <ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
   <info publication="20160520164059" status="release" revision="2.11.8" module="scala-compiler" organisation="org.other">
-    <license url="http://www.scala-lang.org/license.html" name="BSD 3-Clause"/>
-    <description homepage="http://www.scala-lang.org">
+    <license url="https://www.scala-lang.org/license.html" name="BSD 3-Clause"/>
+    <description homepage="https://www.scala-lang.org">
     Scala Compiler
     </description>
   </info>
diff --git a/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-library/2.11.8/ivy.xml b/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-library/2.11.8/ivy.xml
index fb4924a58..d95819442 100644
--- a/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-library/2.11.8/ivy.xml
+++ b/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-library/2.11.8/ivy.xml
@@ -1,8 +1,8 @@
 <?xml version='1.0' encoding='ISO-8859-1'?>
 <ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
   <info publication="20160520164058" status="release" revision="2.11.8" module="scala-library" organisation="org.other">
-    <license url="http://www.scala-lang.org/license.html" name="BSD 3-Clause"/>
-    <description homepage="http://www.scala-lang.org">
+    <license url="https://www.scala-lang.org/license.html" name="BSD 3-Clause"/>
+    <description homepage="https://www.scala-lang.org">
     Scala Standard Library
     </description>
   </info>
diff --git a/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-reflect/2.11.8/ivy.xml b/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-reflect/2.11.8/ivy.xml
index 169793932..0f9f4a0eb 100644
--- a/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-reflect/2.11.8/ivy.xml
+++ b/sbt/src/sbt-test/dependency-management/scala-organization/repo/org.other/scala-reflect/2.11.8/ivy.xml
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
   <info organisation="org.other" module="scala-reflect" revision="2.11.8" status="release" publication="20160520164058">
-    <license name="BSD 3-Clause" url="http://www.scala-lang.org/license.html"/>
-    <description homepage="http://www.scala-lang.org">
+    <license name="BSD 3-Clause" url="https://www.scala-lang.org/license.html"/>
+    <description homepage="https://www.scala-lang.org">
     Scala Reflection Library
     </description>
   </info>
diff --git a/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt b/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt
index 6f66bc879..540318393 100644
--- a/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt
@@ -1,6 +1,6 @@
 // https://github.com/sbt/sbt/issues/1818
 
-scalaVersion := "2.11.5"
+ThisBuild / scalaVersion := "2.11.12"
 libraryDependencies += "org.scala-lang" %% "scala-actors-migration" % "1.1.0"
 libraryDependencies += "org.scala-lang" %% "scala-pickling" % "0.9.1"
 
diff --git a/sbt/src/sbt-test/dependency-management/scala3-auto-scala-library/build.sbt b/sbt/src/sbt-test/dependency-management/scala3-auto-scala-library/build.sbt
new file mode 100644
index 000000000..9478d98dd
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-auto-scala-library/build.sbt
@@ -0,0 +1,19 @@
+autoScalaLibrary := false
+scalaVersion := "3.0.0-M2"
+libraryDependencies += "com.chuusai" % "shapeless_2.13" % "2.3.3"
+
+val checkScalaLibrary = TaskKey[Unit]("checkScalaLibrary")
+
+checkScalaLibrary := {
+  val scalaLibsJars = (Compile / managedClasspath).value
+    .map(_.data.getName)
+    .filter(name => name.startsWith("scala-library") || name.startsWith("scala3-library"))
+    .sorted
+  val expectedScalaLibsJars = Seq(
+    "scala-library-2.13.0.jar"
+  )
+  assert(
+    scalaLibsJars == expectedScalaLibsJars,
+    s"$scalaLibsJars != $expectedScalaLibsJars"
+  )
+}
diff --git a/sbt/src/sbt-test/dependency-management/scala3-auto-scala-library/test b/sbt/src/sbt-test/dependency-management/scala3-auto-scala-library/test
new file mode 100644
index 000000000..f56f5a75e
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-auto-scala-library/test
@@ -0,0 +1 @@
+> checkScalaLibrary
diff --git a/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/A.scala b/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/A.scala
new file mode 100644
index 000000000..c3ab8e5cc
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/A.scala
@@ -0,0 +1 @@
+val A = "A"
diff --git a/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/build.sbt b/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/build.sbt
new file mode 100644
index 000000000..998afcca4
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/build.sbt
@@ -0,0 +1,8 @@
+ThisBuild / scalaVersion := "3.0.0-M2"
+
+lazy val check = taskKey[Unit]("")
+
+check := {
+  val bridge = scalaCompilerBridgeBinaryJar.value
+  bridge.getOrElse(sys.error(s"bridge JAR is missing"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/test b/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/test
new file mode 100644
index 000000000..5f1fbe2c5
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-compiler-bridge-binary/test
@@ -0,0 +1,2 @@
+> check
+> compile
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-home/build.sbt b/sbt/src/sbt-test/dependency-management/scala3-scala-home/build.sbt
new file mode 100644
index 000000000..e3dcd92e1
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-home/build.sbt
@@ -0,0 +1,9 @@
+scalaVersion := "3.0.0-M2"
+
+val makeHome = taskKey[Unit]("Populates the 'home/lib' directory with Scala jars from the default ScalaInstance")
+
+makeHome := {
+	val lib = baseDirectory.value / "home" / "lib"
+	for(jar <- scalaInstance.value.allJars)
+		IO.copyFile(jar, lib / jar.getName)
+}
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-home/changes/real-build.sbt b/sbt/src/sbt-test/dependency-management/scala3-scala-home/changes/real-build.sbt
new file mode 100644
index 000000000..876da64cf
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-home/changes/real-build.sbt
@@ -0,0 +1,11 @@
+scalaVersion := "3.0.0-M2"
+scalaHome := Some(baseDirectory.value / "home")
+
+val checkUpdate = taskKey[Unit]("Ensures that resolved Scala artifacts are replaced with ones from the configured Scala home directory")
+
+checkUpdate := {
+	val report = update.value
+	val lib = (scalaHome.value.get / "lib").getCanonicalFile
+	for(f <- report.allFiles)
+		assert(f.getParentFile == lib, "Artifact not in Scala home directory: " + f.getAbsolutePath)
+}
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-home/test b/sbt/src/sbt-test/dependency-management/scala3-scala-home/test
new file mode 100644
index 000000000..7eadb9215
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-home/test
@@ -0,0 +1,4 @@
+> makeHome
+$ copy-file changes/real-build.sbt build.sbt
+> reload
+> checkUpdate
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/build.sbt b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/build.sbt
new file mode 100644
index 000000000..dfd1b73e5
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/build.sbt
@@ -0,0 +1,48 @@
+ThisBuild / useCoursier := false
+
+scalaOrganization := "org.other"
+scalaVersion := "3.0.0-M2"
+
+resolvers += Resolver.file("buggy", (baseDirectory in LocalRootProject).value / "repo")(
+  Patterns(
+    ivyPatterns = Vector("[organization]/[module]/[revision]/ivy.xml"),
+    artifactPatterns = Vector("[organization]/[module]/[revision]/dummy.jar"),
+    isMavenCompatible = false,
+    descriptorOptional = true,
+    skipConsistencyCheck = true
+  )
+)
+
+libraryDependencies += "org.typelevel" %% "cats-core" % "2.3.0"
+
+val checkDependencies = taskKey[Unit]("Checks that dependencies are correct.")
+
+checkDependencies := {
+  val expected: Set[ModuleID] = Set(
+    "org.scala-lang.modules" % "scala-asm" % "7.3.1-scala-1",
+    "org.jline" % "jline-reader" % "3.15.0",
+    "com.google.protobuf" % "protobuf-java" % "3.7.0",
+    "org.typelevel" % "cats-kernel_3.0.0-M2" % "2.3.0",
+    "org.jline" % "jline-terminal-jna" % "3.15.0",
+    "org.jline" % "jline-terminal" % "3.15.0",
+    "org.scala-sbt" % "compiler-interface" % "1.3.5",
+    "net.java.dev.jna" % "jna" % "5.3.1",
+    "org.other" % "scala-library" % "2.13.4",
+    "org.other" % "scala3-library_3.0.0-M2" % "3.0.0-M2",
+    "org.typelevel" % "simulacrum-scalafix-annotations_3.0.0-M2" % "0.5.1",
+    "org.other" % "scala3-compiler_3.0.0-M2" % "3.0.0-M2",
+    "org.other" % "scala3-interfaces" % "3.0.0-M2",
+    "org.other" % "tasty-core_3.0.0-M2" % "3.0.0-M2",
+    "org.typelevel" % "cats-core_3.0.0-M2" % "2.3.0",
+    "org.scala-sbt" % "util-interface" % "1.3.0"
+  )
+
+  val resolved: Set[ModuleID] =
+    (for {
+      c <- update.value.configurations
+      m <- c.modules
+      if !m.evicted
+    } yield m.module.withExtraAttributes(Map.empty)).toSet
+
+  assert(resolved == expected, s"$resolved != $expected")
+}
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala-library/2.13.4/dummy.jar b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala-library/2.13.4/dummy.jar
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala-library/2.13.4/ivy.xml b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala-library/2.13.4/ivy.xml
new file mode 100644
index 000000000..6ef3dce02
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala-library/2.13.4/ivy.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
+  <info organisation="org.other" module="scala-library" revision="2.13.4" status="integration" publication="20200731084418" e:info.apiURL="https://www.scala-lang.org/api/2.13.4-bin-SNAPSHOT/">
+    <description homepage="https://www.scala-lang.org">Scala Standard Library</description>
+  </info>
+  <configurations>
+    <conf name="plugin" visibility="public" description=""/>
+    <conf name="pom" visibility="public" description=""/>
+    <conf extends="runtime" name="test" visibility="public" description=""/>
+    <conf name="provided" visibility="public" description=""/>
+    <conf extends="compile,optional,provided" name="compile-internal" visibility="public" description=""/>
+    <conf name="docs" visibility="public" description=""/>
+    <conf name="optional" visibility="public" description=""/>
+    <conf name="compile" visibility="public" description=""/>
+    <conf extends="test,optional,provided" name="test-internal" visibility="public" description=""/>
+    <conf extends="runtime" name="default" visibility="public" description=""/>
+    <conf name="sources" visibility="public" description=""/>
+    <conf extends="compile" name="runtime" visibility="public" description=""/>
+    <conf extends="runtime,optional" name="runtime-internal" visibility="public" description=""/>
+  </configurations>
+  <publications>
+    <artifact name="scala-library" type="pom" ext="pom" conf="pom"/>
+    <artifact e:classifier="sources" name="scala-library" type="src" ext="jar" conf="sources"/>
+    <artifact e:classifier="javadoc" name="scala-library" type="doc" ext="jar" conf="docs"/>
+    <artifact name="scala-library" type="jar" ext="jar" conf="compile"/>
+  </publications>
+  <dependencies/>
+</ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-compiler_3.0.0-M2/3.0.0-M2/dummy.jar b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-compiler_3.0.0-M2/3.0.0-M2/dummy.jar
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-compiler_3.0.0-M2/3.0.0-M2/ivy.xml b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-compiler_3.0.0-M2/3.0.0-M2/ivy.xml
new file mode 100644
index 000000000..5b6236f36
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-compiler_3.0.0-M2/3.0.0-M2/ivy.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
+  <info organisation="org.other" module="scala3-compiler_3.0.0-M2" revision="3.0.0-M2" status="integration" publication="20201202164220">
+    <description homepage="https://github.com/lampepfl/dotty">scala3-compiler</description>
+  </info>
+  <configurations>
+    <conf name="plugin" visibility="public" description=""/>
+    <conf name="pom" visibility="public" description=""/>
+    <conf extends="runtime" name="test" visibility="public" description=""/>
+    <conf name="provided" visibility="public" description=""/>
+    <conf extends="compile,optional,provided" name="compile-internal" visibility="public" description=""/>
+    <conf name="docs" visibility="public" description=""/>
+    <conf name="optional" visibility="public" description=""/>
+    <conf name="compile" visibility="public" description=""/>
+    <conf extends="test,optional,provided" name="test-internal" visibility="public" description=""/>
+    <conf name="sourcedeps" visibility="public" description=""/>
+    <conf name="sources" visibility="public" description=""/>
+    <conf extends="compile" name="runtime" visibility="public" description=""/>
+    <conf extends="runtime,optional" name="runtime-internal" visibility="public" description=""/>
+  </configurations>
+  <publications>
+    <artifact name="scala3-compiler_3.0.0-M2" type="pom" ext="pom" conf="pom"/>
+    <artifact e:classifier="sources" name="scala3-compiler_3.0.0-M2" type="src" ext="jar" conf="sources"/>
+    <artifact e:classifier="javadoc" name="scala3-compiler_3.0.0-M2" type="doc" ext="jar" conf="docs"/>
+    <artifact name="scala3-compiler_3.0.0-M2" type="jar" ext="jar" conf="compile"/>
+  </publications>
+  <dependencies>
+    <dependency org="org.other" name="scala3-interfaces" rev="3.0.0-M2" conf="compile->default(compile)"> </dependency>
+    <dependency org="org.other" name="scala3-library_3.0.0-M2" rev="3.0.0-M2" conf="compile->default(compile)"> </dependency>
+    <dependency org="org.other" name="tasty-core_3.0.0-M2" rev="3.0.0-M2" conf="compile->default(compile)"> </dependency>
+    <dependency org="com.novocode" name="junit-interface" rev="0.11" conf="test->default(compile)"> </dependency>
+    <dependency org="org.scala-lang.modules" name="scala-asm" rev="7.3.1-scala-1" conf="compile->default(compile)"> </dependency>
+    <dependency org="org.scala-sbt" name="compiler-interface" rev="1.3.5" conf="compile->default(compile)"> </dependency>
+    <dependency org="org.jline" name="jline-reader" rev="3.15.0" conf="compile->default(compile)"> </dependency>
+    <dependency org="org.jline" name="jline-terminal" rev="3.15.0" conf="compile->default(compile)"> </dependency>
+    <dependency org="org.jline" name="jline-terminal-jna" rev="3.15.0" conf="compile->default(compile)"> </dependency>
+    <dependency org="org.scala-js" name="scalajs-ir_2.13" rev="1.3.1" conf="sourcedeps->default(compile)"> </dependency>
+  </dependencies>
+</ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-interfaces/3.0.0-M2/dummy.jar b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-interfaces/3.0.0-M2/dummy.jar
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-interfaces/3.0.0-M2/ivy.xml b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-interfaces/3.0.0-M2/ivy.xml
new file mode 100644
index 000000000..cab483d67
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-interfaces/3.0.0-M2/ivy.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
+  <info organisation="org.other" module="scala3-interfaces" revision="3.0.0-M2" status="integration" publication="20201021102556">
+    <description homepage="https://github.com/lampepfl/dotty">scala3-interfaces</description>
+  </info>
+  <configurations>
+    <conf name="plugin" visibility="public" description=""/>
+    <conf name="pom" visibility="public" description=""/>
+    <conf extends="runtime" name="test" visibility="public" description=""/>
+    <conf name="provided" visibility="public" description=""/>
+    <conf extends="compile,optional,provided" name="compile-internal" visibility="public" description=""/>
+    <conf name="docs" visibility="public" description=""/>
+    <conf name="optional" visibility="public" description=""/>
+    <conf name="compile" visibility="public" description=""/>
+    <conf extends="test,optional,provided" name="test-internal" visibility="public" description=""/>
+    <conf name="sources" visibility="public" description=""/>
+    <conf extends="compile" name="runtime" visibility="public" description=""/>
+    <conf extends="runtime,optional" name="runtime-internal" visibility="public" description=""/>
+  </configurations>
+  <publications>
+    <artifact e:classifier="sources" name="scala3-interfaces" type="src" ext="jar" conf="sources"/>
+    <artifact e:classifier="javadoc" name="scala3-interfaces" type="doc" ext="jar" conf="docs"/>
+    <artifact name="scala3-interfaces" type="jar" ext="jar" conf="compile"/>
+    <artifact name="scala3-interfaces" type="pom" ext="pom" conf="pom"/>
+  </publications>
+  <dependencies>
+    <dependency org="com.novocode" name="junit-interface" rev="0.11" conf="test->default(compile)"> </dependency>
+  </dependencies>
+</ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-library_3.0.0-M2/3.0.0-M2/dummy.jar b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-library_3.0.0-M2/3.0.0-M2/dummy.jar
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-library_3.0.0-M2/3.0.0-M2/ivy.xml b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-library_3.0.0-M2/3.0.0-M2/ivy.xml
new file mode 100644
index 000000000..593d39bb4
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/scala3-library_3.0.0-M2/3.0.0-M2/ivy.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
+  <info organisation="org.other" module="scala3-library_3.0.0-M2" revision="3.0.0-M2" status="integration" publication="20201021102715">
+    <description homepage="https://github.com/lampepfl/dotty">scala3-library-bootstrapped</description>
+  </info>
+  <configurations>
+    <conf name="plugin" visibility="public" description=""/>
+    <conf name="pom" visibility="public" description=""/>
+    <conf extends="runtime" name="test" visibility="public" description=""/>
+    <conf name="provided" visibility="public" description=""/>
+    <conf extends="compile,optional,provided" name="compile-internal" visibility="public" description=""/>
+    <conf name="docs" visibility="public" description=""/>
+    <conf name="optional" visibility="public" description=""/>
+    <conf name="compile" visibility="public" description=""/>
+    <conf extends="test,optional,provided" name="test-internal" visibility="public" description=""/>
+    <conf name="sources" visibility="public" description=""/>
+    <conf extends="compile" name="runtime" visibility="public" description=""/>
+    <conf extends="runtime,optional" name="runtime-internal" visibility="public" description=""/>
+  </configurations>
+  <publications>
+    <artifact name="scala3-library_3.0.0-M2" type="pom" ext="pom" conf="pom"/>
+    <artifact e:classifier="sources" name="scala3-library_3.0.0-M2" type="src" ext="jar" conf="sources"/>
+    <artifact e:classifier="javadoc" name="scala3-library_3.0.0-M2" type="doc" ext="jar" conf="docs"/>
+    <artifact name="scala3-library_3.0.0-M2" type="jar" ext="jar" conf="compile"/>
+  </publications>
+  <dependencies>
+    <dependency org="com.novocode" name="junit-interface" rev="0.11" conf="test->default(compile)"> </dependency>
+    <dependency org="org.other" name="scala-library" rev="2.13.4" conf="compile->default(compile)"> </dependency>
+  </dependencies>
+</ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/tasty-core_3.0.0-M2/3.0.0-M2/dummy.jar b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/tasty-core_3.0.0-M2/3.0.0-M2/dummy.jar
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/tasty-core_3.0.0-M2/3.0.0-M2/ivy.xml b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/tasty-core_3.0.0-M2/3.0.0-M2/ivy.xml
new file mode 100644
index 000000000..5716a9b6e
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/repo/org.other/tasty-core_3.0.0-M2/3.0.0-M2/ivy.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ivy-module version="2.0" xmlns:e="http://ant.apache.org/ivy/extra">
+  <info organisation="org.other" module="tasty-core_3.0.0-M2" revision="3.0.0-M2" status="integration" publication="20201021102716">
+    <description homepage="https://github.com/lampepfl/dotty">tasty-core-bootstrapped</description>
+  </info>
+  <configurations>
+    <conf name="plugin" visibility="public" description=""/>
+    <conf name="pom" visibility="public" description=""/>
+    <conf extends="runtime" name="test" visibility="public" description=""/>
+    <conf name="provided" visibility="public" description=""/>
+    <conf extends="compile,optional,provided" name="compile-internal" visibility="public" description=""/>
+    <conf name="docs" visibility="public" description=""/>
+    <conf name="optional" visibility="public" description=""/>
+    <conf name="compile" visibility="public" description=""/>
+    <conf extends="test,optional,provided" name="test-internal" visibility="public" description=""/>
+    <conf name="sources" visibility="public" description=""/>
+    <conf extends="compile" name="runtime" visibility="public" description=""/>
+    <conf extends="runtime,optional" name="runtime-internal" visibility="public" description=""/>
+  </configurations>
+  <publications>
+    <artifact name="tasty-core_3.0.0-M2" type="pom" ext="pom" conf="pom"/>
+    <artifact e:classifier="sources" name="tasty-core_3.0.0-M2" type="src" ext="jar" conf="sources"/>
+    <artifact e:classifier="javadoc" name="tasty-core_3.0.0-M2" type="doc" ext="jar" conf="docs"/>
+    <artifact name="tasty-core_3.0.0-M2" type="jar" ext="jar" conf="compile"/>
+  </publications>
+  <dependencies>
+    <dependency org="org.other" name="scala3-library_3.0.0-M2" rev="3.0.0-M2" conf="compile->default(compile)"> </dependency>
+    <dependency org="com.novocode" name="junit-interface" rev="0.11" conf="test->default(compile)"> </dependency>
+  </dependencies>
+</ivy-module>
diff --git a/sbt/src/sbt-test/dependency-management/scala3-scala-organization/test b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/test
new file mode 100644
index 000000000..6e1b1a750
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/scala3-scala-organization/test
@@ -0,0 +1,3 @@
+# this test is pending because the IvyDependencyResolution is not yet able
+# to override the Scala 3 artifacts
+> checkDependencies
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/build.sbt b/sbt/src/sbt-test/dependency-management/snapshot-local/build.sbt
new file mode 100644
index 000000000..6d5248abf
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/snapshot-local/build.sbt
@@ -0,0 +1,39 @@
+ThisBuild / organization := "com.example"
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
+def customIvyPaths: Seq[Def.Setting[_]] = Seq(
+  ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some((baseDirectory in ThisBuild).value / "ivy-cache"))
+)
+
+lazy val sharedResolver: Resolver = {
+  val r = Resolver.defaultShared
+  r withConfiguration (r.configuration withIsLocal false)
+  //MavenRepository("example-shared-repo", "file:///tmp/shared-maven-repo-bad-example")
+  //Resolver.file("example-shared-repo", repoDir)(Resolver.defaultPatterns)
+}
+
+lazy val common = project
+  .settings(customIvyPaths)
+  .settings(
+    organization := "com.badexample",
+    name := "badexample",
+    version := "1.0-SNAPSHOT",
+    publishTo := Some(sharedResolver),
+    crossVersion := Disabled(),
+    publishMavenStyle := (sharedResolver match {
+      case repo: PatternsBasedRepository => repo.patterns.isMavenCompatible
+      case _: RawRepository => false // TODO - look deeper
+      case _: MavenRepository => true
+      case _ => false  // TODO - Handle chain repository?
+    })
+  )
+
+lazy val dependent = project
+  .settings(customIvyPaths)
+  .settings(
+    // Ignore the inter-project resolver, so we force to look remotely.
+    resolvers += sharedResolver,
+    fullResolvers := fullResolvers.value.filterNot(_==projectResolver.value),
+    libraryDependencies += "com.badexample" % "badexample" % "1.0-SNAPSHOT"
+  )
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/changes/BadCommon.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/BadCommon.scala
new file mode 100644
index 000000000..4df4235d5
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/BadCommon.scala
@@ -0,0 +1,2 @@
+object Common {
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/changes/GoodCommon.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/GoodCommon.scala
new file mode 100644
index 000000000..3f9b39258
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/GoodCommon.scala
@@ -0,0 +1,3 @@
+object Common {
+  def name = "common"
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/common/src/main/scala/Common.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/common/src/main/scala/Common.scala
new file mode 100644
index 000000000..d6175ce12
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/snapshot-local/common/src/main/scala/Common.scala
@@ -0,0 +1,3 @@
+object Common {
+
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/dependent/src/main/scala/User.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/dependent/src/main/scala/User.scala
new file mode 100644
index 000000000..8bc6103c8
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/snapshot-local/dependent/src/main/scala/User.scala
@@ -0,0 +1,3 @@
+object User {
+  println(Common.name)
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/test b/sbt/src/sbt-test/dependency-management/snapshot-local/test
new file mode 100644
index 000000000..9fa3d37ba
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/snapshot-local/test
@@ -0,0 +1,21 @@
+# Ivy is able to check for SNAPSHOT across different resolvers
+# Coursier seems to be sticky about the resolver within the TTL
+
+> show dependent/fullResolvers
+
+# Validate that a bad dependency fails the compile
+$ copy-file changes/BadCommon.scala common/src/main/scala/Common.scala
+> common/publishLocal
+
+# Force dep resolution to be successful, then compilation to fail
+> dependent/update
+-> dependent/compile
+
+# Push new good change to the same repository.
+$ copy-file changes/GoodCommon.scala common/src/main/scala/Common.scala
+$ sleep 1000
+> common/publishLocal
+
+# This should compile now because Coursier checks for local update
+> show dependent/update
+> dependent/compile
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt b/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt
index 03c6e79ec..862e728fc 100644
--- a/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt
@@ -1,33 +1,41 @@
+ThisBuild / organization := "com.example"
+ThisBuild / scalaVersion := "2.12.12"
+
+// TTL is 24h so we can't detect the change
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 def customIvyPaths: Seq[Def.Setting[_]] = Seq(
-  ivyPaths := new IvyPaths((baseDirectory in ThisBuild).value, Some((baseDirectory in ThisBuild).value / "ivy-cache"))
+  ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some((baseDirectory in ThisBuild).value / "ivy-cache"))
 )
 
-lazy val sharedResolver: Resolver =
-  Resolver.defaultShared.nonlocal()
+lazy val sharedResolver: Resolver = {
+  val r = Resolver.defaultShared
+  r withConfiguration (r.configuration withIsLocal false)
   //MavenRepository("example-shared-repo", "file:///tmp/shared-maven-repo-bad-example")
   //Resolver.file("example-shared-repo", repoDir)(Resolver.defaultPatterns)
+}
 
-lazy val common = project.
-  settings(customIvyPaths: _*).
-  settings(
+lazy val common = project
+  .settings(customIvyPaths)
+  .settings(
     organization := "com.badexample",
     name := "badexample",
     version := "1.0-SNAPSHOT",
     publishTo := Some(sharedResolver),
-    crossVersion := CrossVersion.Disabled,
+    crossVersion := Disabled(),
     publishMavenStyle := (sharedResolver match {
       case repo: PatternsBasedRepository => repo.patterns.isMavenCompatible
       case _: RawRepository => false // TODO - look deeper
       case _: MavenRepository => true
-      case _: MavenCache => true
       case _ => false  // TODO - Handle chain repository?
     })
     // updateOptions := updateOptions.value.withLatestSnapshots(true)
   )
 
-lazy val dependent = project.
-  settings(customIvyPaths: _*).
-  settings(
+lazy val dependent = project
+  .settings(customIvyPaths)
+  .settings(
     // Uncomment the following to test the before/after
     // updateOptions := updateOptions.value.withLatestSnapshots(false),
     // Ignore the inter-project resolver, so we force to look remotely.
@@ -39,8 +47,9 @@ lazy val dependent = project.
   )
 
 TaskKey[Unit]("dumpResolvers") := {
-  streams.value.log.info(s" -- dependent/fullResolvers -- ")
+  val log = streams.value.log
+  log.info(s" -- dependent/fullResolvers -- ")
   (fullResolvers in dependent).value foreach { r =>
-    streams.value.log.info(s" * ${r}")
+    log.info(s" * ${r}")
   }
 }
diff --git a/sbt/src/sbt-test/dependency-management/snapshot-resolution/test b/sbt/src/sbt-test/dependency-management/snapshot-resolution/test
index 85317974a..a9ee210fb 100644
--- a/sbt/src/sbt-test/dependency-management/snapshot-resolution/test
+++ b/sbt/src/sbt-test/dependency-management/snapshot-resolution/test
@@ -1,5 +1,6 @@
 # Validate that a bad dependency fails the compile
 $ copy-file changes/BadCommon.scala common/src/main/scala/Common.scala
+> common/compile
 > common/publish
 
 # Force dep resolution to be successful, then compilation to fail
@@ -16,7 +17,9 @@ $ sleep 1000
 > dependent/update
 > dependent/compile
 
-# Now let's try this on the opposite order: pubishLocal => publish
+
+
+# Now let's try this on the opposite order: publishLocal => publish
 $ copy-file changes/BadCommon.scala common/src/main/scala/Common.scala
 > common/publishLocal
 
diff --git a/sbt/src/sbt-test/dependency-management/sources-transitive-classifiers/build.sbt b/sbt/src/sbt-test/dependency-management/sources-transitive-classifiers/build.sbt
new file mode 100644
index 000000000..91f35d197
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/sources-transitive-classifiers/build.sbt
@@ -0,0 +1,31 @@
+ThisBuild / useCoursier := false
+
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += "net.liftweb" % "lift-webkit" % "1.0" intransitive(),
+    libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5" intransitive(),
+    autoScalaLibrary := false,
+    managedScalaInstance := false,
+    transitiveClassifiers := Seq("sources"),
+    TaskKey[Unit]("checkSources") := (updateClassifiers map checkSources).value,
+    TaskKey[Unit]("checkBinaries") := (update map checkBinaries).value
+  )
+
+def getSources(report: UpdateReport)  = report.matching(artifactFilter(`classifier` = "sources") )
+def checkSources(report: UpdateReport): Unit =
+  {
+    val srcs = getSources(report)
+    if(srcs.isEmpty)
+      sys.error(s"No sources retrieved\n\n$report")
+    else if(srcs.size != 2)
+      sys.error("Incorrect sources retrieved:\n\t" + srcs.mkString("\n\t"))
+    else
+      ()
+  }
+
+def checkBinaries(report: UpdateReport): Unit =
+  {
+    val srcs = getSources(report)
+    if(srcs.nonEmpty) sys.error("Sources retrieved:\n\t" + srcs.mkString("\n\t"))
+    else ()
+  }
diff --git a/sbt/src/sbt-test/dependency-management/sources-transitive-classifiers/test b/sbt/src/sbt-test/dependency-management/sources-transitive-classifiers/test
new file mode 100644
index 000000000..ca9281f91
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/sources-transitive-classifiers/test
@@ -0,0 +1,3 @@
+> checkBinaries
+> show updateClassifiers
+> checkSources
diff --git a/sbt/src/sbt-test/dependency-management/sources/build.sbt b/sbt/src/sbt-test/dependency-management/sources/build.sbt
index 5fa6d7405..64f5ba3f3 100644
--- a/sbt/src/sbt-test/dependency-management/sources/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/sources/build.sbt
@@ -1,31 +1,33 @@
-import sbt.internal.librarymanagement.syntax._
+ThisBuild / scalaVersion := "2.12.12"
 
-lazy val root = (project in file(".")).
-  settings(
-    libraryDependencies += "net.liftweb" % "lift-webkit" % "1.0" intransitive(),
-    libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5" intransitive(),
-    autoScalaLibrary := false,
-    managedScalaInstance := false,
-    transitiveClassifiers := Seq("sources"),
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.5.22",
     TaskKey[Unit]("checkSources") := (updateClassifiers map checkSources).value,
     TaskKey[Unit]("checkBinaries") := (update map checkBinaries).value
   )
 
 def getSources(report: UpdateReport)  = report.matching(artifactFilter(`classifier` = "sources") )
-def checkSources(report: UpdateReport): Unit =
-{
-  val srcs = getSources(report)
+def checkSources(report: UpdateReport): Unit = {
+  val srcs = getSources(report).map(_.getName)
   if(srcs.isEmpty)
-    sys.error("No sources retrieved")
-  else if(srcs.size != 2)
+    sys.error(s"No sources retrieved\n\n$report")
+  else if (srcs.size != 9 || !srcs.exists(_ == "akka-actor_2.12-2.5.22-sources.jar")) {
+// [info] [error] 	scala-java8-compat_2.12-0.8.0-sources.jar
+// [info] [error] 	scala-library-2.12.12-sources.jar
+// [info] [error] 	config-1.3.3-sources.jar
+// [info] [error] 	akka-actor_2.12-2.5.22-sources.jar
+// [info] [error] 	scala-compiler-2.12.12-sources.jar
+// [info] [error] 	jline-2.14.6-sources.jar
+// [info] [error] 	jansi-1.12-sources.jar
+// [info] [error] 	scala-xml_2.12-1.0.6-sources.jar
+// [info] [error] 	scala-reflect-2.12.12-sources.jar
     sys.error("Incorrect sources retrieved:\n\t" + srcs.mkString("\n\t"))
-  else
-    ()
+  } else ()
 }
 
-def checkBinaries(report: UpdateReport): Unit =
-  {
-    val srcs = getSources(report)
-    if(srcs.nonEmpty) sys.error("Sources retrieved:\n\t" + srcs.mkString("\n\t"))
-    else ()
-  }
+def checkBinaries(report: UpdateReport): Unit = {
+  val srcs = getSources(report)
+  if(srcs.nonEmpty) sys.error("Sources retrieved:\n\t" + srcs.mkString("\n\t"))
+  else ()
+}
diff --git a/sbt/src/sbt-test/dependency-management/t468/build.sbt b/sbt/src/sbt-test/dependency-management/t468/build.sbt
index ab4051a0c..bec54f66b 100644
--- a/sbt/src/sbt-test/dependency-management/t468/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/t468/build.sbt
@@ -1,6 +1,8 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 autoScalaLibrary := false
 
-ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value
+ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
 
 libraryDependencies ++= Seq(
 	"org.sat4j" % "org.sat4j.pb" % "2.3.1",
@@ -12,7 +14,7 @@ TaskKey[Unit]("checkUpdate") := {
 	val mods = report.configuration(Compile.name).get.allModules.map(_.name).toSet
 	val expected = Set("org.sat4j.pb", "org.sat4j.core")
 	if(mods != expected)
-		error("Expected modules " + expected  + ", got: " + mods)
+		sys.error("Expected modules " + expected  + ", got: " + mods)
 }
 
 TaskKey[Unit]("checkClasspath") := (dependencyClasspath in Compile map { cp =>
@@ -20,5 +22,5 @@ TaskKey[Unit]("checkClasspath") := (dependencyClasspath in Compile map { cp =>
 	// Note: pb depends on tests artifact in core for no good reason.  Previously this was not correctly added to the classpath.
 	val expected = Set("org.sat4j.pb-2.3.1.jar", "org.sat4j.core-2.3.1.jar", "org.sat4j.core-2.3.1-tests.jar")
 	if(jars != expected)
-		error("Expected jars " + expected  + ", got: " + jars)
+		sys.error("Expected jars " + expected  + ", got: " + jars)
 }).value
diff --git a/sbt/src/sbt-test/dependency-management/t468/pending b/sbt/src/sbt-test/dependency-management/t468/disabled
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/t468/pending
rename to sbt/src/sbt-test/dependency-management/t468/disabled
diff --git a/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt b/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt
index 2d6e4d174..312d66e8d 100644
--- a/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt
+++ b/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt
@@ -1,10 +1,11 @@
+ThisBuild / useCoursier := false
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 ivyPaths := {
 	val base = baseDirectory.value
-	new IvyPaths(base, Some(base / "ivy-cache"))
+	IvyPaths(base, Some(base / "ivy-cache"))
 }
 
 managedScalaInstance := false
-
 autoScalaLibrary := false
-
 crossPaths := false
diff --git a/sbt/src/sbt-test/dependency-management/transitive-excludes/build.sbt b/sbt/src/sbt-test/dependency-management/transitive-excludes/build.sbt
index 2776e4448..3bebeda6d 100644
--- a/sbt/src/sbt-test/dependency-management/transitive-excludes/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/transitive-excludes/build.sbt
@@ -6,7 +6,7 @@ resolvers += {
 }
 libraryDependencies += "exclude.test" % "app" % "1.0.0"
 
-val checkDependencies = taskKey[Unit]("Checks that dependcies are correct.")
+val checkDependencies = taskKey[Unit]("Checks that dependencies are correct.")
 
 checkDependencies := {
   val hasBadJar = (fullClasspath in Compile).value.exists { jar => jar.data.getName contains "bottom-1.0.0.jar"}
diff --git a/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt b/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt
index 0f8c84c1e..6e3467d19 100644
--- a/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt
@@ -1,5 +1,6 @@
+ThisBuild / scalaVersion := "2.11.12"
+
 organization := "com.test"
 name := "maven-version-range-bug"
 version := "1.0.0-SNAPSHOT"
-scalaVersion := "2.11.6"
-libraryDependencies += "com.amazonaws" % "aws-java-sdk" % "1.7.8.1"
\ No newline at end of file
+libraryDependencies += "com.amazonaws" % "aws-java-sdk" % "1.7.8.1"
diff --git a/sbt/src/sbt-test/dependency-management/update-sbt-classifiers/build.sbt b/sbt/src/sbt-test/dependency-management/update-sbt-classifiers/build.sbt
new file mode 100644
index 000000000..4593d4710
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/update-sbt-classifiers/build.sbt
@@ -0,0 +1,12 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+ivyConfiguration := {
+  throw new RuntimeException("updateSbtClassifiers should use updateSbtClassifiers / ivyConfiguration")
+}
+
+dependencyResolution := {
+  throw new RuntimeException("updateSbtClassifiers should use updateSbtClassifiers / dependencyResolution")
+}
+
+scalaOrganization := "doesnt.exist"
+
diff --git a/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt b/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt
new file mode 100644
index 000000000..9fdc2681d
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt
@@ -0,0 +1,3 @@
+ThisBuild / scalaVersion := "2.11.12"
+
+libraryDependencies += "ccl.northwestern.edu" % "netlogo" % "5.3.1" % "provided" from s"https://github.com/NetLogo/NetLogo/releases/download/5.3.1/NetLogo.jar"
diff --git a/sbt/src/sbt-test/dependency-management/url-no-head/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/url-no-head/src/main/scala/Main.scala
new file mode 100644
index 000000000..d75f66eaf
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/url-no-head/src/main/scala/Main.scala
@@ -0,0 +1,11 @@
+import java.io.File
+import java.nio.file.Files
+
+object Main extends App {
+  // Not using directly the NetLogo 5.x lib, which seems to depend on Scala 2.9
+  // Can't find a way to check that NetLogo.jar is in the classpath
+  // These don't work, even with fork := true:
+  // assert(Thread.currentThread.getContextClassLoader.getResource("org/nlogo/nvm/Task.class") != null)
+  // Thread.currentThread.getContextClassLoader.getResource("org/nlogo/nvm/Task.class")
+  Files.write(new File("output").toPath, "OK".getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/dependency-management/url-no-head/test b/sbt/src/sbt-test/dependency-management/url-no-head/test
new file mode 100644
index 000000000..2182f57b0
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/url-no-head/test
@@ -0,0 +1,3 @@
+$ delete output
+> run
+$ exists output
diff --git a/sbt/src/sbt-test/dependency-management/url/build.sbt b/sbt/src/sbt-test/dependency-management/url/build.sbt
index 14273cc1b..54ae274cf 100644
--- a/sbt/src/sbt-test/dependency-management/url/build.sbt
+++ b/sbt/src/sbt-test/dependency-management/url/build.sbt
@@ -1,9 +1,11 @@
 import sbt.internal.inc.classpath.ClasspathUtilities
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val root = (project in file(".")).
   settings(
-    ivyPaths := (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value,
-    libraryDependencies += "org.jsoup" % "jsoup" % "1.9.1" % Test from "http://jsoup.org/packages/jsoup-1.9.1.jar",
+    ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
+    libraryDependencies += "org.jsoup" % "jsoup" % "1.9.1" % Test from "https://jsoup.org/packages/jsoup-1.9.1.jar",
     ivyLoggingLevel := UpdateLogging.Full,
     TaskKey[Unit]("checkInTest") := checkClasspath(Test).value,
     TaskKey[Unit]("checkInCompile") := checkClasspath(Compile).value
@@ -11,14 +13,12 @@ lazy val root = (project in file(".")).
 
 def checkClasspath(conf: Configuration) =
   fullClasspath in conf map { cp =>
-    try
-    {
+    try {
       val loader = ClasspathUtilities.toLoader(cp.files)
       Class.forName("org.jsoup.Jsoup", false, loader)
       ()
     }
-    catch
-    {
-      case _: ClassNotFoundException => sys.error("Dependency not downloaded.")
+    catch {
+      case _: ClassNotFoundException => sys.error(s"could not instantiate org.jsoup.Jsoup: ${cp.files}")
     }
   }
diff --git a/sbt/src/sbt-test/dependency-management/url/pending b/sbt/src/sbt-test/dependency-management/url/test
similarity index 100%
rename from sbt/src/sbt-test/dependency-management/url/pending
rename to sbt/src/sbt-test/dependency-management/url/test
diff --git a/sbt/src/sbt-test/dependency-management/version-interval/build.sbt b/sbt/src/sbt-test/dependency-management/version-interval/build.sbt
new file mode 100644
index 000000000..efeaf236e
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/version-interval/build.sbt
@@ -0,0 +1,35 @@
+
+libraryDependencies += "org.json4s" %% "json4s-native" % "[3.3.0,3.5.0)"
+
+
+lazy val actualVersionCheck = taskKey[Unit]("")
+
+actualVersionCheck := {
+
+  val log = streams.value.log
+
+  val configReport = update.value
+    .configuration(Compile)
+    .getOrElse {
+      sys.error("compile configuration not found in update report")
+    }
+
+  val modules = configReport
+    .modules
+    .map(_.module)
+
+  assert(modules.nonEmpty)
+  assert(modules.exists(_.name.startsWith("json4s-native")))
+
+  val wrongModules = modules.filter { m =>
+    val v = m.revision
+    v.contains("[") || v.contains("]") || v.contains("(") || v.contains(")")
+  }
+
+  if (wrongModules.nonEmpty) {
+    log.error("Found unexpected intervals in revisions")
+    for (m <- wrongModules)
+      log.error(s"  ${m.organization}:${m.name}:${m.revision}")
+    sys.error("Found intervals in revisions")
+  }
+}
diff --git a/sbt/src/sbt-test/dependency-management/version-interval/test b/sbt/src/sbt-test/dependency-management/version-interval/test
new file mode 100644
index 000000000..99803d595
--- /dev/null
+++ b/sbt/src/sbt-test/dependency-management/version-interval/test
@@ -0,0 +1 @@
+> actualVersionCheck
diff --git a/sbt/src/sbt-test/ivy-deps-management/update-classifiers-snapshot-srcs/build.sbt b/sbt/src/sbt-test/ivy-deps-management/update-classifiers-snapshot-srcs/build.sbt
index 06932eb7e..64ad6b758 100644
--- a/sbt/src/sbt-test/ivy-deps-management/update-classifiers-snapshot-srcs/build.sbt
+++ b/sbt/src/sbt-test/ivy-deps-management/update-classifiers-snapshot-srcs/build.sbt
@@ -1,11 +1,13 @@
 def ivyHome = Def.setting((target in LocalRootProject).value / "ivy")
 def localRepo = Def.setting((target in LocalRootProject).value / "local-repo")
 
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 val commonSettings = Seq[Def.Setting[_]](
   organization := "org.example",
   version := "1.0-SNAPSHOT",
   scalaVersion := "2.11.7",
-  ivyPaths := new IvyPaths((baseDirectory in ThisBuild).value, Some(ivyHome.value)),
+  ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some(ivyHome.value)),
   fullResolvers := fullResolvers.value.filterNot(_ == projectResolver.value)
 )
 
diff --git a/sbt/src/sbt-test/java/argfile/build.sbt b/sbt/src/sbt-test/java/argfile/build.sbt
index 5ce2c66e1..399821afc 100644
--- a/sbt/src/sbt-test/java/argfile/build.sbt
+++ b/sbt/src/sbt-test/java/argfile/build.sbt
@@ -1,11 +1,12 @@
-scalaSource in Configurations.Compile := sourceDirectory( _ / " scala test " ).value
+scalaSource in Configurations.Compile := (sourceDirectory.value / " scala test ")
+ javaSource in Configurations.Compile := (sourceDirectory.value / " java test ")
 
-javaSource in Configurations.Compile := sourceDirectory( _ / " java test " ).value
-
-TaskKey[Unit]("init") := ((scalaSource in Configurations.Compile, javaSource in Configurations.Compile) map { (ss, js) =>
-	import IO._
-	createDirectories(ss :: js :: Nil)
-	copyFile(file("changes") / "Test.scala", ss / " Test s.scala")
-	copyFile(file("changes") / "A.java", js / "a" / "A.java")
-	delete(file("changes"))
-}).value
+TaskKey[Unit]("init") := {
+  val ss = (scalaSource in Configurations.Compile).value
+  val js = ( javaSource in Configurations.Compile).value
+  import IO._
+  createDirectories(ss :: js :: Nil)
+  copyFile(file("changes") / "Test.scala", ss / " Test s.scala")
+  copyFile(file("changes") / "A.java", js / "a" / "A.java")
+  delete(file("changes"))
+}
diff --git a/sbt/src/sbt-test/java/cross/A.scala b/sbt/src/sbt-test/java/cross/A.scala
new file mode 100644
index 000000000..e9ff1f72a
--- /dev/null
+++ b/sbt/src/sbt-test/java/cross/A.scala
@@ -0,0 +1,16 @@
+package pkg
+
+import java.nio.file.{ Paths, Files }
+import java.nio.charset.Charset
+
+object A extends App {
+  val out = Paths.get("out.txt")
+  val content = sys.props("java.version")
+  val w = Files.newBufferedWriter(out, Charset.forName("UTF-8"))
+  try {
+    w.write(content)
+    w.flush()
+  } finally {
+    w.close
+  }
+}
diff --git a/sbt/src/sbt-test/java/cross/build.sbt b/sbt/src/sbt-test/java/cross/build.sbt
new file mode 100644
index 000000000..c71bd179e
--- /dev/null
+++ b/sbt/src/sbt-test/java/cross/build.sbt
@@ -0,0 +1,25 @@
+import complete.DefaultParsers._
+
+val check = inputKey[Unit]("Runs the check")
+
+lazy val root = (project in file("."))
+  .settings(
+    ThisBuild / scalaVersion := "2.12.6",
+    crossJavaVersions := List("1.8"),
+
+    // read out.txt and see if it starts with the passed in number
+    check := {
+      val arg1: Int = (Space ~> NatBasic).parsed
+      file("out.txt") match {
+        case out if out.exists =>
+          IO.readLines(out).headOption match {
+            case Some(v) if v startsWith arg1.toString => ()
+            case Some(v) if v startsWith s"1.$arg1"    => ()
+            case x => sys.error(s"unexpected value: $x")
+          }
+        case out => sys.error(s"$out doesn't exist")
+      }
+    },
+
+    Compile / run / fork := true,
+  )
diff --git a/sbt/src/sbt-test/java/cross/changes/build.sbt b/sbt/src/sbt-test/java/cross/changes/build.sbt
new file mode 100644
index 000000000..245745912
--- /dev/null
+++ b/sbt/src/sbt-test/java/cross/changes/build.sbt
@@ -0,0 +1,25 @@
+import complete.DefaultParsers._
+
+val check = inputKey[Unit]("Runs the check")
+
+lazy val root = (project in file("."))
+  .settings(
+    ThisBuild / scalaVersion := "2.12.6",
+    crossJavaVersions := List("1.8", "10"),
+
+    // read out.txt and see if it starts with the passed in number
+    check := {
+      val arg1: Int = (Space ~> NatBasic).parsed
+      file("out.txt") match {
+        case out if out.exists =>
+          IO.readLines(out).headOption match {
+            case Some(v) if v startsWith arg1.toString => ()
+            case Some(v) if v startsWith s"1.$arg1"    => ()
+            case x => sys.error(s"unexpected value: $x")
+          }
+        case out => sys.error(s"$out doesn't exist")
+      }
+    },
+
+    Compile / run / fork := true,
+  )
diff --git a/sbt/src/sbt-test/java/cross/disabled b/sbt/src/sbt-test/java/cross/disabled
new file mode 100644
index 000000000..9a30d25fb
--- /dev/null
+++ b/sbt/src/sbt-test/java/cross/disabled
@@ -0,0 +1,15 @@
+> java+ run
+> check 8
+
+> java++ 10!
+> run
+> check 10
+
+# test safe switching
+$ copy-file changes/build.sbt build.sbt
+$ delete out.txt
+> reload
+> clean
+> java++ 10
+> run
+> check 10
diff --git a/sbt/src/sbt-test/java/home-discovery/build.sbt b/sbt/src/sbt-test/java/home-discovery/build.sbt
new file mode 100644
index 000000000..7177ca692
--- /dev/null
+++ b/sbt/src/sbt-test/java/home-discovery/build.sbt
@@ -0,0 +1,5 @@
+Global / javaHomes += "6" -> file("/good/old/times/java-6")
+
+TaskKey[Unit]("check") := {
+  assert(fullJavaHomes.value("1.6").getAbsolutePath.contains("java-6"))
+}
diff --git a/sbt/src/sbt-test/java/home-discovery/test b/sbt/src/sbt-test/java/home-discovery/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/java/home-discovery/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/java/track-anonymous/build.sbt b/sbt/src/sbt-test/java/track-anonymous/build.sbt
index edcc050ff..b0c61b63f 100644
--- a/sbt/src/sbt-test/java/track-anonymous/build.sbt
+++ b/sbt/src/sbt-test/java/track-anonymous/build.sbt
@@ -5,9 +5,9 @@
 		val shouldExist = parser.parsed
 		val dir = (classDirectory in Compile).value
 		if((dir / "Anon.class").exists != shouldExist)
-			error("Top level class incorrect" )
+			sys.error("Top level class incorrect" )
 		else if( (dir / "Anon$1.class").exists != shouldExist)
-			error("Inner class incorrect" )
+			sys.error("Inner class incorrect" )
 		else
 			()
 	}
diff --git a/sbt/src/sbt-test/nio/clean-symlinks/build.sbt b/sbt/src/sbt-test/nio/clean-symlinks/build.sbt
new file mode 100644
index 000000000..b7ad34a81
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean-symlinks/build.sbt
@@ -0,0 +1,5 @@
+import java.nio.file.Files
+
+TaskKey[Unit]("createSymlinkedDirectory") := {
+  Files.createSymbolicLink(target.value.toPath / "foo", baseDirectory.value.toPath / "foo")
+}
diff --git a/sbt/src/sbt-test/nio/clean-symlinks/foo/bar b/sbt/src/sbt-test/nio/clean-symlinks/foo/bar
new file mode 100644
index 000000000..5716ca598
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean-symlinks/foo/bar
@@ -0,0 +1 @@
+bar
diff --git a/sbt/src/sbt-test/nio/clean-symlinks/test b/sbt/src/sbt-test/nio/clean-symlinks/test
new file mode 100644
index 000000000..48dfcb255
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean-symlinks/test
@@ -0,0 +1,9 @@
+> createSymlinkedDirectory
+
+$ exists target/foo/bar
+$ exists foo/bar
+
+> clean
+
+$ absent target/foo
+$ exists foo/bar
diff --git a/sbt/src/sbt-test/nio/clean/base/Foo.txt b/sbt/src/sbt-test/nio/clean/base/Foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean/base/Foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/clean/build.sbt b/sbt/src/sbt-test/nio/clean/build.sbt
new file mode 100644
index 000000000..97931d27b
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean/build.sbt
@@ -0,0 +1,50 @@
+import java.nio.file.Path
+
+import sjsonnew.BasicJsonProtocol._
+
+val copyFile = taskKey[Int]("dummy task")
+copyFile / target := target.value / "out"
+copyFile / fileInputs += baseDirectory.value.toGlob / "base" / "*.txt"
+copyFile / fileOutputs += (copyFile / target).value.toGlob / "*.txt"
+
+copyFile := Def.task {
+  val prev = copyFile.previous
+  val changes: Option[Seq[Path]] = copyFile.inputFileChanges match {
+    case fc @ FileChanges(c, _, u, _) if fc.hasChanges => Some(c ++ u)
+    case _ => None
+  }
+  prev match {
+    case Some(v: Int) if changes.isEmpty => v
+    case _ =>
+      changes.getOrElse(copyFile.inputFiles).foreach { p =>
+        val outDir = (copyFile / target).value
+        IO.createDirectory(outDir)
+        IO.copyFile(p.toFile, outDir / p.getFileName.toString)
+      }
+      prev.map(_ + 1).getOrElse(1)
+  }
+}.value
+
+val checkOutDirectoryIsEmpty = taskKey[Unit]("validates that the output directory is empty")
+checkOutDirectoryIsEmpty := {
+  assert(fileTreeView.value.list((copyFile / target).value.toGlob / **).isEmpty)
+}
+
+val checkOutDirectoryHasFile = taskKey[Unit]("validates that the output directory is empty")
+checkOutDirectoryHasFile := {
+  val result = fileTreeView.value.list((copyFile / target).value.toGlob / **).map(_._1.toFile)
+  assert(result == Seq((copyFile / target).value / "Foo.txt"))
+}
+
+commands += Command.single("checkCount") { (s, digits) =>
+  s"writeCount $digits" :: "checkCountImpl" :: s
+}
+
+val writeCount = inputKey[Unit]("writes the count to a file")
+writeCount := IO.write(baseDirectory.value / "expectedCount", Def.spaceDelimited().parsed.head)
+val checkCountImpl = taskKey[Unit]("Check that the expected number of evaluations have run.")
+checkCountImpl := {
+  val expected = IO.read(baseDirectory.value / "expectedCount").toInt
+  val previous = copyFile.previous.getOrElse(0)
+  assert(previous == expected)
+}
diff --git a/sbt/src/sbt-test/nio/clean/changes/Foo.txt b/sbt/src/sbt-test/nio/clean/changes/Foo.txt
new file mode 100644
index 000000000..ba0e162e1
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean/changes/Foo.txt
@@ -0,0 +1 @@
+bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/clean/project/Count.scala b/sbt/src/sbt-test/nio/clean/project/Count.scala
new file mode 100644
index 000000000..264f7bb7d
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean/project/Count.scala
@@ -0,0 +1,3 @@
+object Count {
+  var value = 0
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/clean/test b/sbt/src/sbt-test/nio/clean/test
new file mode 100644
index 000000000..0d587dea6
--- /dev/null
+++ b/sbt/src/sbt-test/nio/clean/test
@@ -0,0 +1,59 @@
+> checkOutDirectoryIsEmpty
+
+> copyFile
+
+> checkOutDirectoryHasFile
+
+> checkCount 1
+
+> copyFile
+
+> checkOutDirectoryHasFile
+
+> checkCount 1
+
+> copyFile / clean
+
+> checkOutDirectoryIsEmpty
+
+> copyFile
+
+> checkOutDirectoryHasFile
+
+> checkCount 1
+
+$ copy-file changes/Foo.txt base/Foo.txt
+
+> copyFile
+
+> checkOutDirectoryHasFile
+
+> checkCount 2
+
+> clean
+
+> checkOutDirectoryIsEmpty
+
+> copyFile
+
+> checkOutDirectoryHasFile
+
+> checkCount 1
+
+> copyFile
+
+> checkOutDirectoryHasFile
+
+> checkCount 1
+
+> copyFile / clean
+
+> checkOutDirectoryIsEmpty
+
+> checkCount 0
+
+> copyFile / allOutputFiles
+
+> checkCount 1
+
+> checkOutDirectoryHasFile
diff --git a/sbt/src/sbt-test/nio/code-formatter/.scalafmt.conf b/sbt/src/sbt-test/nio/code-formatter/.scalafmt.conf
new file mode 100644
index 000000000..b836357eb
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/.scalafmt.conf
@@ -0,0 +1,21 @@
+version = 2.0.0
+maxColumn = 100
+project.git = true
+project.excludeFilters = [ "\\Wsbt-test\\W", "\\Winput_sources\\W", "\\Wcontraband-scala\\W" ]
+
+# https://docs.scala-lang.org/style/scaladoc.html recommends the JavaDoc style.
+# scala/scala is written that way too https://github.com/scala/scala/blob/v2.12.2/src/library/scala/Predef.scala
+docstrings = JavaDoc
+
+# This also seems more idiomatic to include whitespace in import x.{ yyy }
+spaces.inImportCurlyBraces = true
+
+# This is more idiomatic Scala.
+# https://docs.scala-lang.org/style/indentation.html#methods-with-numerous-arguments
+align.openParenCallSite = false
+align.openParenDefnSite = false
+
+# For better code clarity
+danglingParentheses = true
+
+trailingCommas = preserve
diff --git a/sbt/src/sbt-test/nio/code-formatter/build.sbt b/sbt/src/sbt-test/nio/code-formatter/build.sbt
new file mode 100644
index 000000000..47a4e61af
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/build.sbt
@@ -0,0 +1,41 @@
+import java.nio.file.Path
+import complete.DefaultParsers._
+
+enablePlugins(ScalafmtPlugin)
+
+val classFiles = taskKey[Seq[Path]]("The classfiles generated by compile")
+classFiles := {
+  val classes = (Compile / classDirectory).value.toGlob / ** / "*.class"
+  fileTreeView.value.list(classes).map(_._1)
+}
+classFiles := classFiles.dependsOn(Compile / compile).value
+
+val compileAndCheckNoClassFileUpdates = taskKey[Unit]("Checks that there are no class file updates")
+compileAndCheckNoClassFileUpdates := {
+  val current = (classFiles / outputFileStamps).value.toSet
+  val previous = (classFiles / outputFileStamps).previous.getOrElse(Nil).toSet
+  assert(current == previous, s"$current did not equal $previous")
+}
+
+val checkLastModified = inputKey[Unit]("Check the last modified time for a file")
+checkLastModified := {
+  (Space ~> OptSpace ~> matched(charClass(_ != ' ').+) ~ (Space ~> ('!'.? ~ Digit.+.map(
+    _.mkString.toLong
+  )))).parsed match {
+    case (file, (negate, expectedLastModified)) =>
+      val sourceFile = baseDirectory.value / "src" / "main" / "scala" / file
+      val lastModified = IO.getModifiedTimeOrZero(sourceFile)
+      println(s"$lastModified $expectedLastModified")
+      negate match {
+        case Some(_) => assert(lastModified != expectedLastModified)
+        case None    => assert(lastModified == expectedLastModified)
+      }
+  }
+}
+
+val setLastModified = inputKey[Unit]("Set the last modified time for a file")
+setLastModified := {
+  val Seq(file, lm) = Def.spaceDelimited().parsed
+  val sourceFile = baseDirectory.value / "src" / "main" / "scala" / file
+  IO.setModifiedTimeOrFalse(sourceFile, lm.toLong)
+}
diff --git a/sbt/src/sbt-test/nio/code-formatter/changes/Bar-bad.scala b/sbt/src/sbt-test/nio/code-formatter/changes/Bar-bad.scala
new file mode 100644
index 000000000..e2f68f8da
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/changes/Bar-bad.scala
@@ -0,0 +1 @@
+class Bar { val x = }
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/code-formatter/changes/Bar.scala b/sbt/src/sbt-test/nio/code-formatter/changes/Bar.scala
new file mode 100644
index 000000000..79cebe4c5
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/changes/Bar.scala
@@ -0,0 +1 @@
+class Bar {val x=2}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/code-formatter/changes/Foo.scala b/sbt/src/sbt-test/nio/code-formatter/changes/Foo.scala
new file mode 100644
index 000000000..7f57a6412
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/changes/Foo.scala
@@ -0,0 +1 @@
+class Foo{val x=1}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/code-formatter/project/build.sbt b/sbt/src/sbt-test/nio/code-formatter/project/build.sbt
new file mode 100644
index 000000000..f3566daa5
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/project/build.sbt
@@ -0,0 +1 @@
+libraryDependencies += "org.scalameta" %% "scalafmt-dynamic" % "2.0.0"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/code-formatter/project/src/main/scala/ScalafmtPlugin.scala b/sbt/src/sbt-test/nio/code-formatter/project/src/main/scala/ScalafmtPlugin.scala
new file mode 100644
index 000000000..c811b52fb
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/project/src/main/scala/ScalafmtPlugin.scala
@@ -0,0 +1,56 @@
+import java.io.PrintWriter
+import java.nio.file._
+import sbt._
+import sbt.Keys.{ baseDirectory, unmanagedSources }
+import sbt.nio.Keys.{ fileInputs, inputFileStamps, outputFileStamper, outputFileStamps }
+import sbt.nio.FileStamper
+import org.scalafmt.interfaces.{ Scalafmt, ScalafmtReporter }
+
+object ScalafmtPlugin extends AutoPlugin {
+  private val reporter = new ScalafmtReporter {
+    override def error(file: Path, message: String): Unit = throw new Exception(s"$file $message")
+    override def error(file: Path, e: Throwable): Unit = throw e
+    override def excluded(file: Path): Unit = {}
+    override def parsedConfig(config: Path, scalafmtVersion: String): Unit = {}
+    override def downloadWriter: PrintWriter = new PrintWriter(System.out, true)
+  }
+  private val formatter = Scalafmt.create(this.getClass.getClassLoader).withReporter(reporter)
+  object autoImport {
+    val scalafmtImpl = taskKey[Seq[Path]]("Format scala sources")
+    val scalafmt = taskKey[Unit]("Format scala sources and validate results")
+  }
+  import autoImport._
+  override lazy val projectSettings = super.projectSettings ++ Seq(
+    Compile / scalafmtImpl / fileInputs := (Compile / unmanagedSources / fileInputs).value,
+    Compile / scalafmtImpl / outputFileStamper := FileStamper.Hash,
+    Compile / scalafmtImpl := {
+      val config = baseDirectory.value.toPath / ".scalafmt.conf"
+      val allInputStamps = (Compile / scalafmtImpl / inputFileStamps).value
+      val previous =
+        (Compile / scalafmtImpl / outputFileStamps).previous.map(_.toMap).getOrElse(Map.empty)
+      allInputStamps.flatMap {
+        case (p, s) if previous.get(p).fold(false)(_ == s) => Some(p)
+        case (p, s) =>
+          try {
+            println(s"Formatting $p")
+            Files.write(p, formatter.format(config, p, new String(Files.readAllBytes(p))).getBytes)
+            Some(p)
+          } catch {
+            case e: Exception =>
+              println(e)
+              None
+          }
+      }
+    },
+    Compile / scalafmt := {
+      val outputs = (Compile / scalafmtImpl / outputFileStamps).value.toMap
+      val improperlyFormatted = (Compile / scalafmtImpl).inputFiles.filterNot(outputs.contains _)
+      if (improperlyFormatted.nonEmpty) {
+        val msg = s"There were improperly formatted files:\n${improperlyFormatted mkString "\n"}"
+        throw new IllegalStateException(msg)
+      }
+    },
+    Compile / unmanagedSources / inputFileStamps :=
+      (Compile / unmanagedSources / inputFileStamps).dependsOn(Compile / scalafmt).value
+  )
+}
diff --git a/sbt/src/sbt-test/nio/code-formatter/src/main/scala/Foo.scala b/sbt/src/sbt-test/nio/code-formatter/src/main/scala/Foo.scala
new file mode 100644
index 000000000..7f57a6412
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/src/main/scala/Foo.scala
@@ -0,0 +1 @@
+class Foo{val x=1}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/code-formatter/test b/sbt/src/sbt-test/nio/code-formatter/test
new file mode 100644
index 000000000..afe8e3194
--- /dev/null
+++ b/sbt/src/sbt-test/nio/code-formatter/test
@@ -0,0 +1,47 @@
+> setLastModified Foo.scala 12345678
+
+# The first time we run compile, we expect an updated class file for Foo.class
+-> compileAndCheckNoClassFileUpdates
+
+# scalafmt should modify Foo.scala
+> checkLastModified Foo.scala !12345678
+
+# The first time we run compile, there should be no updates since Foo.scala hasn't changed since
+# scalafmt modified it in the first run
+> compileAndCheckNoClassFileUpdates
+
+$ copy-file changes/Foo.scala src/main/scala/Foo.scala
+
+$ copy-file changes/Bar-bad.scala src/main/scala/Bar.scala
+
+> setLastModified Foo.scala 12345678
+
+> setLastModified Bar.scala 12345678
+
+# formatting should fail because Bar.scala is invalid, but Foo.scala should be re-formatted
+-> scalafmt
+
+> checkLastModified Foo.scala !12345678
+
+> checkLastModified Bar.scala 12345678
+
+$ copy-file changes/Bar.scala src/main/scala/Bar.scala
+
+> setLastModified Foo.scala 12345678
+
+> setLastModified Bar.scala 12345678
+
+# Formatting should now succeed and Foo.scala should not be re-formatted
+> scalafmt
+
+> checkLastModified Foo.scala 12345678
+
+> checkLastModified Bar.scala !12345678
+
+# make sure that the custom clean task doesn't blow away the scala source files (it should exclude
+# any files not in the target directory
+> scalafmt / clean
+
+$ exists src/main/scala/Foo.scala
+
+$ exists src/main/scala/Bar.scala
diff --git a/sbt/src/sbt-test/nio/diff/base/Bar.md b/sbt/src/sbt-test/nio/diff/base/Bar.md
new file mode 100644
index 000000000..6e8ef37aa
--- /dev/null
+++ b/sbt/src/sbt-test/nio/diff/base/Bar.md
@@ -0,0 +1 @@
+### Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/diff/build.sbt b/sbt/src/sbt-test/nio/diff/build.sbt
new file mode 100644
index 000000000..284b70818
--- /dev/null
+++ b/sbt/src/sbt-test/nio/diff/build.sbt
@@ -0,0 +1,11 @@
+import sbt.nio.Keys._
+
+val fileInputTask = taskKey[Unit]("task with file inputs")
+
+fileInputTask / fileInputs += Glob(baseDirectory.value / "base", "*.md")
+
+fileInputTask := {
+  val created = fileInputTask.inputFileChanges.created
+  if (created.exists(_.getFileName.toString.startsWith("foo"))) assert(false)
+  assert(true)
+}
diff --git a/sbt/src/sbt-test/nio/diff/changes/Bar.md b/sbt/src/sbt-test/nio/diff/changes/Bar.md
new file mode 100644
index 000000000..79ec9ef4a
--- /dev/null
+++ b/sbt/src/sbt-test/nio/diff/changes/Bar.md
@@ -0,0 +1 @@
+### new bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/diff/test b/sbt/src/sbt-test/nio/diff/test
new file mode 100644
index 000000000..3ca2bbc80
--- /dev/null
+++ b/sbt/src/sbt-test/nio/diff/test
@@ -0,0 +1,9 @@
+> fileInputTask
+
+$ copy-file changes/Bar.md base/Bar.md
+
+> fileInputTask
+
+$ copy-file changes/Bar.md base/foo.md
+
+-> fileInputTask
diff --git a/sbt/src/sbt-test/nio/dynamic-outputs/base/foo.txt b/sbt/src/sbt-test/nio/dynamic-outputs/base/foo.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/dynamic-outputs/build.sbt b/sbt/src/sbt-test/nio/dynamic-outputs/build.sbt
new file mode 100644
index 000000000..1f7ffcb64
--- /dev/null
+++ b/sbt/src/sbt-test/nio/dynamic-outputs/build.sbt
@@ -0,0 +1,24 @@
+import java.nio.file.{ Path, Paths }
+
+val foo = taskKey[Seq[Path]]("Copy files")
+foo / fileInputs += baseDirectory.value.toGlob / "base" / "*.txt"
+foo / target := baseDirectory.value / "out"
+foo := {
+  val out = baseDirectory.value / "out"
+  foo.inputFiles.map { p =>
+    val f = p.toFile
+    val target = out / f.getName
+    IO.copyFile (f, target)
+    target.toPath
+  }
+}
+
+val checkOutputFiles = inputKey[Unit]("check output files")
+checkOutputFiles := {
+  val actual: Seq[Path] =
+    fileTreeView.value.list(baseDirectory.value.toGlob / "out" / **).map(_._1.getFileName).toList
+  Def.spaceDelimited("").parsed.head match {
+    case "empty" => assert(actual.isEmpty)
+    case fileName => assert(actual == Paths.get(fileName) :: Nil)
+  }
+}
diff --git a/sbt/src/sbt-test/nio/dynamic-outputs/test b/sbt/src/sbt-test/nio/dynamic-outputs/test
new file mode 100644
index 000000000..41567592a
--- /dev/null
+++ b/sbt/src/sbt-test/nio/dynamic-outputs/test
@@ -0,0 +1,11 @@
+> foo / clean
+
+> checkOutputFiles empty
+
+> foo
+
+> checkOutputFiles foo.txt
+
+> foo / clean
+
+> checkOutputFiles empty
diff --git a/sbt/src/sbt-test/nio/external-hooks/build.sbt b/sbt/src/sbt-test/nio/external-hooks/build.sbt
new file mode 100644
index 000000000..c01dc8321
--- /dev/null
+++ b/sbt/src/sbt-test/nio/external-hooks/build.sbt
@@ -0,0 +1,23 @@
+val generateSourceFile = taskKey[Unit]("generate source file")
+generateSourceFile := {
+  val testDir = ((Test / scalaSource).value.toPath / "Foo.scala").toString
+  val content = s"object Foo { val x = 2 }"
+  val src =
+    s"""
+       |import scala.language.experimental.macros
+       |import scala.reflect.macros.blackbox
+       |import java.nio.file.{ Files, Paths }
+       |
+       |object Generate {
+       |  def gen: Unit = macro genImpl
+       |  def genImpl(c: blackbox.Context): c.Expr[Unit] = {
+       |    Files.write(Paths.get("${testDir.replace("\\", "\\\\")}"), "$content".getBytes)
+       |    c.universe.reify(())
+       |  }
+       |}
+       |""".stripMargin
+  IO.write((Compile / scalaSource).value / "Generate.scala", src)
+}
+
+libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.5" % "test"
diff --git a/sbt/src/sbt-test/nio/external-hooks/src/main/scala/Foo.scala b/sbt/src/sbt-test/nio/external-hooks/src/main/scala/Foo.scala
new file mode 100644
index 000000000..43c42f145
--- /dev/null
+++ b/sbt/src/sbt-test/nio/external-hooks/src/main/scala/Foo.scala
@@ -0,0 +1 @@
+class Foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/external-hooks/src/test/scala/Foo.scala b/sbt/src/sbt-test/nio/external-hooks/src/test/scala/Foo.scala
new file mode 100644
index 000000000..b4736784b
--- /dev/null
+++ b/sbt/src/sbt-test/nio/external-hooks/src/test/scala/Foo.scala
@@ -0,0 +1,3 @@
+object Foo {
+  def x = 1
+}
diff --git a/sbt/src/sbt-test/nio/external-hooks/src/test/scala/FooTest.scala b/sbt/src/sbt-test/nio/external-hooks/src/test/scala/FooTest.scala
new file mode 100644
index 000000000..3be9ef70b
--- /dev/null
+++ b/sbt/src/sbt-test/nio/external-hooks/src/test/scala/FooTest.scala
@@ -0,0 +1,8 @@
+import org.scalatest.FlatSpec
+
+class FooTest extends FlatSpec {
+  Generate.gen
+  it should "work" in {
+    assert(Foo.x == 2)
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/external-hooks/test b/sbt/src/sbt-test/nio/external-hooks/test
new file mode 100644
index 000000000..26c5f15f3
--- /dev/null
+++ b/sbt/src/sbt-test/nio/external-hooks/test
@@ -0,0 +1,5 @@
+> generateSourceFile
+
+-> test
+
+> test
diff --git a/sbt/src/sbt-test/nio/file-hashes/base/Bar.md b/sbt/src/sbt-test/nio/file-hashes/base/Bar.md
new file mode 100644
index 000000000..6e8ef37aa
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/base/Bar.md
@@ -0,0 +1 @@
+### Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/file-hashes/base/Foo.txt b/sbt/src/sbt-test/nio/file-hashes/base/Foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/base/Foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/file-hashes/build.sbt b/sbt/src/sbt-test/nio/file-hashes/build.sbt
new file mode 100644
index 000000000..d0db76dca
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/build.sbt
@@ -0,0 +1,41 @@
+import sbt.nio.Keys._
+
+val foo = taskKey[Unit]("foo")
+foo / fileInputs := Seq(
+  baseDirectory.value.toGlob / "base" / "*.md",
+  baseDirectory.value.toGlob / "base" / "*.txt",
+)
+
+val checkModified = taskKey[Unit]("check that modified files are returned")
+checkModified := {
+  val modified = foo.inputFileChanges.modified
+  val allFiles = foo.inputFiles
+  if (modified.isEmpty) assert(true)
+  else {
+    assert(modified != allFiles)
+    assert(modified == Seq((baseDirectory.value / "base" / "Bar.md").toPath))
+  }
+}
+
+val checkRemoved = taskKey[Unit]("check that removed files are returned")
+checkRemoved := Def.taskDyn {
+  val files = foo.inputFiles
+  val removed = foo.inputFileChanges.deleted
+  if (removed.isEmpty) Def.task(assert(true))
+  else Def.task {
+    assert(files == Seq((baseDirectory.value / "base" / "Foo.txt").toPath))
+    assert(removed == Seq((baseDirectory.value / "base" / "Bar.md").toPath))
+  }
+}.value
+
+val checkAdded = taskKey[Unit]("check that modified files are returned")
+checkAdded := Def.taskDyn {
+  val files = foo.inputFiles
+  val created = foo.inputFileChanges.created
+  if (created.isEmpty || (files.toSet == created.toSet)) Def.task(assert(true))
+  else Def.task {
+    val base = baseDirectory.value / "base"
+    assert(files.toSet == Set("Bar.md", "Foo.txt").map(p => (base / p).toPath))
+    assert(created == Seq((baseDirectory.value / "base" / "Bar.md").toPath))
+  }
+}.value
diff --git a/sbt/src/sbt-test/nio/file-hashes/changes/Bar.md b/sbt/src/sbt-test/nio/file-hashes/changes/Bar.md
new file mode 100644
index 000000000..bde24f76f
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/changes/Bar.md
@@ -0,0 +1 @@
+### Bar updated
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/file-hashes/changes/Foo-bad.txt b/sbt/src/sbt-test/nio/file-hashes/changes/Foo-bad.txt
new file mode 100644
index 000000000..551f4d337
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/changes/Foo-bad.txt
@@ -0,0 +1 @@
+fooo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/file-hashes/changes/Foo.txt b/sbt/src/sbt-test/nio/file-hashes/changes/Foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/changes/Foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/file-hashes/original/Bar.md b/sbt/src/sbt-test/nio/file-hashes/original/Bar.md
new file mode 100644
index 000000000..6e8ef37aa
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/original/Bar.md
@@ -0,0 +1 @@
+### Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/file-hashes/original/Foo.txt b/sbt/src/sbt-test/nio/file-hashes/original/Foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/original/Foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/file-hashes/test b/sbt/src/sbt-test/nio/file-hashes/test
new file mode 100644
index 000000000..094635c99
--- /dev/null
+++ b/sbt/src/sbt-test/nio/file-hashes/test
@@ -0,0 +1,27 @@
+> checkModified
+
+$ copy-file changes/Bar.md base/Bar.md
+
+> checkModified
+
+$ copy-file changes/Foo-bad.txt base/Foo.txt
+
+-> checkModified
+
+-> checkModified
+
+$ copy-file changes/Foo.txt base/Foo.txt
+
+> checkModified
+
+> checkRemoved
+
+$ delete base/Bar.md
+
+> checkRemoved
+
+> checkAdded
+
+$ copy-file original/Bar.md base/Bar.md
+
+> checkAdded
diff --git a/sbt/src/sbt-test/nio/glob-dsl/base/subdir/nested-subdir/Bar.md b/sbt/src/sbt-test/nio/glob-dsl/base/subdir/nested-subdir/Bar.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/glob-dsl/base/subdir/nested-subdir/Foo.txt b/sbt/src/sbt-test/nio/glob-dsl/base/subdir/nested-subdir/Foo.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/glob-dsl/build.sbt b/sbt/src/sbt-test/nio/glob-dsl/build.sbt
new file mode 100644
index 000000000..2a235473a
--- /dev/null
+++ b/sbt/src/sbt-test/nio/glob-dsl/build.sbt
@@ -0,0 +1,60 @@
+// The project contains two files: { Foo.txt, Bar.md } in the subdirector base/subdir/nested-subdir
+
+// Check that we can correctly extract Foo.txt with a recursive source
+val foo = taskKey[Seq[File]]("Retrieve Foo.txt")
+
+foo / fileInputs += baseDirectory.value.toGlob / ** / "*.txt"
+
+foo := foo.inputFiles.map(_.toFile)
+
+val checkFoo = taskKey[Unit]("Check that the Foo.txt file is retrieved")
+
+checkFoo := assert(foo.value == Seq(baseDirectory.value / "base/subdir/nested-subdir/Foo.txt"))
+
+// Check that we can correctly extract Bar.md with a non-recursive source
+val bar = taskKey[Seq[File]]("Retrieve Bar.md")
+
+bar / fileInputs += baseDirectory.value.toGlob / "base" / "subdir" / "nested-subdir" / "*.md"
+
+bar := bar.inputFiles.map(_.toFile)
+
+val checkBar = taskKey[Unit]("Check that the Bar.md file is retrieved")
+
+checkBar := assert(bar.value == Seq(baseDirectory.value / "base" / "subdir" / "nested-subdir" / "Bar.md"))
+
+// Check that we can correctly extract Bar.md and Foo.md with a non-recursive source
+val all = taskKey[Seq[File]]("Retrieve all files")
+
+all / fileInputs += baseDirectory.value.toGlob / "base" / "subdir" / "nested-subdir" / *
+
+val checkAll = taskKey[Unit]("Check that the Bar.md file is retrieved")
+
+checkAll := {
+  import sbt.dsl.LinterLevel.Ignore
+  val expected = Set("Foo.txt", "Bar.md").map(baseDirectory.value / "base" / "subdir" / "nested-subdir" / _)
+  val actual = all.inputFiles.map(_.toFile).toSet
+  assert(actual == expected)
+}
+
+val set = taskKey[Seq[File]]("Specify redundant sources in a set")
+
+set / fileInputs ++= Seq(
+  baseDirectory.value.toGlob / "base" / **,
+  baseDirectory.value.toGlob / "base" / "subdir" / "nested-subdir" / *
+)
+
+val depth = taskKey[Seq[File]]("Specify redundant sources with limited depth")
+val checkDepth = taskKey[Unit]("Check that the Bar.md file is retrieved")
+
+depth / fileInputs ++= {
+  Seq(
+    Glob(baseDirectory.value / "base", AnyPath / AnyPath / "*.md"),
+    Glob(baseDirectory.value / "base" / "subdir", AnyPath / "*.md"),
+  )
+}
+
+checkDepth := {
+  val expected = Seq("Bar.md").map(baseDirectory.value / "base/subdir/nested-subdir" / _)
+  val actual = depth.inputFiles.map(_.toFile)
+  assert(actual == expected)
+}
diff --git a/sbt/src/sbt-test/nio/glob-dsl/test b/sbt/src/sbt-test/nio/glob-dsl/test
new file mode 100644
index 000000000..aafc93bad
--- /dev/null
+++ b/sbt/src/sbt-test/nio/glob-dsl/test
@@ -0,0 +1,7 @@
+> checkFoo
+
+> checkBar
+
+> checkAll
+
+> checkDepth
diff --git a/sbt/src/sbt-test/nio/input-filters/build.sbt b/sbt/src/sbt-test/nio/input-filters/build.sbt
new file mode 100644
index 000000000..767fbf612
--- /dev/null
+++ b/sbt/src/sbt-test/nio/input-filters/build.sbt
@@ -0,0 +1,34 @@
+import java.nio.file.{ Files, Path }
+
+val copyPaths = taskKey[Seq[Path]]("Copy paths")
+copyPaths / fileInputs += baseDirectory.value.toGlob / "inputs" / *
+copyPaths := {
+  val outFile = streams.value.cacheDirectory
+  IO.delete(outFile)
+  val out = Files.createDirectories(outFile.toPath)
+  copyPaths.inputFiles.map { path =>
+    Files.write(out / path.getFileName.toString, Files.readAllBytes(path))
+  }
+}
+
+val checkPaths = inputKey[Unit]("check paths")
+checkPaths := {
+  val expectedFileNames = Def.spaceDelimited().parsed.toSet
+  val actualFileNames = copyPaths.outputFiles.map(_.getFileName.toString).toSet
+  assert(expectedFileNames == actualFileNames)
+
+}
+
+val newFilter = settingKey[PathFilter]("Works around quotations not working in scripted")
+newFilter := HiddenFileFilter.toNio || "**/bar.txt"
+
+val fooFilter = settingKey[PathFilter]("A filter for the bar.txt file")
+fooFilter := ** / ".foo.txt"
+
+Global / onLoad := { s: State =>
+  if (scala.util.Properties.isWin) {
+    val path = s.baseDir.toPath / "inputs" / ".foo.txt"
+    Files.setAttribute(path, "dos:hidden", true)
+  }
+  s
+}
diff --git a/sbt/src/sbt-test/nio/input-filters/inputs/.foo.txt b/sbt/src/sbt-test/nio/input-filters/inputs/.foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/input-filters/inputs/.foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/input-filters/inputs/bar.txt b/sbt/src/sbt-test/nio/input-filters/inputs/bar.txt
new file mode 100644
index 000000000..ba0e162e1
--- /dev/null
+++ b/sbt/src/sbt-test/nio/input-filters/inputs/bar.txt
@@ -0,0 +1 @@
+bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/input-filters/test b/sbt/src/sbt-test/nio/input-filters/test
new file mode 100644
index 000000000..baeae3b90
--- /dev/null
+++ b/sbt/src/sbt-test/nio/input-filters/test
@@ -0,0 +1,10 @@
+# hidden files are excluded
+> checkPaths bar.txt
+
+> set copyPaths / fileInputExcludeFilter := NothingFilter.toNio
+
+> checkPaths .foo.txt bar.txt
+
+> set copyPaths / fileInputIncludeFilter := fooFilter.value
+
+> checkPaths .foo.txt
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/intraproject-inputs/build.sbt b/sbt/src/sbt-test/nio/intraproject-inputs/build.sbt
new file mode 100644
index 000000000..0d69d7a31
--- /dev/null
+++ b/sbt/src/sbt-test/nio/intraproject-inputs/build.sbt
@@ -0,0 +1 @@
+val root = sbt.interproject.inputs.Build.root
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/intraproject-inputs/project/Build.scala b/sbt/src/sbt-test/nio/intraproject-inputs/project/Build.scala
new file mode 100644
index 000000000..1f36f1640
--- /dev/null
+++ b/sbt/src/sbt-test/nio/intraproject-inputs/project/Build.scala
@@ -0,0 +1,70 @@
+package sbt
+package interproject.inputs
+
+import sbt.Keys._
+import sbt.nio.Keys._
+
+/**
+* This test is for internal logic so it must be in the sbt package because it uses package
+* private apis.
+*/
+object Build {
+  val cached = settingKey[Unit]("")
+  val newInputs = settingKey[Unit]("")
+
+  val checkCompile = taskKey[Unit]("check compile inputs")
+  val checkRun = taskKey[Unit]("check runtime inputs")
+  val checkTest = taskKey[Unit]("check test inputs")
+
+  val root = (project in file(".")).settings(
+    Compile / cached / fileInputs := (Compile / unmanagedSources / fileInputs).value ++
+      (Compile / unmanagedResources / fileInputs).value,
+    Test / cached / fileInputs := (Test / unmanagedSources / fileInputs).value ++
+      (Test / unmanagedResources / fileInputs).value,
+    Compile / newInputs / fileInputs += baseDirectory.value.toGlob / "*.sc",
+    Compile / unmanagedSources / fileInputs ++= (Compile / newInputs / fileInputs).value,
+    checkCompile := {
+      val actual = (Compile / compile / transitiveDynamicInputs).value.map(_.glob).toSet
+      val expected = ((Compile / cached / fileInputs).value ++
+        (Compile / newInputs / fileInputs).value).toSet
+      streams.value.log.debug(s"actual: $actual\nexpected:$expected")
+      if (actual != expected) {
+        val actualExtra = actual diff expected
+        val expectedExtra = expected diff actual
+        throw new IllegalStateException(
+          s"$actual did not equal $expected\n" +
+            s"${if (actualExtra.nonEmpty) s"Actual result had extra fields $actualExtra" else ""}" +
+            s"${if (expectedExtra.nonEmpty) s"Actual result was missing: $expectedExtra" else ""}")
+      }
+    },
+    checkRun := {
+      val actual = (Runtime / run / transitiveDynamicInputs).value.map(_.glob).toSet
+      // Runtime doesn't add any new inputs, but it should correctly find the Compile inputs via
+      // delegation.
+      val expected = ((Compile / cached / fileInputs).value ++
+        (Compile / newInputs / fileInputs).value).toSet
+      streams.value.log.debug(s"actual: $actual\nexpected:$expected")
+      if (actual != expected) {
+        val actualExtra = actual diff expected
+        val expectedExtra = expected diff actual
+        throw new IllegalStateException(
+          s"${if (actualExtra.nonEmpty) s"Actual result had extra fields: $actualExtra" else ""}" +
+            s"${if (expectedExtra.nonEmpty) s"Actual result was missing: $expectedExtra" else ""}")
+      }
+    },
+    checkTest := {
+      val actual = (Test / compile / transitiveDynamicInputs).value.map(_.glob).toSet
+      val expected = ((Test / cached / fileInputs).value ++
+        (Compile / newInputs / fileInputs).value ++ (Compile / cached / fileInputs).value).toSet
+      streams.value.log.debug(s"actual: $actual\nexpected:$expected")
+      if (actual != expected) {
+        val actualExtra = actual diff expected
+        val expectedExtra = expected diff actual
+        throw new IllegalStateException(
+          s"$actual did not equal $expected\n" +
+            s"${if (actualExtra.nonEmpty) s"Actual result had extra fields $actualExtra" else ""}" +
+            s"${if (expectedExtra.nonEmpty) s"Actual result was missing: $expectedExtra" else ""}")
+      }
+    }
+  )
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/intraproject-inputs/src/main/scala/bar/Bar.scala b/sbt/src/sbt-test/nio/intraproject-inputs/src/main/scala/bar/Bar.scala
new file mode 100644
index 000000000..f51e51890
--- /dev/null
+++ b/sbt/src/sbt-test/nio/intraproject-inputs/src/main/scala/bar/Bar.scala
@@ -0,0 +1,3 @@
+package bar
+
+object Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/intraproject-inputs/src/main/scala/foo/Foo.scala b/sbt/src/sbt-test/nio/intraproject-inputs/src/main/scala/foo/Foo.scala
new file mode 100644
index 000000000..5c464310a
--- /dev/null
+++ b/sbt/src/sbt-test/nio/intraproject-inputs/src/main/scala/foo/Foo.scala
@@ -0,0 +1,3 @@
+package foo
+
+object Foo
diff --git a/sbt/src/sbt-test/nio/intraproject-inputs/test b/sbt/src/sbt-test/nio/intraproject-inputs/test
new file mode 100644
index 000000000..7aca28678
--- /dev/null
+++ b/sbt/src/sbt-test/nio/intraproject-inputs/test
@@ -0,0 +1,5 @@
+> checkCompile
+
+> checkRun
+
+> checkTest
diff --git a/sbt/src/sbt-test/nio/last-modified/base/Bar.md b/sbt/src/sbt-test/nio/last-modified/base/Bar.md
new file mode 100644
index 000000000..6e8ef37aa
--- /dev/null
+++ b/sbt/src/sbt-test/nio/last-modified/base/Bar.md
@@ -0,0 +1 @@
+### Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/last-modified/build.sbt b/sbt/src/sbt-test/nio/last-modified/build.sbt
new file mode 100644
index 000000000..74bf81fa5
--- /dev/null
+++ b/sbt/src/sbt-test/nio/last-modified/build.sbt
@@ -0,0 +1,35 @@
+import sbt.nio.Keys._
+
+import scala.util.Try
+
+val fileInputTask = taskKey[Unit]("task with file inputs")
+
+fileInputTask / fileInputs += (baseDirectory.value / "base").toGlob / "*.md"
+
+fileInputTask / inputFileStamper := sbt.nio.FileStamper.LastModified
+
+fileInputTask := {
+  /*
+   * Normally we'd use an input task for this kind of thing, but input tasks don't work with
+   * incremental task evaluation so, instead, we manually set the input in a file. As a result,
+   * most of the test commands have to be split into two: one to set the expected result and one
+   * to validate it.
+   */
+  val expectedChanges =
+    Try(IO.read(baseDirectory.value / "expected").split(" ").toSeq.filterNot(_.isEmpty))
+      .getOrElse(Nil)
+      .map(baseDirectory.value.toPath / "base" / _)
+  val actual = fileInputTask.inputFileChanges.modified
+  assert(actual.toSet == expectedChanges.toSet)
+}
+
+val setExpected = inputKey[Unit]("Writes a space separated list of files")
+setExpected := {
+  IO.write(baseDirectory.value / "expected", Def.spaceDelimited().parsed.mkString(" "))
+}
+
+val setLastModified = taskKey[Unit]("Reset the last modified time")
+setLastModified := {
+  val file = baseDirectory.value / "base" / "Bar.md"
+  IO.setModifiedTimeOrFalse(file, 1234567890L)
+}
diff --git a/sbt/src/sbt-test/nio/last-modified/changes/Bar.md b/sbt/src/sbt-test/nio/last-modified/changes/Bar.md
new file mode 100644
index 000000000..79ec9ef4a
--- /dev/null
+++ b/sbt/src/sbt-test/nio/last-modified/changes/Bar.md
@@ -0,0 +1 @@
+### new bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/last-modified/changes/Bar2.md b/sbt/src/sbt-test/nio/last-modified/changes/Bar2.md
new file mode 100644
index 000000000..a009e9ac1
--- /dev/null
+++ b/sbt/src/sbt-test/nio/last-modified/changes/Bar2.md
@@ -0,0 +1 @@
+### new bar 2
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/last-modified/test b/sbt/src/sbt-test/nio/last-modified/test
new file mode 100644
index 000000000..8c2ffd07f
--- /dev/null
+++ b/sbt/src/sbt-test/nio/last-modified/test
@@ -0,0 +1,32 @@
+> fileInputTask
+
+$ touch base/Bar.md
+
+# The change to Bar.md should be detected since we set last modified instead of hash
+> setExpected Bar.md
+
+> fileInputTask
+
+$ copy-file changes/Bar.md base/Bar.md
+
+# the last modified should change due to the copy
+> fileInputTask
+
+> setLastModified
+
+> fileInputTask
+
+$ copy-file changes/Bar2.md base/Bar.md
+
+> setLastModified
+
+# Since we reverted to the previous last modified time, there should be no changes
+> setExpected
+
+> fileInputTask
+
+$ touch base/Bar.md
+
+> setExpected Bar.md
+
+> fileInputTask
diff --git a/sbt/src/sbt-test/nio/legacy-filters/build.sbt b/sbt/src/sbt-test/nio/legacy-filters/build.sbt
new file mode 100644
index 000000000..921c202e9
--- /dev/null
+++ b/sbt/src/sbt-test/nio/legacy-filters/build.sbt
@@ -0,0 +1,15 @@
+
+val checkSources = inputKey[Unit]("Check that the compile sources match the input file names")
+checkSources := {
+  val sources = Def.spaceDelimited("").parsed.toSet
+  val actual = (Compile / unmanagedSources).value.map(_.getName).toSet
+  assert(sources == actual)
+}
+
+val oldExcludeFilter = settingKey[sbt.io.FileFilter]("the default exclude filter")
+oldExcludeFilter :=  "Bar.scala" || "Baz.scala"
+
+Compile / excludeFilter := oldExcludeFilter.value
+
+val newFilter = settingKey[sbt.nio.file.PathFilter]("an alternative path filter")
+newFilter := !sbt.nio.file.PathFilter(** / "{Baz,Bar}.scala")
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/legacy-filters/src/main/scala/Bar.scala b/sbt/src/sbt-test/nio/legacy-filters/src/main/scala/Bar.scala
new file mode 100644
index 000000000..afa08f013
--- /dev/null
+++ b/sbt/src/sbt-test/nio/legacy-filters/src/main/scala/Bar.scala
@@ -0,0 +1 @@
+class Bar {
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/legacy-filters/src/main/scala/Foo.scala b/sbt/src/sbt-test/nio/legacy-filters/src/main/scala/Foo.scala
new file mode 100644
index 000000000..43c42f145
--- /dev/null
+++ b/sbt/src/sbt-test/nio/legacy-filters/src/main/scala/Foo.scala
@@ -0,0 +1 @@
+class Foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/legacy-filters/test b/sbt/src/sbt-test/nio/legacy-filters/test
new file mode 100644
index 000000000..f05e83685
--- /dev/null
+++ b/sbt/src/sbt-test/nio/legacy-filters/test
@@ -0,0 +1,21 @@
+> checkSources Foo.scala
+
+> compile
+
+> set Compile / excludeFilter := HiddenFileFilter
+
+> checkSources Foo.scala Bar.scala
+
+-> compile
+
+> set Compile / unmanagedSources / excludeFilter := oldExcludeFilter.value
+
+> compile
+
+> set Compile / unmanagedSources / excludeFilter := HiddenFileFilter
+
+-> compile
+
+> set Compile / unmanagedSources / fileInputIncludeFilter := newFilter.value
+
+> compile
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/make-clone/build.sbt b/sbt/src/sbt-test/nio/make-clone/build.sbt
new file mode 100644
index 000000000..06d5c091d
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/build.sbt
@@ -0,0 +1,124 @@
+import java.nio.file.{ Files, Path }
+import scala.sys.process._
+
+val compileOpts = settingKey[Seq[String]]("Extra compile options")
+compileOpts := { "-fPIC" :: "-std=gnu99" :: Nil }
+val compileLib = taskKey[Seq[Path]]("Compile the library")
+compileLib / sourceDirectory := sourceDirectory.value / "lib"
+compileLib / fileInputs := {
+  val base: Glob = (compileLib / sourceDirectory).value.toGlob
+  base / ** / "*.c" :: base / "include" / "*.h" :: Nil
+}
+compileLib / target := baseDirectory.value / "out" / "objects"
+compileLib := {
+  val outputDir = Files.createDirectories(streams.value.cacheDirectory.toPath)
+  val logger = streams.value.log
+  val include = (compileLib / sourceDirectory).value / "include"
+  def outputPath(path: Path): Path =
+    outputDir / path.getFileName.toString.replaceAll(".c$", ".o")
+  def compile(path: Path): Path = {
+    val output = outputPath(path)
+    logger.info(s"Compiling $path to $output")
+    Seq("gcc", "-fPIC", "-std=gnu99", s"-I$include", "-c", s"$path", "-o", s"$output").!!
+    output
+  }
+  val report = compileLib.inputFileChanges
+  val sourceMap = compileLib.inputFiles.view.collect {
+    case p: Path if p.getFileName.toString.endsWith(".c") => outputPath(p) -> p
+  }.toMap
+  val existingTargets = fileTreeView.value.list(outputDir.toGlob / **).flatMap { case (p, _) =>
+    if (!sourceMap.contains(p)) {
+      Files.deleteIfExists(p)
+      None
+    } else {
+      Some(p)
+    }
+  }.toSet
+  val updatedPaths = (report.created ++ report.modified).toSet
+  val needCompile =
+    if (updatedPaths.exists(_.getFileName.toString.endsWith(".h"))) sourceMap.values
+    else updatedPaths ++ sourceMap.filterKeys(!existingTargets(_)).values
+  needCompile.foreach(compile)
+  sourceMap.keys.toVector
+}
+
+val linkLib = taskKey[Path]("")
+linkLib / target := baseDirectory.value / "out" / "lib"
+linkLib := {
+  val outputDir = Files.createDirectories(streams.value.cacheDirectory.toPath)
+  val logger = streams.value.log
+  val isMac = scala.util.Properties.isMac
+  val library = outputDir / s"libfoo.${if (isMac) "dylib" else "so"}"
+  val (report, objects) = (compileLib.outputFileChanges, compileLib.outputFiles)
+  val linkOpts = if (isMac) Seq("-dynamiclib") else Seq("-shared", "-fPIC")
+  if (report.hasChanges || !Files.exists(library)) {
+    logger.info(s"Linking $library")
+    (Seq("gcc") ++ linkOpts ++ Seq("-o", s"$library") ++ objects.map(_.toString)).!!
+  } else {
+    logger.debug(s"Skipping linking of $library")
+  }
+  library
+}
+
+val compileMain = taskKey[Path]("compile main")
+compileMain / sourceDirectory := sourceDirectory.value / "main"
+compileMain / fileInputs := (compileMain / sourceDirectory).value.toGlob / "main.c" :: Nil
+compileMain / target := baseDirectory.value / "out" / "main"
+compileMain := {
+  val library = linkLib.value
+  val changed: Boolean = compileMain.inputFileChanges.hasChanges ||
+    linkLib.outputFileChanges.hasChanges
+  val include = (compileLib / sourceDirectory).value / "include"
+  val logger = streams.value.log
+  val outDir = (compileMain / target).value.toPath
+  val outPath = outDir.resolve("main.out")
+  val inputs = compileMain.inputFiles
+  if (changed || !Files.exists(outPath)) {
+    inputs match {
+      case Seq(main) =>
+        Files.createDirectories(outDir)
+        logger.info(s"Building executable $outPath")
+        (Seq("gcc") ++ compileOpts.value ++ Seq(
+          main.toString,
+          s"-I$include",
+          "-o",
+          outPath.toString,
+          s"-L${library.getParent}",
+          "-lfoo"
+        )).!!
+      case main =>
+        throw new IllegalStateException(s"multiple main files detected: ${main.mkString(",")}")
+    }
+  } else {
+    logger.info(s"Not building $outPath: no dependencies have changed")
+  }
+  outPath
+}
+
+val executeMain = inputKey[Unit]("run the main method")
+executeMain := {
+  val args = Def.spaceDelimited("<arguments>").parsed
+  val binary: Seq[Path] = compileMain.outputFiles
+  val logger = streams.value.log
+  binary match {
+    case Seq(b) =>
+      val argString =
+        if (args.nonEmpty) s" with arguments: ${args.mkString("'", "', '", "'")}" else ""
+      logger.info(s"Running $b$argString")
+      logger.info(RunBinary(b, args, linkLib.value).mkString("\n"))
+
+    case b =>
+      throw new IllegalArgumentException(
+        s"compileMain generated multiple binaries: ${b.mkString(", ")}"
+      )
+  }
+}
+
+val checkOutput = inputKey[Unit]("check the output value")
+checkOutput := {
+  val Seq(arg, res) = Def.spaceDelimited("").parsed
+  val binary: Path = compileMain.outputFiles.head
+  val output = RunBinary(binary, arg :: Nil, linkLib.value)
+  assert(output.contains(s"f($arg) = $res"))
+  ()
+}
diff --git a/sbt/src/sbt-test/nio/make-clone/changes/bad.c b/sbt/src/sbt-test/nio/make-clone/changes/bad.c
new file mode 100644
index 000000000..4e0b2da04
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/changes/bad.c
@@ -0,0 +1 @@
+int
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/make-clone/changes/lib.c b/sbt/src/sbt-test/nio/make-clone/changes/lib.c
new file mode 100644
index 000000000..d811899fb
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/changes/lib.c
@@ -0,0 +1,16 @@
+#include "lib.h"
+
+#define __STR(x) #x
+#define STR(x) __STR(x)
+
+#define BODY(x, op) x op x
+#define OP *
+#define ARG x
+
+const int func(const int x) {
+    return BODY(ARG, OP);
+}
+
+const char* func_str() {
+    return BODY(STR(ARG), " "STR(OP)" ");
+}
diff --git a/sbt/src/sbt-test/nio/make-clone/project/RunBinary.scala b/sbt/src/sbt-test/nio/make-clone/project/RunBinary.scala
new file mode 100644
index 000000000..008ceecdc
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/project/RunBinary.scala
@@ -0,0 +1,15 @@
+import java.nio.file.Path
+import java.util.concurrent.TimeUnit
+
+object RunBinary {
+  def apply(binary: Path, args: Seq[String], libraryPath: Path): Seq[String] = {
+    val builder = new java.lang.ProcessBuilder(binary.toString +: args :_*)
+    if (scala.util.Properties.isLinux) {
+      builder.environment.put("LD_LIBRARY_PATH", libraryPath.getParent.toString)
+    }
+    val process = builder.start()
+    process.waitFor(5, TimeUnit.SECONDS)
+    scala.io.Source.fromInputStream(process.getInputStream).getLines.toVector ++
+      scala.io.Source.fromInputStream(process.getErrorStream).getLines
+  }
+}
diff --git a/sbt/src/sbt-test/nio/make-clone/src/lib/include/lib.h b/sbt/src/sbt-test/nio/make-clone/src/lib/include/lib.h
new file mode 100644
index 000000000..11951d7e8
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/src/lib/include/lib.h
@@ -0,0 +1,3 @@
+const int func(const int);
+
+const char* func_str();
diff --git a/sbt/src/sbt-test/nio/make-clone/src/lib/lib.c b/sbt/src/sbt-test/nio/make-clone/src/lib/lib.c
new file mode 100644
index 000000000..6cb03f41d
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/src/lib/lib.c
@@ -0,0 +1,16 @@
+#include "lib.h"
+
+#define __STR(x) #x
+#define STR(x) __STR(x)
+
+#define BODY(x, op) x op x op x
+#define OP *
+#define ARG x
+
+const int func(const int x) {
+    return BODY(ARG, OP);
+}
+
+const char* func_str() {
+    return BODY(STR(ARG), " "STR(OP)" ");
+}
diff --git a/sbt/src/sbt-test/nio/make-clone/src/main/main.c b/sbt/src/sbt-test/nio/make-clone/src/main/main.c
new file mode 100644
index 000000000..1dddd5336
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/src/main/main.c
@@ -0,0 +1,17 @@
+#include "lib.h"
+#include "stdio.h"
+#include "stdlib.h"
+
+int main(int argc, char *argv[]) {
+  if (argc == 1) printf("No arguments provided, evaluating f with default value: 1\n");
+  printf("f := %s\n", func_str());
+  if (argc == 1) {
+    printf("f(1) = %d\n", func(1));
+  } else {
+    for (int i = 1; i < argc; ++i) {
+      int arg = atoi(argv[i]);
+      printf("f(%d) = %d\n", arg, func(arg));
+    }
+  }
+  return 0;
+}
diff --git a/sbt/src/sbt-test/nio/make-clone/test b/sbt/src/sbt-test/nio/make-clone/test
new file mode 100644
index 000000000..235a39f76
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/test
@@ -0,0 +1,31 @@
+> executeMain 1
+
+> checkDirectoryContents out/main main.out
+
+> compileMain / clean
+
+> checkDirectoryContents out/main empty
+
+> checkDirectoryContents out/lib libfoo*
+
+> linkLib / clean
+
+> checkDirectoryContents out/lib empty
+
+> executeMain 1
+
+> checkDirectoryContents out/main main.out
+
+> checkDirectoryContents out/lib libfoo*
+
+> checkOutput 2 8
+
+$ copy-file changes/bad.c src/lib/bad.c
+
+$ copy-file changes/lib.c src/lib/lib.c
+
+-> checkOutput 2 4
+
+$ delete src/lib/bad.c
+
+> checkOutput 2 4
diff --git a/sbt/src/sbt-test/nio/make-clone/tests.sbt b/sbt/src/sbt-test/nio/make-clone/tests.sbt
new file mode 100644
index 000000000..37baa0b06
--- /dev/null
+++ b/sbt/src/sbt-test/nio/make-clone/tests.sbt
@@ -0,0 +1,19 @@
+import java.nio.file.Path
+
+val checkDirectoryContents = inputKey[Unit]("Validates that a directory has the expected files")
+checkDirectoryContents := {
+  val arguments = Def.spaceDelimited("").parsed
+  val directory = (baseDirectory.value / arguments.head).toPath
+  val view = fileTreeView.value
+  val expected = arguments.tail
+  expected match {
+    case s if s.isEmpty => assert(view.list(directory.toGlob / **).isEmpty)
+    case Seq("empty")   => assert(view.list(directory.toGlob / **).isEmpty)
+    case globStrings =>
+      val globs = globStrings.map(Glob.apply)
+      val actual: Seq[Path] = view.list(directory.toGlob / **).map {
+        case (p, _) => directory.relativize(p)
+      }
+      assert(actual.forall(f => globs.exists(_.matches(f))))
+  }
+}
diff --git a/sbt/src/sbt-test/nio/multiple-inputs/bar/bar.md b/sbt/src/sbt-test/nio/multiple-inputs/bar/bar.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/multiple-inputs/build.sbt b/sbt/src/sbt-test/nio/multiple-inputs/build.sbt
new file mode 100644
index 000000000..824d7c760
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-inputs/build.sbt
@@ -0,0 +1,19 @@
+val foo = taskKey[Unit]("dummy task with inputs")
+foo / fileInputs += baseDirectory.value.toGlob / "foo" / *
+
+val bar = taskKey[Unit]("dummy task with inputs")
+bar / fileInputs += baseDirectory.value.toGlob / "bar" / *
+
+val check = taskKey[Unit]("check expected changes")
+check := {
+  (foo.inputFileChanges.modified ++ bar.inputFileChanges.modified) match {
+    case Nil =>
+      val contents = IO.read(baseDirectory.value / "foo" / "foo.md")
+      assert(contents == "foo", s"expected 'foo', got '$contents")
+    case Seq(f, b) =>
+      val fContents = IO.read(f.toFile)
+      assert(fContents == "updated", s"expected 'updated', got '$fContents' for $f")
+      val bContents = IO.read(b.toFile)
+      assert(bContents == "updated", s"expected 'updated', got '$fContents' for $b")
+  }
+}
diff --git a/sbt/src/sbt-test/nio/multiple-inputs/changes/bad.md b/sbt/src/sbt-test/nio/multiple-inputs/changes/bad.md
new file mode 100644
index 000000000..44d6628cd
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-inputs/changes/bad.md
@@ -0,0 +1 @@
+bad
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/multiple-inputs/changes/updated.md b/sbt/src/sbt-test/nio/multiple-inputs/changes/updated.md
new file mode 100644
index 000000000..f55556eed
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-inputs/changes/updated.md
@@ -0,0 +1 @@
+updated
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/multiple-inputs/foo/foo.md b/sbt/src/sbt-test/nio/multiple-inputs/foo/foo.md
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-inputs/foo/foo.md
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/multiple-inputs/test b/sbt/src/sbt-test/nio/multiple-inputs/test
new file mode 100644
index 000000000..348eb304b
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-inputs/test
@@ -0,0 +1,17 @@
+> check
+
+$ copy-file changes/bad.md foo/foo.md
+
+$ copy-file changes/updated.md bar/bar.md
+
+-> check
+
+-> check
+
+$ copy-file changes/updated.md foo/foo.md
+
+> check
+
+# the changes should be empty now but the content of foo/foo.md is no longer "foo"
+-> check
+
diff --git a/sbt/src/sbt-test/nio/multiple-outputs/bar/bar.md b/sbt/src/sbt-test/nio/multiple-outputs/bar/bar.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/multiple-outputs/build.sbt b/sbt/src/sbt-test/nio/multiple-outputs/build.sbt
new file mode 100644
index 000000000..35d5900ae
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-outputs/build.sbt
@@ -0,0 +1,31 @@
+import java.nio.file.Path
+
+val foo = taskKey[Seq[Path]]("dummy task with inputs")
+foo := fileTreeView.value.list(baseDirectory.value.toGlob / "foo" / *).map(_._1)
+
+val bar = taskKey[Seq[Path]]("dummy task with inputs")
+bar := fileTreeView.value.list(baseDirectory.value.toGlob / "bar" / *).map(_._1)
+
+val check = taskKey[Unit]("check expected changes")
+check := {
+  foo.outputFileChanges.modified ++ bar.outputFileChanges.modified match {
+    case Nil =>
+      val contents = IO.read(baseDirectory.value / "foo" / "foo.md")
+      assert(contents == "foo", s"expected 'foo', got '$contents")
+    case Seq(f, b) =>
+      val fContents = IO.read(f.toFile)
+      assert(fContents == "updated", s"expected 'updated', got '$fContents' for $f")
+      val bContents = IO.read(b.toFile)
+      assert(bContents == "updated", s"expected 'updated', got '$fContents' for $b")
+  }
+}
+
+val setModified = inputKey[Unit]("set the last modified time for a file")
+setModified := {
+  val Seq(relative, lm) = Def.spaceDelimited().parsed
+  // be safe in case of windows
+  val file = relative.split("/") match {
+    case Array(h, rest @ _*) => rest.foldLeft(baseDirectory.value / h)(_ / _)
+  }
+  IO.setModifiedTimeOrFalse(file, lm.toLong)
+}
diff --git a/sbt/src/sbt-test/nio/multiple-outputs/changes/bad.md b/sbt/src/sbt-test/nio/multiple-outputs/changes/bad.md
new file mode 100644
index 000000000..44d6628cd
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-outputs/changes/bad.md
@@ -0,0 +1 @@
+bad
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/multiple-outputs/changes/updated.md b/sbt/src/sbt-test/nio/multiple-outputs/changes/updated.md
new file mode 100644
index 000000000..f55556eed
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-outputs/changes/updated.md
@@ -0,0 +1 @@
+updated
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/multiple-outputs/foo/foo.md b/sbt/src/sbt-test/nio/multiple-outputs/foo/foo.md
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-outputs/foo/foo.md
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/multiple-outputs/test b/sbt/src/sbt-test/nio/multiple-outputs/test
new file mode 100644
index 000000000..804dc4733
--- /dev/null
+++ b/sbt/src/sbt-test/nio/multiple-outputs/test
@@ -0,0 +1,23 @@
+> check
+
+$ copy-file changes/bad.md foo/foo.md
+
+$ copy-file changes/updated.md bar/bar.md
+
+# just in case the two of foo.md copies happen too quickly to update the last modified time
+> setModified foo/foo.md 123456
+
+-> check
+
+-> check
+
+$ copy-file changes/updated.md foo/foo.md
+
+# just in case the two of foo.md copies happen too quickly to update the last modified time
+> setModified foo/foo.md 12345678
+
+> check
+
+# the changes should be empty now but the content of foo/foo.md is no longer "foo"
+-> check
+
diff --git a/sbt/src/sbt-test/nio/output-filters/build.sbt b/sbt/src/sbt-test/nio/output-filters/build.sbt
new file mode 100644
index 000000000..08758851e
--- /dev/null
+++ b/sbt/src/sbt-test/nio/output-filters/build.sbt
@@ -0,0 +1,21 @@
+import java.nio.file.{ Files, Path }
+
+val outputTask = taskKey[Seq[Path]]("A task that generates outputs")
+outputTask := {
+  val dir = Files.createDirectories(streams.value.cacheDirectory.toPath)
+  Seq("foo.txt" -> "foo", "bar.txt" -> "bar").map { case (name, content) =>
+    Files.write(dir/ name, content.getBytes)
+  } :+ dir
+}
+
+val checkOutputs = inputKey[Unit]("check outputs")
+checkOutputs := {
+  val expected = Def.spaceDelimited("").parsed.map {
+    case "base" => (outputTask / streams).value.cacheDirectory.toPath
+    case f => (outputTask / streams).value.cacheDirectory.toPath / f
+  }
+  assert((outputTask / allOutputFiles).value.toSet == expected.toSet)
+}
+
+val barFilter = settingKey[PathFilter]("A filter for the bar.txt file")
+barFilter := ** / "bar.txt"
diff --git a/sbt/src/sbt-test/nio/output-filters/test b/sbt/src/sbt-test/nio/output-filters/test
new file mode 100644
index 000000000..cfbb73286
--- /dev/null
+++ b/sbt/src/sbt-test/nio/output-filters/test
@@ -0,0 +1,17 @@
+> compile
+
+> checkOutputs foo.txt bar.txt base
+
+> set outputTask / fileOutputIncludeFilter := sbt.io.RegularFileFilter
+
+> checkOutputs foo.txt bar.txt
+
+> set outputTask / fileOutputIncludeFilter := sbt.io.DirectoryFilter
+
+> checkOutputs base
+
+> set outputTask / fileOutputIncludeFilter := sbt.io.RegularFileFilter
+
+> set outputTask / fileOutputExcludeFilter := barFilter.value
+
+> checkOutputs foo.txt
diff --git a/sbt/src/sbt-test/nio/overrides/bar.txt b/sbt/src/sbt-test/nio/overrides/bar.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/overrides/baz.txt b/sbt/src/sbt-test/nio/overrides/baz.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/overrides/build.sbt b/sbt/src/sbt-test/nio/overrides/build.sbt
new file mode 100644
index 000000000..9696eeea2
--- /dev/null
+++ b/sbt/src/sbt-test/nio/overrides/build.sbt
@@ -0,0 +1,24 @@
+import java.nio.file.Path
+
+val foo = taskKey[Path]("foo")
+// Check a direct override
+foo / outputFileStamps := Nil
+foo := baseDirectory.value.toPath / "foo.txt"
+
+TaskKey[Unit]("checkFoo") := assert((foo / outputFileStamps).value == Nil)
+
+val bar = taskKey[Path]("bar")
+// Check an append
+bar / outputFileStamps ++= (baz / outputFileStamps).value
+bar / outputFileStamps ++= (baz / outputFileStamps).value
+bar := baseDirectory.value.toPath / "bar.txt"
+
+val baz = taskKey[Path]("baz")
+baz := baseDirectory.value.toPath / "baz.txt"
+
+TaskKey[Unit]("checkBar") := {
+  val stamps = (bar / outputFileStamps).value
+  assert(stamps.length == 3)
+  val fileNames = stamps.map(_._1.getFileName.toString).toSet
+  assert(fileNames == Set("bar.txt", "baz.txt"))
+}
diff --git a/sbt/src/sbt-test/nio/overrides/foo.txt b/sbt/src/sbt-test/nio/overrides/foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/nio/overrides/foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/overrides/test b/sbt/src/sbt-test/nio/overrides/test
new file mode 100644
index 000000000..070045158
--- /dev/null
+++ b/sbt/src/sbt-test/nio/overrides/test
@@ -0,0 +1,3 @@
+> checkBar
+
+> checkFoo
diff --git a/sbt/src/sbt-test/nio/reload/.scalafmt.conf b/sbt/src/sbt-test/nio/reload/.scalafmt.conf
new file mode 100644
index 000000000..8a81e8505
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/.scalafmt.conf
@@ -0,0 +1,21 @@
+version = 2.0.0
+maxColumn = 100
+project.git = true
+project.excludeFilters = [ "\\Wsbt-test\\W", "\\Winput_sources\\W", "\\Wcontraband-scala\\W" ]
+
+# http://docs.scala-lang.org/style/scaladoc.html recommends the JavaDoc style.
+# scala/scala is written that way too https://github.com/scala/scala/blob/v2.12.2/src/library/scala/Predef.scala
+docstrings = JavaDoc
+
+# This also seems more idiomatic to include whitespace in import x.{ yyy }
+spaces.inImportCurlyBraces = true
+
+# This is more idiomatic Scala.
+# http://docs.scala-lang.org/style/indentation.html#methods-with-numerous-arguments
+align.openParenCallSite = false
+align.openParenDefnSite = false
+
+# For better code clarity
+danglingParentheses = true
+
+trailingCommas = preserve
diff --git a/sbt/src/sbt-test/nio/reload/build.sbt b/sbt/src/sbt-test/nio/reload/build.sbt
new file mode 100644
index 000000000..910bfa622
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/build.sbt
@@ -0,0 +1,19 @@
+import scala.concurrent.duration._
+
+val foo = inputKey[Unit]("working task")
+foo := {
+  val filename = Def.spaceDelimited("").parsed.head
+  IO.touch(baseDirectory.value / filename)
+}
+
+val exists = inputKey[Unit]("check that the file was written")
+exists := {
+  val filename = Def.spaceDelimited("").parsed.head
+  assert((baseDirectory.value / filename).exists)
+}
+
+Global / onChangedBuildSource := ReloadOnSourceChanges
+
+ThisBuild / checkBuildSources / pollInterval := 0.seconds
+
+val sub = project
diff --git a/sbt/src/sbt-test/nio/reload/changes/ScalafmtVersion.scala b/sbt/src/sbt-test/nio/reload/changes/ScalafmtVersion.scala
new file mode 100644
index 000000000..42ad05178
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/changes/ScalafmtVersion.scala
@@ -0,0 +1,3 @@
+object ScalafmtVersion {
+  val value = "2.0.4"
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/reload/changes/broken.sbt b/sbt/src/sbt-test/nio/reload/changes/broken.sbt
new file mode 100644
index 000000000..be157511f
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/changes/broken.sbt
@@ -0,0 +1,16 @@
+import scala.concurrent.duration._
+
+val foo = inputKey[Unit]("broken task")
+foo := { throw new IllegalStateException("foo") }
+
+val exists = inputKey[Unit]("check that the file was written")
+exists := {
+  val filename = Def.spaceDelimited("").parsed.head
+  assert((baseDirectory.value / filename).exists)
+}
+
+Global / onChangedBuildSource := ReloadOnSourceChanges
+
+ThisBuild / checkBuildSources / pollInterval := 0.seconds
+
+val sub = project
diff --git a/sbt/src/sbt-test/nio/reload/changes/sub.sbt b/sbt/src/sbt-test/nio/reload/changes/sub.sbt
new file mode 100644
index 000000000..4797974c4
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/changes/sub.sbt
@@ -0,0 +1,5 @@
+import scala.concurrent.duration._
+
+libraryDependencies += "org.scala-sbt" % "sbt" % "1.3.0"
+
+ThisBuild / checkBuildSources / pollInterval := 0.seconds
diff --git a/sbt/src/sbt-test/nio/reload/changes/working.sbt b/sbt/src/sbt-test/nio/reload/changes/working.sbt
new file mode 100644
index 000000000..910bfa622
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/changes/working.sbt
@@ -0,0 +1,19 @@
+import scala.concurrent.duration._
+
+val foo = inputKey[Unit]("working task")
+foo := {
+  val filename = Def.spaceDelimited("").parsed.head
+  IO.touch(baseDirectory.value / filename)
+}
+
+val exists = inputKey[Unit]("check that the file was written")
+exists := {
+  val filename = Def.spaceDelimited("").parsed.head
+  assert((baseDirectory.value / filename).exists)
+}
+
+Global / onChangedBuildSource := ReloadOnSourceChanges
+
+ThisBuild / checkBuildSources / pollInterval := 0.seconds
+
+val sub = project
diff --git a/sbt/src/sbt-test/nio/reload/project/plugins.sbt b/sbt/src/sbt-test/nio/reload/project/plugins.sbt
new file mode 100644
index 000000000..99c853f12
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/project/plugins.sbt
@@ -0,0 +1,8 @@
+libraryDependencies ++= {
+  if (ScalafmtVersion.value == "2.0.4") {
+    val sbtV = (sbtBinaryVersion in pluginCrossBuild).value
+    val scalaV = (scalaBinaryVersion in update).value
+    val dep = "org.scalameta" % "sbt-scalafmt" % ScalafmtVersion.value
+    sbt.Defaults.sbtPluginExtra(dep, sbtV, scalaV) :: Nil
+  } else Nil
+}
diff --git a/sbt/src/sbt-test/nio/reload/project/project/ScalafmtVersion.scala b/sbt/src/sbt-test/nio/reload/project/project/ScalafmtVersion.scala
new file mode 100644
index 000000000..d21e33494
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/project/project/ScalafmtVersion.scala
@@ -0,0 +1,3 @@
+object ScalafmtVersion {
+  val value = "2.0.3"
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/reload/sub/build.sbt b/sbt/src/sbt-test/nio/reload/sub/build.sbt
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/nio/reload/sub/src/main/scala/Test.scala b/sbt/src/sbt-test/nio/reload/sub/src/main/scala/Test.scala
new file mode 100644
index 000000000..405e020be
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/sub/src/main/scala/Test.scala
@@ -0,0 +1,3 @@
+object Test {
+  val x = sbt.Keys
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/nio/reload/test b/sbt/src/sbt-test/nio/reload/test
new file mode 100644
index 000000000..6da7b6750
--- /dev/null
+++ b/sbt/src/sbt-test/nio/reload/test
@@ -0,0 +1,37 @@
+> show Global / checkBuildSources / pollInterval
+
+> foo bar
+
+> exists bar
+
+$ copy-file changes/broken.sbt build.sbt
+
+-> foo baz
+
+-> exists baz
+
+$ copy-file changes/working.sbt build.sbt
+
+> foo baz
+
+> exists baz
+
+> foo foo; reload
+
+> exists foo
+
+-> compile
+
+$ copy-file changes/sub.sbt sub/build.sbt
+
+> compile
+
+-> scalafmt
+
+$ copy-file changes/ScalafmtVersion.scala project/project/ScalafmtVersion.scala
+
+> scalafmt
+
+$ delete project/plugins.sbt
+
+-> scalafmt
diff --git a/sbt/src/sbt-test/nio/transform/build.sbt b/sbt/src/sbt-test/nio/transform/build.sbt
new file mode 100644
index 000000000..9aba3478f
--- /dev/null
+++ b/sbt/src/sbt-test/nio/transform/build.sbt
@@ -0,0 +1,31 @@
+import complete.DefaultParsers._
+import complete.Parser
+import sbt.Def.Initialize
+
+val keep = taskKey[Int]("")
+val checkKeep = inputKey[Unit]("")
+
+keep := (getPrevious(keep) map { case None => 3; case Some(x) => x + 1 } keepAs keep).value
+checkKeep := inputCheck((ctx, s) => Space ~> str(getFromContext(keep, ctx, s))).evaluated
+
+val foo = AttributeKey[Int]("foo")
+val transform = taskKey[StateTransform]("")
+transform := {
+  keep.value
+  StateTransform(_.put(foo, 1))
+}
+
+def inputCheck[T](f: (ScopedKey[_], State) => Parser[T]): Initialize[InputTask[Unit]] =
+  InputTask(resolvedScoped(ctx => (s: State) => f(ctx, s)))(dummyTask)
+
+val checkTransform = taskKey[Unit]("")
+checkTransform := {
+  assert(state.value.get(foo).contains(1))
+}
+
+def dummyTask: Any => Initialize[Task[Unit]] =
+  (_: Any) =>
+    maxErrors map { _ =>
+      ()
+    }
+def str(o: Option[Int]) = o match { case None => "blue"; case Some(i) => i.toString }
diff --git a/sbt/src/sbt-test/nio/transform/test b/sbt/src/sbt-test/nio/transform/test
new file mode 100644
index 000000000..f1acac98d
--- /dev/null
+++ b/sbt/src/sbt-test/nio/transform/test
@@ -0,0 +1,13 @@
+> checkKeep blue
+
+-> checkTransform
+
+> transform
+
+> checkKeep 3
+
+> checkTransform
+
+> transform
+
+> checkKeep 4
\ No newline at end of file
diff --git a/sbt/src/sbt-test/package/lazy-name/test b/sbt/src/sbt-test/package/lazy-name/test
index ce4ba25f0..9afdadb29 100644
--- a/sbt/src/sbt-test/package/lazy-name/test
+++ b/sbt/src/sbt-test/package/lazy-name/test
@@ -4,19 +4,19 @@
 # much purpose other than checking that the 'set' command
 # re-evaluates the project data.
 
-> 'set name := "lazy-package-name"'
+> set name := "lazy-package-name"
 > set crossPaths := false
 
-> 'set version := "0.1.1"'
+> set version := "0.1.1"
 > package
-$ exists "target/lazy-package-name-0.1.1.jar"
+$ exists target/lazy-package-name-0.1.1.jar
 > clean
 
-> 'set version := "0.1.2"'
+> set version := "0.1.2"
 > package
-$ exists "target/lazy-package-name-0.1.2.jar"
+$ exists target/lazy-package-name-0.1.2.jar
 > clean
 
-> 'set version := "0.1.3"'
+> set version := "0.1.3"
 > package
-$ exists "target/lazy-package-name-0.1.3.jar"
+$ exists target/lazy-package-name-0.1.3.jar
diff --git a/sbt/src/sbt-test/package/manifest/build.sbt b/sbt/src/sbt-test/package/manifest/build.sbt
index e12b8db8d..73ac1427d 100644
--- a/sbt/src/sbt-test/package/manifest/build.sbt
+++ b/sbt/src/sbt-test/package/manifest/build.sbt
@@ -1,5 +1,5 @@
-	import java.util.jar.{Attributes, Manifest}
-	import Path.makeString
+import java.util.jar.{Attributes, Manifest}
+import Path.makeString
 
 name := "Jar Manifest Test"
 
@@ -9,12 +9,11 @@ crossPaths := false
 
 mainClass := Some("jartest.Main")
 
-packageOptions in (Compile, packageBin) := ((packageOptions in (Compile, packageBin), scalaInstance) map { (opts, si) =>
-	def manifestExtra =
-	{
-		val mf = new Manifest
-		mf.getMainAttributes.put(Attributes.Name.CLASS_PATH, makeString(si.libraryJar :: Nil) )
-		mf
-	}
-	opts :+ Package.JarManifest(manifestExtra)
-}).value
+packageOptions in (Compile, packageBin) := {
+  def manifestExtra = {
+    val mf = new Manifest
+    mf.getMainAttributes.put(Attributes.Name.CLASS_PATH, makeString(scalaInstance.value.libraryJars))
+    mf
+  }
+  (packageOptions in (Compile, packageBin)).value :+ Package.JarManifest(manifestExtra)
+}
diff --git a/sbt/src/sbt-test/package/manifest/test b/sbt/src/sbt-test/package/manifest/test
index 20c80ee3c..e77e9b799 100644
--- a/sbt/src/sbt-test/package/manifest/test
+++ b/sbt/src/sbt-test/package/manifest/test
@@ -1,4 +1,4 @@
 > package
-$ exists "./target/jar-manifest-test-0.2.jar"
-$ exec java -jar "./target/jar-manifest-test-0.2.jar"
+$ exists ./target/jar-manifest-test-0.2.jar
+$ exec java -jar ./target/jar-manifest-test-0.2.jar
 > run
\ No newline at end of file
diff --git a/sbt/src/sbt-test/package/mappings/build.sbt b/sbt/src/sbt-test/package/mappings/build.sbt
new file mode 100644
index 000000000..dc930b4ae
--- /dev/null
+++ b/sbt/src/sbt-test/package/mappings/build.sbt
@@ -0,0 +1,17 @@
+name := "Mappings Test"
+
+version := "0.2"
+
+mappings in (Compile, packageBin) ++= {
+  val test = file("test")
+  Seq(
+    test -> "test1",
+    test -> "test1",
+    test -> "test2"
+  )
+}
+
+lazy val unzipPackage = taskKey[Unit]("extract jar file")
+unzipPackage := {
+  IO.unzip((packageBin in Compile).value, target.value / "extracted")
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/package/mappings/test b/sbt/src/sbt-test/package/mappings/test
new file mode 100644
index 000000000..f95f9bb76
--- /dev/null
+++ b/sbt/src/sbt-test/package/mappings/test
@@ -0,0 +1,3 @@
+> unzipPackage
+$ exists target/extracted/test2
+$ exists target/extracted/test1
diff --git a/sbt/src/sbt-test/package/resources/build.sbt b/sbt/src/sbt-test/package/resources/build.sbt
index a1942fed7..51f5865e6 100644
--- a/sbt/src/sbt-test/package/resources/build.sbt
+++ b/sbt/src/sbt-test/package/resources/build.sbt
@@ -1,16 +1,17 @@
+import Path.makeString
+
 name := "Main Resources Test"
 
 version := "0.1"
 
 crossPaths := false
 
-packageOptions := ((packageOptions, scalaInstance) map { (opts, si) =>
-	def manifestExtra =
-	{
-		import java.util.jar._
-		val mf = new Manifest
-		mf.getMainAttributes.put(Attributes.Name.CLASS_PATH, si.libraryJar.getAbsolutePath)
-		mf
-	}
-	Package.JarManifest(manifestExtra) +: opts
-}).value
+packageOptions := {
+  def manifestExtra = {
+    import java.util.jar._
+    val mf = new Manifest
+    mf.getMainAttributes.put(Attributes.Name.CLASS_PATH, makeString(scalaInstance.value.libraryJars))
+    mf
+  }
+  Package.JarManifest(manifestExtra) +: packageOptions.value
+}
diff --git a/sbt/src/sbt-test/package/resources/test b/sbt/src/sbt-test/package/resources/test
index aa29e4d8c..fefcded95 100644
--- a/sbt/src/sbt-test/package/resources/test
+++ b/sbt/src/sbt-test/package/resources/test
@@ -10,7 +10,7 @@
 
 # This should fail because sbt should include the resource in the jar but it won't have the right
 # directory structure
--$ exec java -jar "./target/main-resources-test-0.1.jar"
+-$ exec java -jar ./target/main-resources-test-0.1.jar
 
 # Give the resource the right directory structure
 $ mkdir src/main/resources/jartest
@@ -27,4 +27,4 @@ $ delete src/main/resources/main_resource_test
 > package
 
 # This should succeed because sbt should include the resource in the jar with the right directory structure
-$ exec java -jar "./target/main-resources-test-0.1.jar"
\ No newline at end of file
+$ exec java -jar ./target/main-resources-test-0.1.jar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/app/src/main/scala/hello/Hello.scala b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/app/src/main/scala/hello/Hello.scala
new file mode 100644
index 000000000..d92d9bb84
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/app/src/main/scala/hello/Hello.scala
@@ -0,0 +1,14 @@
+package hello
+
+object Hello {
+  def main(args: Array[String]): Unit = {
+    val dotty: Int | String = "dotty"
+
+    val y = 5 / 0 // error
+    100 + 6 / 0 // error
+    6L / 0L // error
+    val z = 7 / 0.0 // error
+
+    println(s"Hello $dotty!")
+  }
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/appOK/src/main/scala/hello/Hello.scala b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/appOK/src/main/scala/hello/Hello.scala
new file mode 100644
index 000000000..c67735762
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/appOK/src/main/scala/hello/Hello.scala
@@ -0,0 +1,8 @@
+package hello
+
+object Hello {
+  def main(args: Array[String]): Unit = {
+    val dotty: Int | String = "dotty"
+    println(s"Hello $dotty!")
+  }
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/build.sbt b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/build.sbt
new file mode 100644
index 000000000..8aabedac8
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/build.sbt
@@ -0,0 +1,29 @@
+ThisBuild / scalaVersion := "3.0.0-M1"
+
+lazy val plugin = project
+  .in(file("plugin"))
+  .settings(
+    name := "dividezero",
+    version := "0.0.1",
+    organization := "ch.epfl.lamp",
+
+    scalacOptions ++= Seq(
+      "-language:implicitConversions"
+    ),
+
+    libraryDependencies ++= Seq(
+      "ch.epfl.lamp" %% "dotty-compiler" % scalaVersion.value % "provided"
+    )
+  )
+
+lazy val app = project
+  .in(file("app"))
+  .settings(
+    scalaVersion := dottyVersion
+  )
+
+lazy val appOk = project
+  .in(file("appOk"))
+  .settings(
+    scalaVersion := dottyVersion
+  )
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/changes/build.sbt b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/changes/build.sbt
new file mode 100644
index 000000000..584adf234
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/changes/build.sbt
@@ -0,0 +1,28 @@
+lazy val dottyVersion = "3.0.0-M1"
+
+lazy val plugin = project
+  .in(file("plugin"))
+  .settings(
+    name := "dividezero",
+    version := "0.0.1",
+    organization := "ch.epfl.lamp",
+    scalaVersion := dottyVersion,
+
+    libraryDependencies ++= Seq(
+      "ch.epfl.lamp" %% "dotty" % scalaVersion.value % "provided"
+    )
+  )
+
+lazy val app = project
+  .in(file("app"))
+  .settings(
+    scalaVersion := dottyVersion,
+    addCompilerPlugin("ch.epfl.lamp" %% "dividezero" % "0.0.1")
+  )
+
+lazy val appOk = project
+  .in(file("appOk"))
+  .settings(
+    scalaVersion := dottyVersion,
+    addCompilerPlugin("ch.epfl.lamp" %% "dividezero" % "0.0.1")
+  )
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/disabled b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/disabled
new file mode 100644
index 000000000..35d9f1be8
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/disabled
@@ -0,0 +1,17 @@
+# Should compile OK without the plugin
+> app/compile
+
+# Publish plugin locally
+> plugin/publishLocal
+
+# Enable plugin
+$ copy-file changes/build.sbt build.sbt
+> reload
+
+# Should compile with the plugin
+> clean
+> appOk/compile
+
+# Should NOT compile with the plugin
+> clean
+-> app/compile
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/plugin/DivideZero.scala b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/plugin/DivideZero.scala
new file mode 100644
index 000000000..feadac221
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/plugin/DivideZero.scala
@@ -0,0 +1,41 @@
+package dividezero
+
+import dotty.tools.dotc._
+import core._
+import Contexts.Context
+import plugins._
+import Phases.Phase
+import ast.tpd
+import transform.MegaPhase.MiniPhase
+import Decorators._
+import Symbols.Symbol
+import Constants.Constant
+import transform.{Pickler, Staging}
+
+/** Compiler plugin that emits an error when compiling a division by zero */
+class DivideZero extends PluginPhase with StandardPlugin {
+  val name: String = "divideZero"
+  override val description: String = "divide zero check"
+
+  val phaseName = name
+
+  override val runsAfter = Set(Staging.name)
+  override val runsBefore = Set(Pickler.name)
+
+  def init(options: List[String]): List[PluginPhase] = this :: Nil
+
+  private def isNumericDivide(sym: Symbol)(implicit ctx: Context): Boolean = {
+    def test(tpe: String): Boolean =
+      (sym.owner eq ctx.requiredClass(tpe)) && sym.name.show == "/"
+
+    test("scala.Int") || test("scala.Long") || test("scala.Short") || test("scala.Float") || test("scala.Double")
+  }
+
+  override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = tree match {
+    case tpd.Apply(fun, tpd.Literal(Constants.Constant(v)) :: Nil) if isNumericDivide(fun.symbol) && v == 0 =>
+      ctx.error("divide by zero", tree.sourcePos)
+      tpd.Literal(Constant(0))
+    case _ =>
+      tree
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/plugin/src/main/resources/plugin.properties b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/plugin/src/main/resources/plugin.properties
new file mode 100644
index 000000000..f903a0f32
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/plugin/src/main/resources/plugin.properties
@@ -0,0 +1 @@
+pluginClass=dividezero.DivideZero
diff --git a/sbt/src/sbt-test/plugins/dotty-compiler-plugin/project/plugins.sbt b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/project/plugins.sbt
new file mode 100644
index 000000000..83a3da10f
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-compiler-plugin/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.4.6")
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/app/src/main/scala/app/Main.scala b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/app/src/main/scala/app/Main.scala
new file mode 100644
index 000000000..e3a0fa2ce
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/app/src/main/scala/app/Main.scala
@@ -0,0 +1,9 @@
+package app
+
+import mylib._
+
+object Main {
+  def main(args: Array[String]): Unit = {
+    println(MyLib.square(5))
+  }
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt
new file mode 100644
index 000000000..9e2883f48
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt
@@ -0,0 +1,15 @@
+ThisBuild / scalaVersion := "2.13.4"
+ThisBuild / scalacOptions += "-Ytasty-reader"
+
+lazy val scala3code = project
+  .enablePlugins(ScalaJSPlugin)
+  .settings(scalaVersion := "3.0.0-M1")
+
+lazy val app = project
+  .enablePlugins(ScalaJSPlugin)
+  .dependsOn(scala3code)
+  .settings(
+    libraryDependencies ~= (_.filterNot(_.name.contains("scalajs-compiler"))),
+    addCompilerPlugin("org.scala-js" % "scalajs-compiler_2.13.4" % scalaJSVersion),
+    scalaJSUseMainModuleInitializer := true,
+  )
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/project/plugins.sbt b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/project/plugins.sbt
new file mode 100644
index 000000000..f0dfae12d
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/project/plugins.sbt
@@ -0,0 +1,2 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.4.6")
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.3.0")
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/scala3code/src/main/scala/mylib/MyLib.scala b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/scala3code/src/main/scala/mylib/MyLib.scala
new file mode 100644
index 000000000..ae2f3af75
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/scala3code/src/main/scala/mylib/MyLib.scala
@@ -0,0 +1,5 @@
+package mylib
+
+object MyLib {
+  def square(x: Int): Int = x * x
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/test b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/test
new file mode 100644
index 000000000..63092ffa4
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich-sjs/test
@@ -0,0 +1 @@
+> app/run
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich/bar-app/D.scala b/sbt/src/sbt-test/plugins/dotty-sandwich/bar-app/D.scala
new file mode 100644
index 000000000..b937ae06c
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich/bar-app/D.scala
@@ -0,0 +1,5 @@
+package example
+
+object D {
+  val x = C.x
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich/bar-core/C.scala b/sbt/src/sbt-test/plugins/dotty-sandwich/bar-core/C.scala
new file mode 100644
index 000000000..4d4fcc6df
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich/bar-core/C.scala
@@ -0,0 +1,5 @@
+package example
+
+object C {
+  val x = 1
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich/build.sbt b/sbt/src/sbt-test/plugins/dotty-sandwich/build.sbt
new file mode 100644
index 000000000..d6b4a9a34
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich/build.sbt
@@ -0,0 +1,23 @@
+ThisBuild / scalaVersion := "3.0.0-M1"
+ThisBuild / scalacOptions += "-Ytasty-reader"
+
+lazy val scala213 = "2.13.4"
+
+lazy val root = (project in file("."))
+  .aggregate(fooApp, fooCore, barApp, barCore)
+
+lazy val fooApp = (project in file("foo-app"))
+  .dependsOn(fooCore)
+
+lazy val fooCore = (project in file("foo-core"))
+  .settings(
+    scalaVersion := scala213
+  )
+
+lazy val barApp = (project in file("bar-app"))
+  .dependsOn(barCore)
+  .settings(
+    scalaVersion := scala213
+  )
+
+lazy val barCore = (project in file("bar-core"))
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich/foo-app/B.scala b/sbt/src/sbt-test/plugins/dotty-sandwich/foo-app/B.scala
new file mode 100644
index 000000000..ed82c07d1
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich/foo-app/B.scala
@@ -0,0 +1,5 @@
+package example
+
+object B {
+  val x = A.x
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich/foo-core/A.scala b/sbt/src/sbt-test/plugins/dotty-sandwich/foo-core/A.scala
new file mode 100644
index 000000000..be4b82a9f
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich/foo-core/A.scala
@@ -0,0 +1,5 @@
+package example
+
+object A {
+  val x = 1
+}
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich/project/plugins.sbt b/sbt/src/sbt-test/plugins/dotty-sandwich/project/plugins.sbt
new file mode 100644
index 000000000..83a3da10f
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.4.6")
diff --git a/sbt/src/sbt-test/plugins/dotty-sandwich/test b/sbt/src/sbt-test/plugins/dotty-sandwich/test
new file mode 100644
index 000000000..19ccc5787
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty-sandwich/test
@@ -0,0 +1,3 @@
+> fooApp/compile
+
+> barApp/compile
diff --git a/sbt/src/sbt-test/plugins/dotty/LICENSE b/sbt/src/sbt-test/plugins/dotty/LICENSE
new file mode 100644
index 000000000..728844ee3
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2015 The dotty-example-project contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/sbt/src/sbt-test/plugins/dotty/README.md b/sbt/src/sbt-test/plugins/dotty/README.md
new file mode 100644
index 000000000..e476c5c1d
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/README.md
@@ -0,0 +1 @@
+Cut-n-pasted from https://github.com/lampepfl/dotty-example-project/tree/a753b14e281bbaa6c69f26298913ad6feba969c7
diff --git a/sbt/src/sbt-test/plugins/dotty/build.sbt b/sbt/src/sbt-test/plugins/dotty/build.sbt
new file mode 100644
index 000000000..e80bfb07c
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/build.sbt
@@ -0,0 +1 @@
+ThisBuild / scalaVersion := "3.0.0-M1"
diff --git a/sbt/src/sbt-test/plugins/dotty/project/build.properties b/sbt/src/sbt-test/plugins/dotty/project/build.properties
new file mode 100644
index 000000000..16dc090c5
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/project/build.properties
@@ -0,0 +1,3 @@
+# sbt-coursier scripted tests: required, as we default to sbt 1.0.3,
+# but sbt-dotty requires sbt >= 1.2.7
+sbt.version=1.2.7
diff --git a/sbt/src/sbt-test/plugins/dotty/project/plugins.sbt b/sbt/src/sbt-test/plugins/dotty/project/plugins.sbt
new file mode 100644
index 000000000..83a3da10f
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.4.6")
diff --git a/sbt/src/sbt-test/plugins/dotty/src/main/scala-3/Main.scala b/sbt/src/sbt-test/plugins/dotty/src/main/scala-3/Main.scala
new file mode 100644
index 000000000..8a44ae4ef
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/src/main/scala-3/Main.scala
@@ -0,0 +1,16 @@
+
+object Main {
+
+  def main(args: Array[String]): Unit = {
+
+    runExample("Trait Params")(TraitParams.test)
+
+  }
+
+  private def runExample(name: String)(f: => Unit) = {
+    println(Console.MAGENTA + s"$name example:" + Console.RESET)
+    f
+    println()
+  }
+
+}
diff --git a/sbt/src/sbt-test/plugins/dotty/src/main/scala-3/TraitParams.scala b/sbt/src/sbt-test/plugins/dotty/src/main/scala-3/TraitParams.scala
new file mode 100644
index 000000000..5d4409971
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/src/main/scala-3/TraitParams.scala
@@ -0,0 +1,21 @@
+/**
+  * Trait Parameters: https://dotty.epfl.ch/docs/reference/other-new-features/trait-parameters.html
+  */
+object TraitParams {
+
+  trait Base(val msg: String)
+  class A extends Base("Hello")
+  class B extends Base("Dotty!")
+
+  // Union types only exist in Dotty, so there's no chance that this will accidentally be compiled with Scala 2
+  private def printMessages(msgs: (A | B)*) = println(msgs.map(_.msg).mkString(" "))
+
+  def test: Unit = {
+
+    printMessages(new A, new B)
+
+    // Sanity check the classpath: this won't run if the dotty jar is not present.
+    val x: Int => Int = z => z
+    x(1)
+  }
+}
diff --git a/sbt/src/sbt-test/plugins/dotty/test b/sbt/src/sbt-test/plugins/dotty/test
new file mode 100644
index 000000000..62ea636c1
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/dotty/test
@@ -0,0 +1 @@
+> run
diff --git a/sbt/src/sbt-test/plugins/hydra/Hello.scala b/sbt/src/sbt-test/plugins/hydra/Hello.scala
new file mode 100644
index 000000000..98e54159b
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/hydra/Hello.scala
@@ -0,0 +1,5 @@
+package example
+
+object Hello extends App {
+  println("Hello!")
+}
diff --git a/sbt/src/sbt-test/plugins/hydra/build.sbt b/sbt/src/sbt-test/plugins/hydra/build.sbt
new file mode 100644
index 000000000..2324a2515
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/hydra/build.sbt
@@ -0,0 +1,12 @@
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val check = taskKey[Unit]("")
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "hello",
+    check := {
+      val rs = scalaCompilerBridgeResolvers.value
+      assert(rs.exists(r => r.name == "Triplequote Maven Releases"))
+    }
+  )
diff --git a/sbt/src/sbt-test/plugins/hydra/project/HydraPlugin.scala b/sbt/src/sbt-test/plugins/hydra/project/HydraPlugin.scala
new file mode 100644
index 000000000..68d4ffa99
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/hydra/project/HydraPlugin.scala
@@ -0,0 +1,23 @@
+package sbtmyplugin
+
+import sbt._
+import sbt.Keys._
+
+object HydraPlugin extends AutoPlugin {
+  override def requires: Plugins = plugins.JvmPlugin
+  override def trigger: PluginTrigger = allRequirements
+
+  override lazy val projectSettings = Seq(
+    resolvers += "Triplequote Maven Releases" at "https://repo.triplequote.com/artifactory/libs-release/",
+  ) ++ inConfig(Compile)(compileSettings) ++ inConfig(Test)(compileSettings)
+
+  private lazy val compileSettings: Seq[Def.Setting[_]] = inTask(compile)(compileInputsSettings)
+  
+  private def compileInputsSettings: Seq[Setting[_]] = Seq(
+    scalaCompilerBridgeSource := {
+      ModuleID("com.triplequote", "hydra-bridge_1_0", "2.1.4")
+        .withConfigurations(Some(Configurations.Compile.name))
+        .sources()
+    }
+  )
+}
diff --git a/sbt/src/sbt-test/plugins/hydra/test b/sbt/src/sbt-test/plugins/hydra/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/hydra/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/plugins/play-watch/app/Controller.scala b/sbt/src/sbt-test/plugins/play-watch/app/Controller.scala
new file mode 100644
index 000000000..d181c83af
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/play-watch/app/Controller.scala
@@ -0,0 +1,2 @@
+object Controller {
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/plugins/play-watch/build.sbt b/sbt/src/sbt-test/plugins/play-watch/build.sbt
new file mode 100644
index 000000000..b66f88d87
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/play-watch/build.sbt
@@ -0,0 +1,3 @@
+enablePlugins(PlayScala)
+
+watchOnIteration := { (_, _, _) => Watch.CancelWatch }
diff --git a/sbt/src/sbt-test/plugins/play-watch/project/plugins.sbt b/sbt/src/sbt-test/plugins/play-watch/project/plugins.sbt
new file mode 100644
index 000000000..05e01d6e5
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/play-watch/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.7.3")
\ No newline at end of file
diff --git a/sbt/src/sbt-test/plugins/play-watch/test b/sbt/src/sbt-test/plugins/play-watch/test
new file mode 100644
index 000000000..693209c25
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/play-watch/test
@@ -0,0 +1 @@
+> ~compile
diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/build.sbt b/sbt/src/sbt-test/plugins/sbt-native-packager/build.sbt
new file mode 100644
index 000000000..8f8aa3c80
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/sbt-native-packager/build.sbt
@@ -0,0 +1,20 @@
+ThisBuild / scalaVersion := "2.12.12"
+
+name := "hello"
+enablePlugins(JavaAppPackaging)
+
+lazy val check = taskKey[Unit]("")
+
+check := {
+  val cmd = "target/universal/stage/bin/hello"
+  val cmd0 =
+    if (sys.props("os.name").toLowerCase(java.util.Locale.ROOT).contains("windows"))
+      cmd + ".bat"
+    else
+      cmd
+  val b = new ProcessBuilder(cmd0)
+  b.inheritIO()
+  val p = b.start()
+  val retCode = p.waitFor()
+  assert(retCode == 0, s"Command $cmd returned code $retCode")
+}
diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt b/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt
new file mode 100644
index 000000000..414d83d34
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.20")
diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/src/main/scala/Main.scala b/sbt/src/sbt-test/plugins/sbt-native-packager/src/main/scala/Main.scala
new file mode 100644
index 000000000..61295349d
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/sbt-native-packager/src/main/scala/Main.scala
@@ -0,0 +1,6 @@
+import java.io.File
+import java.nio.file.Files
+
+object Main extends App {
+  Files.write(new File("output").toPath, "OK".getBytes("UTF-8"))
+}
diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/test b/sbt/src/sbt-test/plugins/sbt-native-packager/test
new file mode 100644
index 000000000..bb563a74f
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/sbt-native-packager/test
@@ -0,0 +1,5 @@
+$ delete output
+> stage
+> check
+$ exists output
+$ delete output
diff --git a/sbt/src/sbt-test/plugins/scala-js-macro/build.sbt b/sbt/src/sbt-test/plugins/scala-js-macro/build.sbt
new file mode 100644
index 000000000..ff4eb16f3
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js-macro/build.sbt
@@ -0,0 +1,13 @@
+ThisBuild / scalaVersion := "2.13.1"
+
+lazy val root = (project in file("."))
+  .aggregate(macroProvider, macroClient)
+
+lazy val macroProvider = (project in file("macro-provider"))
+  .settings(
+    libraryDependencies += scalaVersion("org.scala-lang" % "scala-reflect" % _ ).value
+  )
+
+lazy val macroClient = (project in file("macro-client"))
+  .enablePlugins(ScalaJSPlugin)
+  .dependsOn(macroProvider)
diff --git a/sbt/src/sbt-test/plugins/scala-js-macro/macro-client/Client.scala b/sbt/src/sbt-test/plugins/scala-js-macro/macro-client/Client.scala
new file mode 100644
index 000000000..151d7d267
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js-macro/macro-client/Client.scala
@@ -0,0 +1,5 @@
+package macros
+
+object Client {
+  Provider.tree(0)
+}
diff --git a/sbt/src/sbt-test/plugins/scala-js-macro/macro-provider/Provider.scala b/sbt/src/sbt-test/plugins/scala-js-macro/macro-provider/Provider.scala
new file mode 100644
index 000000000..ee55bfdd3
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js-macro/macro-provider/Provider.scala
@@ -0,0 +1,13 @@
+package macros
+
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox
+import java.io.File
+
+object Provider {
+  def tree(args: Any): File = macro treeImpl
+  def treeImpl(c: blackbox.Context)(args: c.Expr[Any]): c.Expr[File] = {
+    import c.universe._
+    c.Expr(q"""new java.io.File(".")""")
+  }
+}
diff --git a/sbt/src/sbt-test/plugins/scala-js-macro/macro-provider/changes/Provider.scala b/sbt/src/sbt-test/plugins/scala-js-macro/macro-provider/changes/Provider.scala
new file mode 100644
index 000000000..92842db5d
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js-macro/macro-provider/changes/Provider.scala
@@ -0,0 +1,8 @@
+package macros
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox
+
+object Provider {
+  def tree(args: Any): Any = macro treeImpl
+  def treeImpl(c: blackbox.Context)(args: c.Expr[Any]) = sys.error("no macro for you!")
+}
diff --git a/sbt/src/sbt-test/plugins/scala-js-macro/project/plugins.sbt b/sbt/src/sbt-test/plugins/scala-js-macro/project/plugins.sbt
new file mode 100644
index 000000000..8365c11cc
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js-macro/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.0.0")
diff --git a/sbt/src/sbt-test/plugins/scala-js-macro/test b/sbt/src/sbt-test/plugins/scala-js-macro/test
new file mode 100644
index 000000000..7a3d278a8
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js-macro/test
@@ -0,0 +1,16 @@
+# Marked as pending due to StackOverflow error, see
+# https://github.com/sbt/sbt/issues/1544 for details
+
+> compile
+
+# replace macro with one that throws an error
+
+$ copy-file macro-provider/changes/Provider.scala macro-provider/Provider.scala
+
+> macroProvider/compile
+
+-> macroClient/compile
+
+> clean
+
+-> compile
diff --git a/sbt/src/sbt-test/plugins/scala-js/build.sbt b/sbt/src/sbt-test/plugins/scala-js/build.sbt
new file mode 100644
index 000000000..f8c7a3109
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js/build.sbt
@@ -0,0 +1,7 @@
+ThisBuild / scalaVersion := "2.13.1"
+
+lazy val root = (project in file("."))
+  .enablePlugins(ScalaJSPlugin)
+  .settings(
+    libraryDependencies += "org.scala-js" %%% "scalajs-java-time" % "1.0.0"
+  )
diff --git a/sbt/src/sbt-test/plugins/scala-js/project/plugins.sbt b/sbt/src/sbt-test/plugins/scala-js/project/plugins.sbt
new file mode 100644
index 000000000..8365c11cc
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.0.0")
diff --git a/sbt/src/sbt-test/plugins/scala-js/test b/sbt/src/sbt-test/plugins/scala-js/test
new file mode 100644
index 000000000..103bd8d2f
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/scala-js/test
@@ -0,0 +1 @@
+> update
diff --git a/sbt/src/sbt-test/plugins/twirl/build.sbt b/sbt/src/sbt-test/plugins/twirl/build.sbt
new file mode 100644
index 000000000..bee7bb4cf
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/twirl/build.sbt
@@ -0,0 +1,12 @@
+
+lazy val check = taskKey[Unit]("")
+
+lazy val root = (project in file("."))
+  .enablePlugins(TwirlPlugin)
+  .settings(
+    check := {
+      val templates = (Compile / twirlCompileTemplates / sources).value
+      assert(templates.nonEmpty)
+      assert(!templates.exists(_.toString.contains("hidden")))
+    }
+  )
diff --git a/sbt/src/sbt-test/plugins/twirl/project/TwirlPlugin.scala b/sbt/src/sbt-test/plugins/twirl/project/TwirlPlugin.scala
new file mode 100644
index 000000000..5911cdfcc
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/twirl/project/TwirlPlugin.scala
@@ -0,0 +1,29 @@
+import sbt._
+import Keys._
+
+object TwirlPlugin extends AutoPlugin {
+  override def requires = sbt.plugins.JvmPlugin
+  override def trigger = noTrigger
+
+  object autoImport {
+    val twirlCompileTemplates = taskKey[Seq[File]]("Compile twirl templates into scala source files")
+  }
+
+  override def projectSettings: Seq[Setting[_]] =
+    inConfig(Compile)(twirlSettings) ++
+        inConfig(Test)(twirlSettings)
+
+  import autoImport._
+
+  def twirlSettings: Seq[Setting[_]] =  Seq(
+    twirlCompileTemplates / includeFilter := "*.scala.*",
+    twirlCompileTemplates / excludeFilter := HiddenFileFilter,
+    twirlCompileTemplates / sourceDirectories := Seq(sourceDirectory.value / "twirl"),
+
+    twirlCompileTemplates / sources := Defaults.collectFiles(
+      twirlCompileTemplates / sourceDirectories,
+      twirlCompileTemplates / includeFilter,
+      twirlCompileTemplates / excludeFilter
+    ).value
+  )
+}
diff --git a/sbt/src/sbt-test/plugins/twirl/src/main/twirl/.hidden/fake.scala.twirl b/sbt/src/sbt-test/plugins/twirl/src/main/twirl/.hidden/fake.scala.twirl
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/plugins/twirl/src/main/twirl/play/routes/forwardsRouter.scala.twirl b/sbt/src/sbt-test/plugins/twirl/src/main/twirl/play/routes/forwardsRouter.scala.twirl
new file mode 100644
index 000000000..8db5bd943
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/twirl/src/main/twirl/play/routes/forwardsRouter.scala.twirl
@@ -0,0 +1,3 @@
+@import play.routes.compiler._
+@import play.routes.compiler.templates._
+@import InjectedRoutesGenerator.Dependency
diff --git a/sbt/src/sbt-test/plugins/twirl/test b/sbt/src/sbt-test/plugins/twirl/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/twirl/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/plugins/unidoc/build.sbt b/sbt/src/sbt-test/plugins/unidoc/build.sbt
new file mode 100644
index 000000000..3aa46422f
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/unidoc/build.sbt
@@ -0,0 +1,5 @@
+scalaVersion := "2.12.1"
+scalacOptions += "-Xfatal-warnings" // required for the test
+
+enablePlugins(ScalaUnidocPlugin)
+autoAPIMappings := true
diff --git a/sbt/src/sbt-test/plugins/unidoc/project/extra.sbt b/sbt/src/sbt-test/plugins/unidoc/project/extra.sbt
new file mode 100644
index 000000000..ade7d89a5
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/unidoc/project/extra.sbt
@@ -0,0 +1 @@
+addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.4.2")
diff --git a/sbt/src/sbt-test/plugins/unidoc/src/main/scala/Foo.scala b/sbt/src/sbt-test/plugins/unidoc/src/main/scala/Foo.scala
new file mode 100644
index 000000000..b5ba8323e
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/unidoc/src/main/scala/Foo.scala
@@ -0,0 +1,3 @@
+
+/** Default instances for Scala's [[scala.concurrent.Future Future]]. */
+class Foo
diff --git a/sbt/src/sbt-test/plugins/unidoc/test b/sbt/src/sbt-test/plugins/unidoc/test
new file mode 100644
index 000000000..7439923b4
--- /dev/null
+++ b/sbt/src/sbt-test/plugins/unidoc/test
@@ -0,0 +1 @@
+> unidoc
diff --git a/sbt/src/sbt-test/project-load/sha-conflict/disabled b/sbt/src/sbt-test/project-load/sha-conflict/disabled
new file mode 100644
index 000000000..477407e68
--- /dev/null
+++ b/sbt/src/sbt-test/project-load/sha-conflict/disabled
@@ -0,0 +1 @@
+> name
diff --git a/sbt/src/sbt-test/project/aggregate/projA/build.sbt b/sbt/src/sbt-test/project/aggregate/projA/build.sbt
index 88a866ee1..cb6b82872 100644
--- a/sbt/src/sbt-test/project/aggregate/projA/build.sbt
+++ b/sbt/src/sbt-test/project/aggregate/projA/build.sbt
@@ -1,3 +1,3 @@
 name := "projA"
 
-scalaVersion := "2.11.8"
+scalaVersion := "2.12.12"
diff --git a/sbt/src/sbt-test/project/aggregate/test b/sbt/src/sbt-test/project/aggregate/test
index 1cb4f2bba..e7243130f 100644
--- a/sbt/src/sbt-test/project/aggregate/test
+++ b/sbt/src/sbt-test/project/aggregate/test
@@ -1,2 +1,2 @@
 > compile
-$ exists projA/target/scala-2.11/classes/A.class
+$ exists projA/target/scala-2.12/classes/A.class
diff --git a/sbt/src/sbt-test/project/auto-import/project/P.scala b/sbt/src/sbt-test/project/auto-import/project/P.scala
index 0ff8fbd51..70e309a38 100644
--- a/sbt/src/sbt-test/project/auto-import/project/P.scala
+++ b/sbt/src/sbt-test/project/auto-import/project/P.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._
+import sbt._
 
 object Q extends AutoPlugin {
   override val requires = plugins.JvmPlugin
diff --git a/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/build.sbt b/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/build.sbt
index 601ed7611..bea5471fd 100644
--- a/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/build.sbt
+++ b/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/build.sbt
@@ -1,8 +1,8 @@
 val test123 = project in file(".") enablePlugins TestP settings(
-  resourceGenerators in Compile += (Def.task {
+  resourceGenerators in Compile += Def.task {
     streams.value.log info "resource generated in settings"
     Nil
-  }).taskValue
+  }
 )
 
 TaskKey[Unit]("check") := {
diff --git a/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/project/TestP.scala b/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/project/TestP.scala
index ce7b6f707..c52417af9 100644
--- a/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/project/TestP.scala
+++ b/sbt/src/sbt-test/project/auto-plugins-default-requires-jvmplugin/project/TestP.scala
@@ -1,10 +1,10 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object TestP extends AutoPlugin {
   override def projectSettings: Seq[Setting[_]] = Seq(
-    resourceGenerators in Compile += (Def.task {
+    resourceGenerators in Compile += Def.task {
       streams.value.log info "resource generated in plugin"
       Nil
-    }).taskValue
+    }
   )
 }
diff --git a/sbt/src/sbt-test/project/auto-plugins-ivy-disabled/build.sbt b/sbt/src/sbt-test/project/auto-plugins-ivy-disabled/build.sbt
new file mode 100644
index 000000000..82a2f4d9d
--- /dev/null
+++ b/sbt/src/sbt-test/project/auto-plugins-ivy-disabled/build.sbt
@@ -0,0 +1,6 @@
+disablePlugins(plugins.IvyPlugin)
+
+TaskKey[Unit]("check") := {
+  val pid = projectID.?.value
+  assert(pid.isEmpty)
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/auto-plugins-ivy-disabled/test b/sbt/src/sbt-test/project/auto-plugins-ivy-disabled/test
new file mode 100644
index 000000000..a5912a391
--- /dev/null
+++ b/sbt/src/sbt-test/project/auto-plugins-ivy-disabled/test
@@ -0,0 +1 @@
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/auto-plugins-nested/project/Q.scala b/sbt/src/sbt-test/project/auto-plugins-nested/project/Q.scala
index 19af35308..b7deb8b58 100644
--- a/sbt/src/sbt-test/project/auto-plugins-nested/project/Q.scala
+++ b/sbt/src/sbt-test/project/auto-plugins-nested/project/Q.scala
@@ -1,5 +1,5 @@
 package sbttest
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object Imports {
   object A extends AutoPlugin
diff --git a/sbt/src/sbt-test/project/auto-plugins/build.sbt b/sbt/src/sbt-test/project/auto-plugins/build.sbt
index 8038f2a06..f564d4879 100644
--- a/sbt/src/sbt-test/project/auto-plugins/build.sbt
+++ b/sbt/src/sbt-test/project/auto-plugins/build.sbt
@@ -28,9 +28,6 @@ lazy val projI = project.enablePlugins(TopC)
 // Tests that we can disable an auto-enabled root plugin
 lazy val disableAutoNoRequirePlugin = project.disablePlugins(OrgPlugin)
 
-
-disablePlugins(plugins.IvyPlugin)
-
 check := {
     // Ensure organization on root is overridable.
     val rorg = (organization).value // Should be None
@@ -38,11 +35,10 @@ check := {
     // this will pass when the raw disablePlugin works.
     val dversion = (projectID in projD).?.value // Should be None
     same(dversion, None, "projectID in projD")
-    val rversion = projectID.?.value // Should be None
-    same(rversion, None, "projectID")
+
 //  Ensure with multiple .sbt files that disabling/enabling works across them
-    val fDel = (del in q in projF).?.value
-    same(fDel, Some(" Q"), "del in q in projF")
+    val fDel = (del in Quux in projF).?.value
+    same(fDel, Some(" Q"), "del in Quux in projF")
 //
 	val adel = (del in projA).?.value // should be None
 	same(adel, None, "del in projA")
@@ -57,10 +53,10 @@ check := {
 	same(globalValue, "global 0", "demo in Global")
 	val projValue = (demo in projC).?.value
 	same(projValue, Some("project projC Q R"), "demo in projC")
-	val qValue = (del in projC in q).?.value
-	same(qValue, Some(" Q R"), "del in projC in q")
-	val optInValue = (del in projE in q).value
-	same(optInValue, " Q S R", "del in projE in q")
+	val qValue = (del in projC in Quux).?.value
+	same(qValue, Some(" Q R"), "del in projC in Quux")
+	val optInValue = (del in projE in Quux).value
+	same(optInValue, " Q S R", "del in projE in Quux")
 	val overrideOrgValue = (organization in projE).value
 	same(overrideOrgValue, "S", "organization in projE")
 // tests for top level plugins
diff --git a/sbt/src/sbt-test/project/auto-plugins/project/A.scala b/sbt/src/sbt-test/project/auto-plugins/project/A.scala
index 7871676de..b11319afe 100644
--- a/sbt/src/sbt-test/project/auto-plugins/project/A.scala
+++ b/sbt/src/sbt-test/project/auto-plugins/project/A.scala
@@ -1,7 +1,7 @@
 // no package
 // plugins declared within no package should be visible to other plugins in the _root_ package
 
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object TopLevelImports {
   lazy val topLevelDemo = settingKey[String]("A top level demo setting.")
diff --git a/sbt/src/sbt-test/project/auto-plugins/project/Q.scala b/sbt/src/sbt-test/project/auto-plugins/project/Q.scala
index 091e812d6..001fd1eae 100644
--- a/sbt/src/sbt-test/project/auto-plugins/project/Q.scala
+++ b/sbt/src/sbt-test/project/auto-plugins/project/Q.scala
@@ -1,6 +1,6 @@
-package sbttest // you need package http://stackoverflow.com/questions/9822008/
+package sbttest // you need package https://stackoverflow.com/questions/9822008/
 
-	import sbt._, syntax._, Keys._
+	import sbt._, Keys._
 	import java.util.concurrent.atomic.{AtomicInteger => AInt}
 
 	object A extends AutoPlugin { override def requires: Plugins = empty }
@@ -9,8 +9,8 @@ package sbttest // you need package http://stackoverflow.com/questions/9822008/
 
 object Imports
 {
-	lazy val q = config("q")
-	lazy val p = config("p").extend(q)
+	lazy val Quux = config("q")
+	lazy val Pippy = config("p").extend(Quux)
 
 	lazy val demo = settingKey[String]("A demo setting.")
 	lazy val del = settingKey[String]("Another demo setting.")
@@ -47,13 +47,13 @@ object Q extends AutoPlugin
 	override def trigger = allRequirements
 
 	override def projectConfigurations: Seq[Configuration] =
-		p ::
-		q ::
+		Pippy ::
+		Quux ::
 		Nil
 
    override def projectSettings: Seq[Setting[_]] =
 		(demo := s"project ${name.value}") ::
-		(del in q := " Q") ::
+		(del in Quux := " Q") ::
 		Nil
 
    override def buildSettings: Seq[Setting[_]] =
@@ -77,9 +77,9 @@ object R extends AutoPlugin
 
 	override def projectSettings = Seq(
 		// tests proper ordering: R requires Q, so Q settings should come first
-		del in q += " R",
+		del in Quux += " R",
 		// tests that configurations are properly registered, enabling delegation from p to q
-		demo += (del in p).value
+		demo += (del in Pippy).value
 	)
 }
 
@@ -91,7 +91,7 @@ object S extends AutoPlugin
 	override def trigger = noTrigger
 
 	override def projectSettings = Seq(
-		del in q += " S",
+		del in Quux += " S",
 		organization := "S"
 	)
 }
diff --git a/sbt/src/sbt-test/project/auto-settings/b/build.sbt b/sbt/src/sbt-test/project/auto-settings/b/build.sbt
deleted file mode 100644
index e864169d1..000000000
--- a/sbt/src/sbt-test/project/auto-settings/b/build.sbt
+++ /dev/null
@@ -1 +0,0 @@
-version := "ignored"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/auto-settings/build.sbt b/sbt/src/sbt-test/project/auto-settings/build.sbt
deleted file mode 100644
index 7d4a01490..000000000
--- a/sbt/src/sbt-test/project/auto-settings/build.sbt
+++ /dev/null
@@ -1,37 +0,0 @@
-import AddSettings._
-
-// version should be from explicit/a.txt
-lazy val root = proj("root", "1.4").settingSets(
-  buildScalaFiles,
-  userSettings,
-  sbtFiles(file("explicit/a.txt"))
-)
-
-// version should be from global/user.sbt
-lazy val a = proj("a", "1.1").
-  settingSets( buildScalaFiles, userSettings )
-
-// version should be the default 0.1-SNAPSHOT
-lazy val b = proj("b", "0.1-SNAPSHOT").
-  settingSets(buildScalaFiles)
-
-// version should be from the explicit settings call
-lazy val c = proj("c", "0.9").settings(version := "0.9").
-  settingSets(buildScalaFiles)
-
-// version should be from d/build.sbt
-lazy val d = proj("d", "1.3").settings(version := "0.9").
-  settingSets( buildScalaFiles, defaultSbtFiles )
-
-// version should be from global/user.sbt
-lazy val e = proj("e", "1.1").settings(version := "0.9").
-  settingSets( buildScalaFiles, defaultSbtFiles, sbtFiles(file("../explicit/a.txt")), userSettings )
-
-def proj(id: String, expectedVersion: String): Project =
-  Project(id, if(id == "root") file(".") else file(id)).
-  settings(
-    TaskKey[Unit]("check") := {
-      assert(version.value == expectedVersion,
-        "Expected version '" + expectedVersion + "', got: " + version.value + " in " + id)
-    }
-  )
diff --git a/sbt/src/sbt-test/project/auto-settings/d/build.sbt b/sbt/src/sbt-test/project/auto-settings/d/build.sbt
deleted file mode 100644
index 7e86dd0fb..000000000
--- a/sbt/src/sbt-test/project/auto-settings/d/build.sbt
+++ /dev/null
@@ -1 +0,0 @@
-version := "1.3"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/auto-settings/disabled b/sbt/src/sbt-test/project/auto-settings/disabled
deleted file mode 100644
index dcccfd271..000000000
--- a/sbt/src/sbt-test/project/auto-settings/disabled
+++ /dev/null
@@ -1,13 +0,0 @@
-> plugins
-
-> root/check
-
-> a/check
-
-> b/check
-
-> c/check
-
-> d/check
-
-> e/check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/auto-settings/e/build.sbt b/sbt/src/sbt-test/project/auto-settings/e/build.sbt
deleted file mode 100644
index e864169d1..000000000
--- a/sbt/src/sbt-test/project/auto-settings/e/build.sbt
+++ /dev/null
@@ -1 +0,0 @@
-version := "ignored"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/auto-settings/explicit/a.txt b/sbt/src/sbt-test/project/auto-settings/explicit/a.txt
deleted file mode 100644
index 873fd02b0..000000000
--- a/sbt/src/sbt-test/project/auto-settings/explicit/a.txt
+++ /dev/null
@@ -1 +0,0 @@
-version := "1.4"
diff --git a/sbt/src/sbt-test/project/auto-settings/global/user.sbt b/sbt/src/sbt-test/project/auto-settings/global/user.sbt
deleted file mode 100644
index 99be66402..000000000
--- a/sbt/src/sbt-test/project/auto-settings/global/user.sbt
+++ /dev/null
@@ -1 +0,0 @@
-version := "1.1"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/auto-settings/root.sbt b/sbt/src/sbt-test/project/auto-settings/root.sbt
deleted file mode 100644
index 7ec0d973f..000000000
--- a/sbt/src/sbt-test/project/auto-settings/root.sbt
+++ /dev/null
@@ -1 +0,0 @@
-version := "1.2"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/binary-plugin/changes/define/A.scala b/sbt/src/sbt-test/project/binary-plugin/changes/define/A.scala
index f003b8da5..e9654ba5d 100644
--- a/sbt/src/sbt-test/project/binary-plugin/changes/define/A.scala
+++ b/sbt/src/sbt-test/project/binary-plugin/changes/define/A.scala
@@ -1,6 +1,6 @@
-package sbttest // you need package http://stackoverflow.com/questions/9822008/
+package sbttest // you need package https://stackoverflow.com/questions/9822008/
 
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object C extends AutoPlugin {
   object autoImport {
diff --git a/sbt/src/sbt-test/project/binary-plugin/changes/define/D.scala b/sbt/src/sbt-test/project/binary-plugin/changes/define/D.scala
index 1b21ad9dd..7490579a8 100644
--- a/sbt/src/sbt-test/project/binary-plugin/changes/define/D.scala
+++ b/sbt/src/sbt-test/project/binary-plugin/changes/define/D.scala
@@ -1,6 +1,6 @@
 // no package declaration
 
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object D extends AutoPlugin {
   object autoImport {
diff --git a/sbt/src/sbt-test/project/binary-plugin/test b/sbt/src/sbt-test/project/binary-plugin/test
index a8ccb21b4..b1f744b7a 100644
--- a/sbt/src/sbt-test/project/binary-plugin/test
+++ b/sbt/src/sbt-test/project/binary-plugin/test
@@ -3,7 +3,7 @@ $ copy-file changes/define/build.sbt build.sbt
 $ copy-file changes/define/A.scala A.scala
 $ copy-file changes/define/D.scala D.scala
 
-# reload implied
+> reload
 > publishLocal
 
 # Now we remove the source code and define a project which uses the build.
diff --git a/sbt/src/sbt-test/project/bsp-internal-dependency-configs/build.sbt b/sbt/src/sbt-test/project/bsp-internal-dependency-configs/build.sbt
new file mode 100644
index 000000000..bc3f2d431
--- /dev/null
+++ b/sbt/src/sbt-test/project/bsp-internal-dependency-configs/build.sbt
@@ -0,0 +1,19 @@
+lazy val a = project.in(file("a")).dependsOn(b % Test)
+
+lazy val b = project.in(file("b")).dependsOn(c)
+
+lazy val c = project.in(file("c"))
+
+def getConfigs(key: SettingKey[Seq[(ProjectRef, Set[ConfigKey])]]):
+  Def.Initialize[Map[String, Set[String]]] =
+    Def.setting(key.value.map { case (p, c) => p.project -> c.map(_.name) }.toMap)
+
+TaskKey[Unit]("check") := {
+  val testDeps = getConfigs(a / Test / bspInternalDependencyConfigurations).value
+  val expected = Map(
+    "a" -> Set("compile", "test"),
+    "b" -> Set("compile"),
+    "c" -> Set("compile")
+  )
+  assert(testDeps == expected)
+}
diff --git a/sbt/src/sbt-test/project/bsp-internal-dependency-configs/test b/sbt/src/sbt-test/project/bsp-internal-dependency-configs/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/project/bsp-internal-dependency-configs/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/project/build-deps/changes/b.sbt b/sbt/src/sbt-test/project/build-deps/changes/b.sbt
index 4de1f967f..334917dea 100644
--- a/sbt/src/sbt-test/project/build-deps/changes/b.sbt
+++ b/sbt/src/sbt-test/project/build-deps/changes/b.sbt
@@ -1,3 +1,5 @@
-buildDependencies in Global := ((buildDependencies in Global, thisProjectRef, thisProjectRef in LocalProject("a")) { (deps, refB, refA) =>
-	deps.addClasspath(refA, ResolvedClasspathDependency(refB, None))
-}).value
+buildDependencies in Global :=
+  (buildDependencies in Global).value.addClasspath(
+    (thisProjectRef in LocalProject("a")).value,
+    ResolvedClasspathDependency(thisProjectRef.value, None)
+  )
diff --git a/sbt/src/sbt-test/project/circular/build.sbt b/sbt/src/sbt-test/project/circular/build.sbt
index 282765eaf..f254811cc 100644
--- a/sbt/src/sbt-test/project/circular/build.sbt
+++ b/sbt/src/sbt-test/project/circular/build.sbt
@@ -5,14 +5,14 @@ lazy val root = (project in file(".")).
   )
 
 lazy val sub: Project = project.
-  dependsOn(root).
-  settingsLazy(
-    name := (name in root).value + "sub"
+  dependsOn(LocalProject("root")).
+  settings(
+    name := (name in LocalProject("root")).value + "sub"
   )
 
 lazy val foo: Project = project.
-  aggregateSeq(List(root)).
-  dependsOnSeq(List(root)).
+  aggregate(LocalProject("root")).
+  dependsOn(LocalProject("root")).
   settings(List(
-    name := (name in root).value + "foo"
+    name := (name in LocalProject("root")).value + "foo"
   ): _*)
diff --git a/sbt/src/sbt-test/project/continuations/build.sbt b/sbt/src/sbt-test/project/continuations/build.sbt
index a74d681e4..f64801e68 100644
--- a/sbt/src/sbt-test/project/continuations/build.sbt
+++ b/sbt/src/sbt-test/project/continuations/build.sbt
@@ -7,7 +7,7 @@ addCompilerPlugin("org.scala-lang.plugins" % "continuations" % "2.8.1")
 scalacOptions += "-P:continuations:enable"
 
 libraryDependencies ++= Seq(
-	"junit" % "junit" % "4.7" % "test",
+	"junit" % "junit" % "4.13.1" % "test",
 	"com.novocode" % "junit-interface" % "0.5" % "test"
 )
 
diff --git a/sbt/src/sbt-test/project/continuations/src/main/scala/Example.scala b/sbt/src/sbt-test/project/continuations/src/main/scala/Example.scala
index c93d82ac7..393eb3374 100644
--- a/sbt/src/sbt-test/project/continuations/src/main/scala/Example.scala
+++ b/sbt/src/sbt-test/project/continuations/src/main/scala/Example.scala
@@ -4,7 +4,7 @@ object Example {
 
 	val x =
 		reset {
-			shift { k: (Int=>Int) =>
+			shift { k: (Int => Int) =>
 				k(k(k(7)))
 			} + 1
 		} * 2
diff --git a/sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt b/sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt
new file mode 100644
index 000000000..2179dcf9e
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt
@@ -0,0 +1,40 @@
+val baseSbt = "1."
+
+val buildCrossList = List("2.10.7", "2.11.12", "2.12.12")
+scalaVersion in ThisBuild := "2.12.12"
+crossScalaVersions in ThisBuild := buildCrossList
+
+addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.7.0")
+
+lazy val root = (project in file("."))
+  .enablePlugins(SbtPlugin)
+  .settings(
+    TaskKey[Unit]("check") := mkCheck("2.12", "1.0", "1.").value,
+    TaskKey[Unit]("check2") := mkCheck("2.10", "0.13", "0.13").value,
+  )
+
+lazy val app = (project in file("app"))
+
+def mkCheck(scalaBinV: String, sbtBinVer: String, sbtVerPrefix: String) = Def.task {
+  val crossV = (sbtVersion in pluginCrossBuild).value
+  val crossBinV = (sbtBinaryVersion in pluginCrossBuild).value
+  val sv = projectID.value.extraAttributes("e:scalaVersion")
+  assert(sbtVersion.value startsWith baseSbt, s"Wrong sbt version: ${sbtVersion.value}")
+  assert(sv == scalaBinV, s"Wrong e:scalaVersion: $sv")
+  assert(scalaBinaryVersion.value == scalaBinV, s"Wrong Scala binary version: ${scalaBinaryVersion.value}")
+  assert(crossV startsWith sbtVerPrefix, s"Wrong `sbtVersion in pluginCrossBuild`: $crossV")
+
+  val ur = update.value
+  val cr = ur.configuration(Compile).get
+  val mr = cr.modules.find(mr => mr.module.organization == "com.eed3si9n" && mr.module.name == "sbt-buildinfo").get
+  val plugSv = mr.module.extraAttributes("scalaVersion")
+  val plugSbtV = mr.module.extraAttributes("sbtVersion")
+  assert(plugSv == scalaBinV, s"Wrong plugin scalaVersion: $plugSv")
+  assert(plugSbtV == sbtBinVer, s"Wrong plugin sbtVersion: $plugSbtV")
+
+  // crossScalaVersions in app should not be affected, per se or after ^^
+  val appCrossScalaVersions = (crossScalaVersions in app).value.toList
+  val appScalaVersion = (scalaVersion in app).value
+  assert(appCrossScalaVersions == buildCrossList, s"Wrong `crossScalaVersions in app`: $appCrossScalaVersions")
+  assert(appScalaVersion startsWith "2.12", s"Wrong `scalaVersion in app`: $appScalaVersion")
+}
diff --git a/sbt/src/sbt-test/project/cross-plugins-defaults/test b/sbt/src/sbt-test/project/cross-plugins-defaults/test
new file mode 100644
index 000000000..15a55b859
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-defaults/test
@@ -0,0 +1,5 @@
+> check
+
+> ^^0.13.15
+
+> check2
diff --git a/sbt/src/sbt-test/project/cross-plugins-source/build.sbt b/sbt/src/sbt-test/project/cross-plugins-source/build.sbt
new file mode 100644
index 000000000..874d2da9d
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-source/build.sbt
@@ -0,0 +1,6 @@
+lazy val root = (project in file("."))
+  .settings(
+    sbtPlugin := true,
+    sbtVersion in pluginCrossBuild := "0.13.15",
+    resolvers += Resolver.typesafeIvyRepo("releases")
+  )
diff --git a/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13.x/B.scala b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13.x/B.scala
new file mode 100644
index 000000000..0ed0a40b8
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13.x/B.scala
@@ -0,0 +1,2 @@
+// folder mustn't be included
+trait B
diff --git a/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13/A.scala b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13/A.scala
new file mode 100644
index 000000000..16c5ea484
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13/A.scala
@@ -0,0 +1 @@
+trait A
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13/B.scala b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13/B.scala
new file mode 100644
index 000000000..1e59c35e7
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala-sbt-0.13/B.scala
@@ -0,0 +1 @@
+trait B
diff --git a/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala/Test.scala b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala/Test.scala
new file mode 100644
index 000000000..3dc251c35
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-source/src/main/scala/Test.scala
@@ -0,0 +1 @@
+object Test extends A with B
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/cross-plugins-source/src/test/scala/TestFile.scala b/sbt/src/sbt-test/project/cross-plugins-source/src/test/scala/TestFile.scala
new file mode 100644
index 000000000..e2d081a36
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-source/src/test/scala/TestFile.scala
@@ -0,0 +1,3 @@
+// should fail because the project is building for
+// 0.13.15 where E is not included
+object ErrorTest extends E
diff --git a/sbt/src/sbt-test/project/cross-plugins-source/test b/sbt/src/sbt-test/project/cross-plugins-source/test
new file mode 100644
index 000000000..f3f14e7b2
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-plugins-source/test
@@ -0,0 +1,3 @@
+> show pluginCrossBuild::sbtDependency
+> compile
+-> test:compile
diff --git a/sbt/src/sbt-test/project/cross-source/build.sbt b/sbt/src/sbt-test/project/cross-source/build.sbt
new file mode 100644
index 000000000..2f3894078
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/build.sbt
@@ -0,0 +1,8 @@
+val commonSettings = Seq(
+  crossScalaVersions := (0 to 6).map(i => s"2.10.$i") ++ (0 to 11).map(i => s"2.11.$i") ++ (0 to 2).map(i => s"2.12.$i")
+)
+
+val p1 = project.in(file("p1")).settings(commonSettings)
+val p2 = project.in(file("p2")).settings(commonSettings)
+val p3 = project.in(file("p3")).settings(commonSettings)
+val p4 = project.in(file("p4")).settings(commonSettings)
diff --git a/sbt/src/sbt-test/source-dependencies/cross-source/src/main/scala-2.10/B.scala b/sbt/src/sbt-test/project/cross-source/p1/src/main/scala-2.10/B.scala
similarity index 100%
rename from sbt/src/sbt-test/source-dependencies/cross-source/src/main/scala-2.10/B.scala
rename to sbt/src/sbt-test/project/cross-source/p1/src/main/scala-2.10/B.scala
diff --git a/sbt/src/sbt-test/project/cross-source/p1/src/main/scala/A.scala b/sbt/src/sbt-test/project/cross-source/p1/src/main/scala/A.scala
new file mode 100644
index 000000000..8b55ead57
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/p1/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+class A {
+  def show(what: String): Unit = println(what)
+}
diff --git a/sbt/src/sbt-test/project/cross-source/p2/src/main/scala-2.10/B.scala b/sbt/src/sbt-test/project/cross-source/p2/src/main/scala-2.10/B.scala
new file mode 100644
index 000000000..fa8ad30ea
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/p2/src/main/scala-2.10/B.scala
@@ -0,0 +1,3 @@
+object B {
+  def show(what: String): String = s"String interpolation is ${what.toUpperCase}!"
+}
diff --git a/sbt/src/sbt-test/project/cross-source/p2/src/main/scala/A.scala b/sbt/src/sbt-test/project/cross-source/p2/src/main/scala/A.scala
new file mode 100644
index 000000000..8b55ead57
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/p2/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+class A {
+  def show(what: String): Unit = println(what)
+}
diff --git a/sbt/src/sbt-test/project/cross-source/p3/src/main/scala-2.10/B.scala b/sbt/src/sbt-test/project/cross-source/p3/src/main/scala-2.10/B.scala
new file mode 100644
index 000000000..fa8ad30ea
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/p3/src/main/scala-2.10/B.scala
@@ -0,0 +1,3 @@
+object B {
+  def show(what: String): String = s"String interpolation is ${what.toUpperCase}!"
+}
diff --git a/sbt/src/sbt-test/project/cross-source/p3/src/main/scala/A.scala b/sbt/src/sbt-test/project/cross-source/p3/src/main/scala/A.scala
new file mode 100644
index 000000000..8b55ead57
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/p3/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+class A {
+  def show(what: String): Unit = println(what)
+}
diff --git a/sbt/src/sbt-test/project/cross-source/p4/src/main/scala-2.10/B.scala b/sbt/src/sbt-test/project/cross-source/p4/src/main/scala-2.10/B.scala
new file mode 100644
index 000000000..fa8ad30ea
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/p4/src/main/scala-2.10/B.scala
@@ -0,0 +1,3 @@
+object B {
+  def show(what: String): String = s"String interpolation is ${what.toUpperCase}!"
+}
diff --git a/sbt/src/sbt-test/project/cross-source/p4/src/main/scala/A.scala b/sbt/src/sbt-test/project/cross-source/p4/src/main/scala/A.scala
new file mode 100644
index 000000000..8b55ead57
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/p4/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+class A {
+  def show(what: String): Unit = println(what)
+}
diff --git a/sbt/src/sbt-test/project/cross-source/test b/sbt/src/sbt-test/project/cross-source/test
new file mode 100644
index 000000000..17db5c8da
--- /dev/null
+++ b/sbt/src/sbt-test/project/cross-source/test
@@ -0,0 +1,3 @@
+# https://github.com/sbt/sbt/issues/3143
+> crossScalaVersions
+> +version
diff --git a/sbt/src/sbt-test/project/default-settings/build.sbt b/sbt/src/sbt-test/project/default-settings/build.sbt
index eb3cb4c16..d910b30ac 100644
--- a/sbt/src/sbt-test/project/default-settings/build.sbt
+++ b/sbt/src/sbt-test/project/default-settings/build.sbt
@@ -2,7 +2,7 @@ val root = (project in file("."))
 
 TaskKey[Unit]("checkScalaVersion", "test") := {
   val sv = scalaVersion.value
-  assert(sv startsWith "2.11.", s"Found $sv!")
+  assert(sv startsWith "2.12.", s"Found $sv!")
 }
 
 TaskKey[Unit]("checkArtifacts", "test") := {
diff --git a/sbt/src/sbt-test/project/defs/build.sbt b/sbt/src/sbt-test/project/defs/build.sbt
index f5dca00bb..94be70893 100644
--- a/sbt/src/sbt-test/project/defs/build.sbt
+++ b/sbt/src/sbt-test/project/defs/build.sbt
@@ -1,4 +1,5 @@
-lazy val a,b = project
+lazy val a = project
+lazy val b = project
 
 def now = System.currentTimeMillis
 
diff --git a/sbt/src/sbt-test/project/extra-projects/project/DatabasePlugin.scala b/sbt/src/sbt-test/project/extra-projects/project/DatabasePlugin.scala
index 0febc622b..0d7a4163e 100644
--- a/sbt/src/sbt-test/project/extra-projects/project/DatabasePlugin.scala
+++ b/sbt/src/sbt-test/project/extra-projects/project/DatabasePlugin.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object DatabasePlugin extends AutoPlugin {
   override def requires: Plugins = sbt.plugins.JvmPlugin
diff --git a/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample.scala b/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample.scala
index 1ebb3d494..0ab386369 100644
--- a/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample.scala
+++ b/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object ExtraProjectPluginExample extends AutoPlugin {
   override def extraProjects: Seq[Project] =
diff --git a/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample2.scala b/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample2.scala
index e74064a4a..dd1682623 100644
--- a/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample2.scala
+++ b/sbt/src/sbt-test/project/extra-projects/project/ExtraProjectPluginExample2.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object ExtraProjectPluginExample2 extends AutoPlugin {
   // Enable this plugin by default
diff --git a/sbt/src/sbt-test/project/extra/build.sbt b/sbt/src/sbt-test/project/extra/build.sbt
index 03087c247..556d3e61b 100644
--- a/sbt/src/sbt-test/project/extra/build.sbt
+++ b/sbt/src/sbt-test/project/extra/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / useCoursier := false
+
 lazy val root = (project in file(".")).
   settings(
     autoScalaLibrary := false,
@@ -38,6 +40,6 @@ def addExtra2(s: State, extra: Seq[File]): State =
     else
     {
       val newID = ApplicationID(currentID).copy(extra = extra)
-      s.setResult(Some(reload.copy(app = newID)))
+      s.setNext(new State.Return(reload.copy(app = newID)))
     }
   }
diff --git a/sbt/src/sbt-test/project/flatten/build.sbt b/sbt/src/sbt-test/project/flatten/build.sbt
index 819170f8e..5e39482e1 100644
--- a/sbt/src/sbt-test/project/flatten/build.sbt
+++ b/sbt/src/sbt-test/project/flatten/build.sbt
@@ -1,23 +1,23 @@
-lazy val root = (project in file(".")).
-  settings(
+val unpackage = TaskKey[Unit]("unpackage")
+
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file("."))
+  .settings(
     forConfig(Compile, "src"),
     forConfig(Test, "test-src"),
-    baseSettings
+    libraryDependencies += "org.scalacheck" %% "scalacheck" % "1.14.0" % Test,
+    unmanagedSources / includeFilter := "*.java" | "*.scala"
   )
 
-def baseSettings = Seq(
-  scalaVersion := "2.11.8",
-  libraryDependencies += "org.scalacheck" %% "scalacheck" % "1.11.4" % Test,
-  includeFilter in unmanagedSources := "*.java" | "*.scala"
-)
-
 def forConfig(conf: Configuration, name: String) = Project.inConfig(conf)( unpackageSettings(name) )
 
 def unpackageSettings(name: String) = Seq(
   unmanagedSourceDirectories := (baseDirectory.value / name) :: Nil,
-  excludeFilter in unmanagedResources := (includeFilter in unmanagedSources).value,
+  unmanagedResources / excludeFilter := (unmanagedSources / includeFilter).value,
   unmanagedResourceDirectories := unmanagedSourceDirectories.value,
-  unpackage := IO.unzip(artifactPath in packageSrc value, baseDirectory.value / name)
+  unpackage := {
+    IO.unzip((packageSrc / artifactPath).value, baseDirectory.value / name)
+    IO.delete(baseDirectory.value / name / "META-INF")
+  }
 )
-
-val unpackage = TaskKey[Unit]("unpackage")
diff --git a/sbt/src/sbt-test/project/generated-root-no-publish/build.sbt b/sbt/src/sbt-test/project/generated-root-no-publish/build.sbt
index 974a291a9..218d90089 100644
--- a/sbt/src/sbt-test/project/generated-root-no-publish/build.sbt
+++ b/sbt/src/sbt-test/project/generated-root-no-publish/build.sbt
@@ -1,10 +1,13 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 val commonSettings = Seq(
   organization := "com.example",
   version := "0.1.0",
-  ivyPaths := new IvyPaths((baseDirectory in LocalRootProject).value, Some((target in LocalRootProject).value / "ivy-cache"))
+  ivyPaths := IvyPaths((baseDirectory in LocalRootProject).value, Some((target in LocalRootProject).value / "ivy-cache"))
 )
 
 lazy val app = (project in file("app")).
   settings(commonSettings: _*)
 
+name := "generated-root-no-publish"
 commonSettings
diff --git a/sbt/src/sbt-test/project/generated-root-no-publish/changes/bare.sbt b/sbt/src/sbt-test/project/generated-root-no-publish/changes/bare.sbt
index 936367950..f614ef398 100644
--- a/sbt/src/sbt-test/project/generated-root-no-publish/changes/bare.sbt
+++ b/sbt/src/sbt-test/project/generated-root-no-publish/changes/bare.sbt
@@ -1,3 +1,5 @@
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 organization := "com.example"
 version := "0.1.0"
-ivyPaths := new IvyPaths((baseDirectory in LocalRootProject).value, Some((target in LocalRootProject).value / "ivy-cache"))
+ivyPaths := IvyPaths((baseDirectory in LocalRootProject).value, Some((target in LocalRootProject).value / "ivy-cache"))
diff --git a/sbt/src/sbt-test/project/generated-root-no-publish/test b/sbt/src/sbt-test/project/generated-root-no-publish/test
index 9b428f03a..bbe00c95c 100644
--- a/sbt/src/sbt-test/project/generated-root-no-publish/test
+++ b/sbt/src/sbt-test/project/generated-root-no-publish/test
@@ -1,10 +1,10 @@
 > publishLocal
-$ exists target/ivy-cache/local/com.example/app_2.11/0.1.0/poms/app_2.11.pom
-$ exists target/ivy-cache/local/com.example/app_2.11/0.1.0/jars/app_2.11.jar
-$ absent target/ivy-cache/local/com.example/default-root_2.11/0.1.0/ivys/ivy.xml
+$ exists target/ivy-cache/local/com.example/app_2.12/0.1.0/poms/app_2.12.pom
+$ exists target/ivy-cache/local/com.example/app_2.12/0.1.0/jars/app_2.12.jar
+$ absent target/ivy-cache/local/com.example/default-root_2.12/0.1.0/ivys/ivy.xml
 
 $ copy-file changes/bare.sbt build.sbt
 > reload
 > publishLocal
-$ exists target/ivy-cache/local/com.example/generated-root-no-publish_2.11/0.1.0/poms/generated-root-no-publish_2.11.pom
-$ exists target/ivy-cache/local/com.example/generated-root-no-publish_2.11/0.1.0/jars/generated-root-no-publish_2.11.jar
+$ exists target/ivy-cache/local/com.example/generated-root-no-publish_2.12/0.1.0/poms/generated-root-no-publish_2.12.pom
+$ exists target/ivy-cache/local/com.example/generated-root-no-publish_2.12/0.1.0/jars/generated-root-no-publish_2.12.jar
diff --git a/sbt/src/sbt-test/project/giter8-plugin/build.sbt b/sbt/src/sbt-test/project/giter8-plugin/build.sbt
new file mode 100644
index 000000000..d2785acac
--- /dev/null
+++ b/sbt/src/sbt-test/project/giter8-plugin/build.sbt
@@ -0,0 +1 @@
+enablePlugins(ScriptedPlugin)
diff --git a/sbt/src/sbt-test/project/giter8-plugin/project/p.sbt b/sbt/src/sbt-test/project/giter8-plugin/project/p.sbt
new file mode 100644
index 000000000..7d34f5f68
--- /dev/null
+++ b/sbt/src/sbt-test/project/giter8-plugin/project/p.sbt
@@ -0,0 +1 @@
+addSbtPlugin("org.foundweekends.giter8" %% "sbt-giter8" % "0.11.0-M4")
diff --git a/sbt/src/sbt-test/project/giter8-plugin/test b/sbt/src/sbt-test/project/giter8-plugin/test
new file mode 100644
index 000000000..4e3db8162
--- /dev/null
+++ b/sbt/src/sbt-test/project/giter8-plugin/test
@@ -0,0 +1 @@
+> about
diff --git a/sbt/src/sbt-test/project/global-plugin/global/plugins/A.scala b/sbt/src/sbt-test/project/global-plugin/global/plugins/A.scala
index d22df4753..0ac7f6e66 100644
--- a/sbt/src/sbt-test/project/global-plugin/global/plugins/A.scala
+++ b/sbt/src/sbt-test/project/global-plugin/global/plugins/A.scala
@@ -1,6 +1,6 @@
 package test
 
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 object Global {
   val x = 3
diff --git a/sbt/src/sbt-test/project/inside-ci/build.sbt b/sbt/src/sbt-test/project/inside-ci/build.sbt
new file mode 100644
index 000000000..9e772fdcd
--- /dev/null
+++ b/sbt/src/sbt-test/project/inside-ci/build.sbt
@@ -0,0 +1,7 @@
+name := "inside-ci"
+
+organization := "org.example"
+
+val t = taskKey[Boolean]("inside-ci")
+
+t := insideCI.value
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/inside-ci/test b/sbt/src/sbt-test/project/inside-ci/test
new file mode 100644
index 000000000..360ba64e4
--- /dev/null
+++ b/sbt/src/sbt-test/project/inside-ci/test
@@ -0,0 +1,2 @@
+# just need to verify it loads
+> about
diff --git a/sbt/src/sbt-test/project/internal-dependency-configurations/a/A.scala b/sbt/src/sbt-test/project/internal-dependency-configurations/a/A.scala
new file mode 100644
index 000000000..3f2aea979
--- /dev/null
+++ b/sbt/src/sbt-test/project/internal-dependency-configurations/a/A.scala
@@ -0,0 +1,3 @@
+package a
+
+object A {}
diff --git a/sbt/src/sbt-test/project/internal-dependency-configurations/b/B.scala b/sbt/src/sbt-test/project/internal-dependency-configurations/b/B.scala
new file mode 100644
index 000000000..184707bb1
--- /dev/null
+++ b/sbt/src/sbt-test/project/internal-dependency-configurations/b/B.scala
@@ -0,0 +1,5 @@
+package b
+
+object B {
+  println(a.A.toString)
+}
diff --git a/sbt/src/sbt-test/project/internal-dependency-configurations/build.sbt b/sbt/src/sbt-test/project/internal-dependency-configurations/build.sbt
new file mode 100644
index 000000000..06a8556dd
--- /dev/null
+++ b/sbt/src/sbt-test/project/internal-dependency-configurations/build.sbt
@@ -0,0 +1,53 @@
+lazy val root = (project in file(".")).
+  aggregate(a, b, c, d).
+  settings(
+    inThisBuild(Seq(
+      scalaVersion := "2.11.7",
+      trackInternalDependencies := TrackLevel.NoTracking
+    ))
+  )
+
+lazy val a = project in file("a")
+
+lazy val b = (project in file("b")).dependsOn(a % "*->compile")
+
+lazy val c = (project in file("c")).settings(exportToInternal := TrackLevel.NoTracking)
+
+lazy val d = (project in file("d"))
+  .dependsOn(c % "test->test;compile->compile")
+  .settings(trackInternalDependencies := TrackLevel.TrackIfMissing)
+
+def getConfigs(key: SettingKey[Seq[(ProjectRef, Set[String])]]):
+  Def.Initialize[Map[String, Set[String]]] =
+    Def.setting(key.value.map { case (p, c) => p.project -> c }.toMap)
+val checkA = taskKey[Unit]("Verify that project a's internal dependencies are as expected")
+checkA := {
+  val compileDeps = getConfigs(a / Compile / internalDependencyConfigurations).value
+  assert(compileDeps == Map("a" -> Set("compile")))
+  val testDeps = getConfigs(a / Test / internalDependencyConfigurations).value
+  assert(testDeps == Map("a" -> Set("compile", "runtime", "test")))
+}
+
+val checkB = taskKey[Unit]("Verify that project b's internal dependencies are as expected")
+checkB := {
+  val compileDeps = getConfigs(b / Compile / internalDependencyConfigurations).value
+  assert(compileDeps == Map("b" -> Set("compile"), "a" -> Set("compile")))
+  val testDeps = getConfigs(b / Test / internalDependencyConfigurations).value
+  assert(testDeps == Map("b" -> Set("compile", "runtime", "test"), "a" -> Set("compile")))
+}
+
+val checkC = taskKey[Unit]("Verify that project c's internal dependencies are as expected")
+checkC := {
+  val compileDeps = getConfigs(c / Compile / internalDependencyConfigurations).value
+  assert(compileDeps == Map("c" -> Set("compile")))
+  val testDeps = getConfigs(c / Test / internalDependencyConfigurations).value
+  assert(testDeps == Map("c" -> Set("compile", "runtime", "test")))
+}
+
+val checkD = taskKey[Unit]("Verify that project d's internal dependencies are as expected")
+checkD := {
+  val compileDeps = getConfigs(d / Compile / internalDependencyConfigurations).value
+  assert(compileDeps == Map("d" -> Set("compile"), "c" -> Set("compile")))
+  val testDeps = getConfigs(d / Test / internalDependencyConfigurations).value
+  assert(testDeps == Map("d" -> Set("compile", "runtime", "test"), "c" -> Set("compile", "test")))
+}
diff --git a/sbt/src/sbt-test/project/internal-dependency-configurations/c/C.scala b/sbt/src/sbt-test/project/internal-dependency-configurations/c/C.scala
new file mode 100644
index 000000000..abadf1e84
--- /dev/null
+++ b/sbt/src/sbt-test/project/internal-dependency-configurations/c/C.scala
@@ -0,0 +1,3 @@
+package c
+
+object C {}
diff --git a/sbt/src/sbt-test/project/internal-dependency-configurations/d/D.scala b/sbt/src/sbt-test/project/internal-dependency-configurations/d/D.scala
new file mode 100644
index 000000000..9a2cd3377
--- /dev/null
+++ b/sbt/src/sbt-test/project/internal-dependency-configurations/d/D.scala
@@ -0,0 +1,3 @@
+package d
+
+object D { println(c.C.toString) }
diff --git a/sbt/src/sbt-test/project/internal-dependency-configurations/test b/sbt/src/sbt-test/project/internal-dependency-configurations/test
new file mode 100644
index 000000000..618b58159
--- /dev/null
+++ b/sbt/src/sbt-test/project/internal-dependency-configurations/test
@@ -0,0 +1,7 @@
+> checkA
+
+> checkB
+
+> checkC
+
+> checkD
diff --git a/sbt/src/sbt-test/project/internal-tracking/build.sbt b/sbt/src/sbt-test/project/internal-tracking/build.sbt
index ca1ba256c..0d567f22e 100644
--- a/sbt/src/sbt-test/project/internal-tracking/build.sbt
+++ b/sbt/src/sbt-test/project/internal-tracking/build.sbt
@@ -1,25 +1,21 @@
-lazy val root = (project in file(".")).
-  aggregate(a, b, c, d).
-  settings(
-    inThisBuild(Seq(
-      scalaVersion := "2.11.7",
-      trackInternalDependencies := TrackLevel.NoTracking
-    ))
-  )
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / trackInternalDependencies := TrackLevel.NoTracking
+
+lazy val root = (project in file("."))
+  .aggregate(a, b, c, d)
 
 lazy val a = (project in file("a"))
 
-lazy val b = (project in file("b")).
-  dependsOn(a)
+lazy val b = (project in file("b"))
+  .dependsOn(a)
 
-lazy val c = (project in file("c")).
-  settings(
+lazy val c = (project in file("c"))
+  .settings(
     exportToInternal := TrackLevel.NoTracking
   )
 
-lazy val d = (project in file("d")).
-  dependsOn(c).
-  settings(
+lazy val d = (project in file("d"))
+  .dependsOn(c)
+  .settings(
     trackInternalDependencies := TrackLevel.TrackIfMissing
   )
-
diff --git a/sbt/src/sbt-test/project/isolated-build-definitions/generator/build.sbt b/sbt/src/sbt-test/project/isolated-build-definitions/generator/build.sbt
index 4b1c3536a..cbc8c6c17 100644
--- a/sbt/src/sbt-test/project/isolated-build-definitions/generator/build.sbt
+++ b/sbt/src/sbt-test/project/isolated-build-definitions/generator/build.sbt
@@ -1,4 +1,4 @@
-lazy val project = (sbt.syntax.project in file(".")).
+lazy val project = (sbt.project in file(".")).
   settings(
     name := "project",
     scalaVersion := "2.11.7",
diff --git a/sbt/src/sbt-test/project/lint/build.sbt b/sbt/src/sbt-test/project/lint/build.sbt
new file mode 100644
index 000000000..b8ba55e05
--- /dev/null
+++ b/sbt/src/sbt-test/project/lint/build.sbt
@@ -0,0 +1,27 @@
+ThisBuild / doc / scalacOptions += "-Xsomething"
+
+ThisBuild / shellPrompt := { state => "sbt> " }
+
+// watch related settings
+ThisBuild / sbt.nio.Keys.watchTriggers := Seq()
+ThisBuild / sbt.nio.Keys.watchPersistFileStamps := true
+
+lazy val lintBuildTest = taskKey[Unit]("")
+
+lazy val root = (project in file("."))
+  .settings(
+    lintBuildTest := {
+      val state = Keys.state.value
+      val includeKeys = (lintIncludeFilter in Global).value
+      val excludeKeys = (lintExcludeFilter in Global).value
+      val result = sbt.internal.LintUnused.lintUnused(state, includeKeys, excludeKeys)
+      result foreach {
+        case (_, "ThisBuild / doc / scalacOptions", _) => ()
+        case (_, "app / globalAutoPluginSetting", _)   => ()
+        case (_, "root / globalAutoPluginSetting", _)  => ()
+        case (_, str, _)                               => sys.error(str)
+      }
+    }
+  )
+
+lazy val app = project
diff --git a/sbt/src/sbt-test/project/lint/test b/sbt/src/sbt-test/project/lint/test
new file mode 100644
index 000000000..0fff33bdb
--- /dev/null
+++ b/sbt/src/sbt-test/project/lint/test
@@ -0,0 +1 @@
+> lintBuildTest
diff --git a/sbt/src/sbt-test/project/literal-defs/build.sbt b/sbt/src/sbt-test/project/literal-defs/build.sbt
new file mode 100644
index 000000000..1f2675d2e
--- /dev/null
+++ b/sbt/src/sbt-test/project/literal-defs/build.sbt
@@ -0,0 +1,19 @@
+lazy val `import` = (project in file("."))
+  .settings(
+    name := "Hello"
+  )
+
+val `return` = inputKey[Unit]("Check that commands can be defined as back-ticked variables")
+
+
+`return` := {
+	()
+}
+
+
+val `ї` = inputKey[Unit]("Check that we can defined unicode commands")
+
+`ї` := {
+	()
+}
+
diff --git a/sbt/src/sbt-test/project/literal-defs/test b/sbt/src/sbt-test/project/literal-defs/test
new file mode 100644
index 000000000..ba3e85139
--- /dev/null
+++ b/sbt/src/sbt-test/project/literal-defs/test
@@ -0,0 +1,12 @@
+# This test verifies that top-level literal identifiers, like `return`, are loaded correctly
+
+# Initial load should succeed
+
+# Check that we can modify project properties
+> 'set version := "1.0.0"'
+
+# Check that we can run command defined in back-quotes
+> return
+
+# Check that we can define unicode commands
+> ї
diff --git a/sbt/src/sbt-test/project/load-hooks/build.sbt b/sbt/src/sbt-test/project/load-hooks/build.sbt
index 60d7a7a36..c5d44543c 100644
--- a/sbt/src/sbt-test/project/load-hooks/build.sbt
+++ b/sbt/src/sbt-test/project/load-hooks/build.sbt
@@ -1,5 +1,3 @@
-
-
 {
   val loadCount = AttributeKey[Int]("load-count")
   val unloadCount = AttributeKey[Int]("unload-count")
@@ -7,20 +5,20 @@
     val previous = s get key getOrElse 0
     s.put(key, previous + 1)
   }
-  seq(
-	onLoad in Global ~= (f(loadCount) compose _),
-	onUnload in Global ~= (f(unloadCount) compose _)
+  Seq(
+    onLoad in Global ~= (f(loadCount) compose _),
+    onUnload in Global ~= (f(unloadCount) compose _)
   )
 }
 
-InputKey[Unit]("checkCount") := (inputTask { argsTask =>
-	(argsTask, state) map { (args, s) =>
-		def get(label: String) = s get AttributeKey[Int](label) getOrElse 0
-		val loadCount = get("load-count")
-		val unloadCount = get("unload-count")
-		val expectedLoad = args(0).toInt
-		val expectedUnload = args(1).toInt
-		assert(expectedLoad == loadCount, "Expected load count: " + expectedLoad + ", got: " + loadCount)
-		assert(expectedUnload == unloadCount, "Expected unload count: " + expectedUnload + ", got: " + unloadCount)
-	}
-}).evaluated
+InputKey[Unit]("checkCount") := {
+  val s = state.value
+  val args = Def.spaceDelimited().parsed
+  def get(label: String) = s get AttributeKey[Int](label) getOrElse 0
+  val loadCount = get("load-count")
+  val unloadCount = get("unload-count")
+  val expectedLoad = args(0).toInt
+  val expectedUnload = args(1).toInt
+  assert(expectedLoad == loadCount, s"Expected load count: $expectedLoad, got: $loadCount")
+  assert(expectedUnload == unloadCount, s"Expected unload count: $expectedUnload, got: $unloadCount")
+}
diff --git a/sbt/src/sbt-test/project/load-hooks/test b/sbt/src/sbt-test/project/load-hooks/test
index 2e3f94ffd..4db9a6e26 100644
--- a/sbt/src/sbt-test/project/load-hooks/test
+++ b/sbt/src/sbt-test/project/load-hooks/test
@@ -1,3 +1,4 @@
+> reboot
 > checkCount 1 0
 > checkCount 1 0
 > reload
diff --git a/sbt/src/sbt-test/project/old-ops/test b/sbt/src/sbt-test/project/old-ops/test
index 2eae3cfe4..dca604af7 100644
--- a/sbt/src/sbt-test/project/old-ops/test
+++ b/sbt/src/sbt-test/project/old-ops/test
@@ -1,17 +1,18 @@
 $ copy-file changes/settingAssign/build.sbt build.sbt
--> compile
+# Necessary to reload since the test assumes that the new build is picked up
+-> reload
 
 $ copy-file changes/settingAppend1/build.sbt build.sbt
--> compile
+-> reload
 
 $ copy-file changes/settingAppendN/build.sbt build.sbt
--> compile
+-> reload
 
 $ copy-file changes/taskAssign/build.sbt build.sbt
--> compile
+-> reload
 
 $ copy-file changes/taskAppend1/build.sbt build.sbt
--> compile
+-> reload
 
 $ copy-file changes/taskAppendN/build.sbt build.sbt
--> compile
+-> reload
diff --git a/sbt/src/sbt-test/project/plugin-scala-compiler-dependency/project/Plugin.scala b/sbt/src/sbt-test/project/plugin-scala-compiler-dependency/project/Plugin.scala
new file mode 100644
index 000000000..56281e2a1
--- /dev/null
+++ b/sbt/src/sbt-test/project/plugin-scala-compiler-dependency/project/Plugin.scala
@@ -0,0 +1,3 @@
+import scala.tools.nsc
+
+object Plugin
diff --git a/sbt/src/sbt-test/project/plugin-scala-compiler-dependency/test b/sbt/src/sbt-test/project/plugin-scala-compiler-dependency/test
new file mode 100644
index 000000000..3d7a46a0a
--- /dev/null
+++ b/sbt/src/sbt-test/project/plugin-scala-compiler-dependency/test
@@ -0,0 +1,2 @@
+> show sbtVersion
+# we just want to test that the project loads
diff --git a/sbt/src/sbt-test/project/plusequals/build.sbt b/sbt/src/sbt-test/project/plusequals/build.sbt
new file mode 100644
index 000000000..b584511d9
--- /dev/null
+++ b/sbt/src/sbt-test/project/plusequals/build.sbt
@@ -0,0 +1,6 @@
+// https://github.com/sbt/sbt/issues/3132
+lazy val root = (project in file(".")).
+  enablePlugins(XBuildInfoPlugin).
+  settings(
+    buildInfoKeys += name
+  )
diff --git a/sbt/src/sbt-test/project/plusequals/project/XBuildInfoPlugin.scala b/sbt/src/sbt-test/project/plusequals/project/XBuildInfoPlugin.scala
new file mode 100644
index 000000000..b401e079b
--- /dev/null
+++ b/sbt/src/sbt-test/project/plusequals/project/XBuildInfoPlugin.scala
@@ -0,0 +1,32 @@
+import sbt._
+import Keys._
+
+object XBuildInfoPlugin extends sbt.AutoPlugin {
+  override def requires = plugins.JvmPlugin
+
+  object autoImport {
+    lazy val buildInfoKeys = settingKey[Seq[BuildInfoKey.Entry[_]]]("Entries for build info.")
+  }
+  import autoImport._
+
+  override def projectSettings: Seq[Def.Setting[_]] = Seq(
+    buildInfoKeys := Seq(name, version, scalaVersion, sbtVersion),
+  )
+}
+
+object BuildInfoKey {
+  implicit def setting[A](key: SettingKey[A]): Entry[A] = Setting(key)
+  implicit def task[A](key: TaskKey[A]): Entry[A] = Task(key)
+  def apply[A](key: SettingKey[A]): Entry[A] = Setting(key)
+  def apply[A](key: TaskKey[A]): Entry[A] = Task(key)
+
+  case class Setting[A](scoped: SettingKey[A]) extends Entry[A] {
+    def manifest = scoped.key.manifest
+  }
+  case class Task[A](scoped: TaskKey[A]) extends Entry[A] {
+    def manifest = scoped.key.manifest.typeArguments.head.asInstanceOf[Manifest[A]]
+  }
+  sealed trait Entry[A] {
+    def manifest: Manifest[A]
+  }
+}
diff --git a/sbt/src/sbt-test/apiinfo/basic/test b/sbt/src/sbt-test/project/plusequals/test
similarity index 100%
rename from sbt/src/sbt-test/apiinfo/basic/test
rename to sbt/src/sbt-test/project/plusequals/test
diff --git a/sbt/src/sbt-test/project/provided/build.sbt b/sbt/src/sbt-test/project/provided/build.sbt
index ae80958f7..af6bf0a3f 100644
--- a/sbt/src/sbt-test/project/provided/build.sbt
+++ b/sbt/src/sbt-test/project/provided/build.sbt
@@ -1,38 +1,27 @@
-import sbt.internal.inc.classpath.ClasspathUtilities
+val rootRef = LocalProject("root")
+val sub = project
+val superRoot = project in file("super") dependsOn rootRef
 
-lazy val superRoot = (project in file("super")).
-  dependsOn(rootRef)
+val root = project in file(".") dependsOn (sub % "provided->test") settings (
+  TaskKey[Unit]("check") := {
+    check0((fullClasspath in (sub, Test)).value, "sub test", true)
+    check0((fullClasspath in (superRoot, Compile)).value, "superRoot main", false)
+    check0((fullClasspath in (rootRef, Compile)).value, "root main", true)
+    check0((fullClasspath in (rootRef, Runtime)).value, "root runtime", false)
+    check0((fullClasspath in (rootRef, Test)).value, "root test", true)
+  }
+)
 
-lazy val root = (project in file(".")).
-  dependsOn(sub % "provided->test").
-  settings(
-    rootSettings
-  )
-
-lazy val sub = project
-
-lazy val rootRef = LocalProject("root")
-
-def rootSettings = (TaskKey[Unit]("check") := checkTask.value)
-def checkTask = (fullClasspath in (rootRef, Compile), fullClasspath in (rootRef, Runtime), fullClasspath in (rootRef, Test), fullClasspath in (sub, Test), fullClasspath in (superRoot, Compile)) map { (rc, rr, rt, st, pr) =>
-  check0(st, "sub test", true)
-  check0(pr, "superRoot main", false)
-  check0(rc, "root main", true)
-  check0(rr, "root runtime", false)
-  check0(rt, "root test", true)
-}
-
-def check0(cp: Seq[Attributed[File]], label: String, shouldSucceed: Boolean): Unit =
-{
+def check0(cp: Seq[Attributed[File]], label: String, shouldSucceed: Boolean): Unit = {
+  import sbt.internal.inc.classpath.ClasspathUtilities
   val loader = ClasspathUtilities.toLoader(cp.files)
   println("Checking " + label)
   val err = try { Class.forName("org.example.ProvidedTest", false, loader); None }
   catch { case e: Exception => Some(e) }
 
-  (err, shouldSucceed) match
-  {
+  (err, shouldSucceed) match {
     case (None, true) | (Some(_), false) => ()
-    case (None, false) => sys.error("Expected failure")
-    case (Some(x), true) => throw x
+    case (None, false)                   => sys.error("Expected failure")
+    case (Some(x), true)                 => throw x
   }
 }
diff --git a/sbt/src/sbt-test/project/sbt-composite-projects/build.sbt b/sbt/src/sbt-test/project/sbt-composite-projects/build.sbt
new file mode 100644
index 000000000..1537b2610
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-composite-projects/build.sbt
@@ -0,0 +1,36 @@
+import sbt.internal.AddSettings
+import sbt.CompositeProject
+
+lazy val check = taskKey[Unit]("check")
+
+// Based on sbt-file-projects test
+lazy val foo = new CompositeProject
+{
+  val jvm = Project.apply("jvm", new File("jvm")).settings(version := "0.1.0") // this one needs to win
+  val js = Project.apply("js", new File("js")).settings(version := "0.1.0") // this one needs to win
+  def componentProjects: Seq[Project] = Seq(jvm, js)
+}
+
+lazy val fooJS = foo.js
+lazy val fooJVM = foo.jvm
+
+lazy val bar = project
+  .dependsOn(foo.jvm)
+
+val g = taskKey[Unit]("A task in the root project")
+g := println("Hello.")
+
+
+check := {
+  val verJvm = (version in foo.jvm).?.value
+  assert (verJvm == Some("0.1.0"))
+
+  val verFooJvm = (version in fooJVM).?.value
+  assert (verFooJvm == Some("0.1.0"))
+
+  val verJs = (version in foo.js).?.value
+  assert (verJs == Some("0.1.0"))
+
+  val verFooJs = (version in fooJS).?.value
+  assert (verFooJs == Some("0.1.0"))
+}
diff --git a/sbt/src/sbt-test/project/sbt-file-projects/changes/Basic.sbt b/sbt/src/sbt-test/project/sbt-composite-projects/changes/basic.sbt
similarity index 100%
rename from sbt/src/sbt-test/project/sbt-file-projects/changes/Basic.sbt
rename to sbt/src/sbt-test/project/sbt-composite-projects/changes/basic.sbt
diff --git a/sbt/src/sbt-test/project/sbt-composite-projects/changes/shadow.sbt b/sbt/src/sbt-test/project/sbt-composite-projects/changes/shadow.sbt
new file mode 100644
index 000000000..0713e7f4b
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-composite-projects/changes/shadow.sbt
@@ -0,0 +1,36 @@
+import sbt.internal.AddSettings
+import sbt.CompositeProject
+
+lazy val check = taskKey[Unit]("check")
+
+// Based on sbt-file-projects test
+lazy val foo = new CompositeProject
+{
+  val jvm = Project.apply("jvm", new File("jvm")).settings(version := "0.1.0")
+  val js = Project.apply("js", new File("js")).settings(version := "0.1.0") // this one needs to win
+  def componentProjects: Seq[Project] = Seq(jvm, js)
+}
+
+lazy val fooJS = foo.js
+lazy val fooJVM = foo.jvm.settings(version := "0.2.0") // this one needs to win
+
+lazy val bar = project
+  .dependsOn(foo.jvm)
+
+val g = taskKey[Unit]("A task in the root project")
+g := println("Hello.")
+
+
+check := {
+  val verJvm = (version in foo.jvm).?.value
+  assert (verJvm == Some("0.2.0"))
+
+  val verFooJvm = (version in fooJVM).?.value
+  assert (verFooJvm == Some("0.2.0"))
+
+  val verJs = (version in foo.js).?.value
+  assert (verJs == Some("0.1.0"))
+
+  val verFooJs = (version in fooJS).?.value
+  assert (verFooJs == Some("0.1.0"))
+}
diff --git a/sbt/src/sbt-test/project/sbt-composite-projects/changes/shadowLazy.sbt b/sbt/src/sbt-test/project/sbt-composite-projects/changes/shadowLazy.sbt
new file mode 100644
index 000000000..492fbd621
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-composite-projects/changes/shadowLazy.sbt
@@ -0,0 +1,37 @@
+import sbt.internal.AddSettings
+import sbt.CompositeProject
+
+lazy val check = taskKey[Unit]("check")
+
+lazy val fooJS = foo.js.settings(version := "0.2.1") // this one needs to win
+
+// Based on sbt-file-projects test
+lazy val foo = new CompositeProject
+{
+  val jvm = Project.apply("jvm", new File("jvm")).settings(version := "0.1.0")
+  val js = Project.apply("js", new File("js")).settings(version := "0.1.0")
+  def componentProjects: Seq[Project] = Seq(jvm, js)
+}
+
+lazy val fooJVM = foo.jvm.settings(version := "0.2.0") // this one needs to win
+
+lazy val bar = project
+  .dependsOn(foo.jvm)
+
+val g = taskKey[Unit]("A task in the root project")
+g := println("Hello.")
+
+
+check := {
+  val verJvm = (version in foo.jvm).?.value
+  assert (verJvm == Some("0.2.0"))
+
+  val verFooJvm = (version in fooJVM).?.value
+  assert (verFooJvm == Some("0.2.0"))
+
+  val verJs = (version in foo.js).?.value
+  assert (verJs == Some("0.2.1"))
+
+  val verFooJs = (version in fooJS).?.value
+  assert (verFooJs == Some("0.2.1"))
+}
diff --git a/sbt/src/sbt-test/project/sbt-composite-projects/js/build.sbt b/sbt/src/sbt-test/project/sbt-composite-projects/js/build.sbt
new file mode 100644
index 000000000..0ddd49e30
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-composite-projects/js/build.sbt
@@ -0,0 +1,2 @@
+val h = taskKey[Unit]("A task in project 'js'")
+h := println("Hello.")
diff --git a/sbt/src/sbt-test/source-dependencies/relative-source-error/src/A.scala b/sbt/src/sbt-test/project/sbt-composite-projects/jvm/A.scala
similarity index 100%
rename from sbt/src/sbt-test/source-dependencies/relative-source-error/src/A.scala
rename to sbt/src/sbt-test/project/sbt-composite-projects/jvm/A.scala
diff --git a/sbt/src/sbt-test/project/sbt-composite-projects/jvm/a.sbt b/sbt/src/sbt-test/project/sbt-composite-projects/jvm/a.sbt
new file mode 100644
index 000000000..9b73a55bf
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-composite-projects/jvm/a.sbt
@@ -0,0 +1,2 @@
+val aa = taskKey[Unit]("A task in the 'jvm' project")
+aa := println("Hello.")
diff --git a/sbt/src/sbt-test/project/sbt-composite-projects/other.sbt b/sbt/src/sbt-test/project/sbt-composite-projects/other.sbt
new file mode 100644
index 000000000..94e5f2363
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-composite-projects/other.sbt
@@ -0,0 +1 @@
+val c = project
diff --git a/sbt/src/sbt-test/project/sbt-composite-projects/test b/sbt/src/sbt-test/project/sbt-composite-projects/test
new file mode 100644
index 000000000..34bc8097d
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-composite-projects/test
@@ -0,0 +1,40 @@
+> g
+-> root/compile
+> jvm/compile
+> jvm/aa
+> js/compile
+> js/h
+> c/compile
+> bar/compile
+
+$ copy-file changes/basic.sbt basic.sbt
+> reload
+> g
+> root/compile
+> jvm/compile
+> jvm/aa
+> js/compile
+> js/h
+> c/compile
+> bar/compile
+> check
+
+$ copy-file changes/shadow.sbt build.sbt
+> reload
+> jvm/compile
+> jvm/aa
+> js/compile
+> js/h
+> c/compile
+> bar/compile
+> check
+
+$ copy-file changes/shadowLazy.sbt build.sbt
+> reload
+> jvm/compile
+> jvm/aa
+> js/compile
+> js/h
+> c/compile
+> bar/compile
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/sbt-file-projects/a/a.sbt b/sbt/src/sbt-test/project/sbt-file-projects/a/a.sbt
index dd33a306a..67966f6d2 100644
--- a/sbt/src/sbt-test/project/sbt-file-projects/a/a.sbt
+++ b/sbt/src/sbt-test/project/sbt-file-projects/a/a.sbt
@@ -1,4 +1,2 @@
-
 val aa = taskKey[Unit]("A task in the 'a' project")
-
 aa := println("Hello.")
diff --git a/sbt/src/sbt-test/project/sbt-file-projects/b/build.sbt b/sbt/src/sbt-test/project/sbt-file-projects/b/build.sbt
index 0c5fae53d..3c7dc5056 100644
--- a/sbt/src/sbt-test/project/sbt-file-projects/b/build.sbt
+++ b/sbt/src/sbt-test/project/sbt-file-projects/b/build.sbt
@@ -1,4 +1,2 @@
-
 val h = taskKey[Unit]("A task in project 'b'")
-
 h := println("Hello.")
diff --git a/sbt/src/sbt-test/project/sbt-file-projects/build.sbt b/sbt/src/sbt-test/project/sbt-file-projects/build.sbt
index 0de1d3480..dbc0dbfe9 100644
--- a/sbt/src/sbt-test/project/sbt-file-projects/build.sbt
+++ b/sbt/src/sbt-test/project/sbt-file-projects/build.sbt
@@ -1,12 +1,7 @@
 import sbt.internal.AddSettings
 
-val a = "a"
-val f = file("a")
+val a = project
+val b = project
+
 val g = taskKey[Unit]("A task in the root project")
-
-val p = Project(a, f).
-  settingSets(AddSettings.autoPlugins, AddSettings.sbtFiles( file("a.sbt") ))
-
-val b = (project in file("b"))
-
 g := println("Hello.")
diff --git a/sbt/src/sbt-test/project/sbt-file-projects/changes/basic.sbt b/sbt/src/sbt-test/project/sbt-file-projects/changes/basic.sbt
new file mode 100644
index 000000000..c128b140e
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-file-projects/changes/basic.sbt
@@ -0,0 +1 @@
+lazy val root = (project in file("."))
diff --git a/sbt/src/sbt-test/project/sbt-file-projects/test b/sbt/src/sbt-test/project/sbt-file-projects/test
index d7bf3e913..dbf2e5289 100644
--- a/sbt/src/sbt-test/project/sbt-file-projects/test
+++ b/sbt/src/sbt-test/project/sbt-file-projects/test
@@ -1,4 +1,3 @@
-# nothing in project/
 > g
 -> root/compile
 > a/compile
@@ -7,7 +6,7 @@
 > b/h
 > c/compile
 
-$ copy-file changes/Basic.sbt basic.sbt
+$ copy-file changes/basic.sbt basic.sbt
 > reload
 > g
 > root/compile
diff --git a/sbt/src/sbt-test/project/sbt-version-change/build.sbt b/sbt/src/sbt-test/project/sbt-version-change/build.sbt
new file mode 100644
index 000000000..f0dbd39a1
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-version-change/build.sbt
@@ -0,0 +1,8 @@
+TaskKey[Unit]("checkSbtVersionWarning") := {
+	val state = Keys.state.value
+	val logging = state.globalLogging
+	val currVersion = state.configuration.provider.id.version()
+	val contents = IO.read(logging.backing.file)
+	assert(contents.contains(s"""sbt version mismatch, using: $currVersion, in build.properties: "1.1.1", use 'reboot' to use the new value."""))
+	()
+}
diff --git a/sbt/src/sbt-test/project/sbt-version-change/changes/build.properties b/sbt/src/sbt-test/project/sbt-version-change/changes/build.properties
new file mode 100644
index 000000000..9f782f704
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-version-change/changes/build.properties
@@ -0,0 +1 @@
+sbt.version=1.1.1
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/sbt-version-change/test b/sbt/src/sbt-test/project/sbt-version-change/test
new file mode 100644
index 000000000..e8efe77c5
--- /dev/null
+++ b/sbt/src/sbt-test/project/sbt-version-change/test
@@ -0,0 +1,4 @@
+> about
+$ copy-file changes/build.properties project/build.properties
+> reload
+> checkSbtVersionWarning
diff --git a/sbt/src/sbt-test/project/scala3-console-project/build.sbt b/sbt/src/sbt-test/project/scala3-console-project/build.sbt
new file mode 100644
index 000000000..208b8c684
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-console-project/build.sbt
@@ -0,0 +1,3 @@
+ThisBuild / scalaVersion := "3.0.0-M2"
+
+lazy val root = project.in(file("."))
diff --git a/sbt/src/sbt-test/project/scala3-console-project/test b/sbt/src/sbt-test/project/scala3-console-project/test
new file mode 100644
index 000000000..b80db65f1
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-console-project/test
@@ -0,0 +1 @@
+> consoleProject
diff --git a/sbt/src/sbt-test/project/scala3-example-project/LICENSE b/sbt/src/sbt-test/project/scala3-example-project/LICENSE
new file mode 100644
index 000000000..728844ee3
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-example-project/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2015 The dotty-example-project contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/sbt/src/sbt-test/project/scala3-example-project/README.md b/sbt/src/sbt-test/project/scala3-example-project/README.md
new file mode 100644
index 000000000..daa544226
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-example-project/README.md
@@ -0,0 +1 @@
+Cut-n-pasted from https://github.com/scala/scala3-example-project/tree/353ccef820699f20eb012420a9deb28814481031
diff --git a/sbt/src/sbt-test/project/scala3-example-project/build.sbt b/sbt/src/sbt-test/project/scala3-example-project/build.sbt
new file mode 100644
index 000000000..14f3f6017
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-example-project/build.sbt
@@ -0,0 +1 @@
+ThisBuild / scalaVersion := "3.0.0-M3"
diff --git a/sbt/src/sbt-test/project/scala3-example-project/src/main/scala-3/Main.scala b/sbt/src/sbt-test/project/scala3-example-project/src/main/scala-3/Main.scala
new file mode 100644
index 000000000..8a44ae4ef
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-example-project/src/main/scala-3/Main.scala
@@ -0,0 +1,16 @@
+
+object Main {
+
+  def main(args: Array[String]): Unit = {
+
+    runExample("Trait Params")(TraitParams.test)
+
+  }
+
+  private def runExample(name: String)(f: => Unit) = {
+    println(Console.MAGENTA + s"$name example:" + Console.RESET)
+    f
+    println()
+  }
+
+}
diff --git a/sbt/src/sbt-test/project/scala3-example-project/src/main/scala-3/TraitParams.scala b/sbt/src/sbt-test/project/scala3-example-project/src/main/scala-3/TraitParams.scala
new file mode 100644
index 000000000..1ca8d7c42
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-example-project/src/main/scala-3/TraitParams.scala
@@ -0,0 +1,21 @@
+/**
+ * Trait Parameters: https://dotty.epfl.ch/docs/reference/other-new-features/trait-parameters.html
+ */
+object TraitParams {
+
+  trait Base(val msg: String)
+  class A extends Base("Hello")
+  class B extends Base("Dotty!")
+
+  // Union types only exist in Dotty, so there's no chance that this will accidentally be compiled with Scala 2
+  private def printMessages(msgs: (A | B)*) = println(msgs.map(_.msg).mkString(" "))
+
+  def test: Unit = {
+
+    printMessages(new A, new B)
+
+    // Sanity check the classpath: this won't run if the dotty jar is not present.
+    val x: Int => Int = z => z
+    x(1)
+  }
+}
diff --git a/sbt/src/sbt-test/project/scala3-example-project/test b/sbt/src/sbt-test/project/scala3-example-project/test
new file mode 100644
index 000000000..62ea636c1
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-example-project/test
@@ -0,0 +1 @@
+> run
diff --git a/sbt/src/sbt-test/project/scala3-instance-loader/build.sbt b/sbt/src/sbt-test/project/scala3-instance-loader/build.sbt
new file mode 100644
index 000000000..53bf8a0d3
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-instance-loader/build.sbt
@@ -0,0 +1,13 @@
+ThisBuild / scalaVersion := "3.0.0-M3"
+
+lazy val check = taskKey[Unit]("check the Scala 3 instance class loader")
+
+lazy val xsbtiClass = classOf[xsbti.compile.Compilers]
+
+check := {
+  val scala3Loader = scalaInstance.value.loader
+  assert(
+    scala3Loader.loadClass(xsbtiClass.getCanonicalName) == xsbtiClass,
+    "The Scala 3 instance classloader does not load the same `xsbti` classes than sbt"
+  )
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/scala3-instance-loader/test b/sbt/src/sbt-test/project/scala3-instance-loader/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-instance-loader/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/project/scala3-sandwich-sjs/app/src/main/scala/app/Main.scala b/sbt/src/sbt-test/project/scala3-sandwich-sjs/app/src/main/scala/app/Main.scala
new file mode 100644
index 000000000..e3a0fa2ce
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich-sjs/app/src/main/scala/app/Main.scala
@@ -0,0 +1,9 @@
+package app
+
+import mylib._
+
+object Main {
+  def main(args: Array[String]): Unit = {
+    println(MyLib.square(5))
+  }
+}
diff --git a/sbt/src/sbt-test/project/scala3-sandwich-sjs/build.sbt b/sbt/src/sbt-test/project/scala3-sandwich-sjs/build.sbt
new file mode 100644
index 000000000..01e81e167
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich-sjs/build.sbt
@@ -0,0 +1,15 @@
+ThisBuild / scalaVersion := "2.13.4"
+ThisBuild / scalacOptions += "-Ytasty-reader"
+
+lazy val scala3code = project
+  .enablePlugins(ScalaJSPlugin)
+  .settings(scalaVersion := "3.0.0-M1")
+
+lazy val app = project
+  .enablePlugins(ScalaJSPlugin)
+  .dependsOn(scala3code)
+  .settings(
+    scalaVersion := "2.13.4",
+    scalacOptions += "-Ytasty-reader",
+    scalaJSUseMainModuleInitializer := true
+  )
diff --git a/sbt/src/sbt-test/project/scala3-sandwich-sjs/project/plugins.sbt b/sbt/src/sbt-test/project/scala3-sandwich-sjs/project/plugins.sbt
new file mode 100644
index 000000000..8f1d0ac9b
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich-sjs/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.3.1")
diff --git a/sbt/src/sbt-test/project/scala3-sandwich-sjs/scala3code/src/main/scala/mylib/MyLib.scala b/sbt/src/sbt-test/project/scala3-sandwich-sjs/scala3code/src/main/scala/mylib/MyLib.scala
new file mode 100644
index 000000000..ae2f3af75
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich-sjs/scala3code/src/main/scala/mylib/MyLib.scala
@@ -0,0 +1,5 @@
+package mylib
+
+object MyLib {
+  def square(x: Int): Int = x * x
+}
diff --git a/sbt/src/sbt-test/project/scala3-sandwich-sjs/test b/sbt/src/sbt-test/project/scala3-sandwich-sjs/test
new file mode 100644
index 000000000..63092ffa4
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich-sjs/test
@@ -0,0 +1 @@
+> app/run
diff --git a/sbt/src/sbt-test/project/scala3-sandwich/bar-app/D.scala b/sbt/src/sbt-test/project/scala3-sandwich/bar-app/D.scala
new file mode 100644
index 000000000..b937ae06c
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich/bar-app/D.scala
@@ -0,0 +1,5 @@
+package example
+
+object D {
+  val x = C.x
+}
diff --git a/sbt/src/sbt-test/project/scala3-sandwich/bar-core/C.scala b/sbt/src/sbt-test/project/scala3-sandwich/bar-core/C.scala
new file mode 100644
index 000000000..4d4fcc6df
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich/bar-core/C.scala
@@ -0,0 +1,5 @@
+package example
+
+object C {
+  val x = 1
+}
diff --git a/sbt/src/sbt-test/project/scala3-sandwich/build.sbt b/sbt/src/sbt-test/project/scala3-sandwich/build.sbt
new file mode 100644
index 000000000..69a2ca58f
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich/build.sbt
@@ -0,0 +1,23 @@
+ThisBuild / scalaVersion := "3.0.0-M1"
+
+lazy val scala213 = "2.13.4"
+
+lazy val root = (project in file("."))
+  .aggregate(fooApp, fooCore, barApp, barCore)
+
+lazy val fooApp = (project in file("foo-app"))
+  .dependsOn(fooCore)
+
+lazy val fooCore = (project in file("foo-core"))
+  .settings(
+    scalaVersion := scala213,
+  )
+
+lazy val barApp = (project in file("bar-app"))
+  .dependsOn(barCore)
+  .settings(
+    scalaVersion := scala213,
+    scalacOptions += "-Ytasty-reader"
+  )
+
+lazy val barCore = (project in file("bar-core"))
diff --git a/sbt/src/sbt-test/project/scala3-sandwich/foo-app/B.scala b/sbt/src/sbt-test/project/scala3-sandwich/foo-app/B.scala
new file mode 100644
index 000000000..ed82c07d1
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich/foo-app/B.scala
@@ -0,0 +1,5 @@
+package example
+
+object B {
+  val x = A.x
+}
diff --git a/sbt/src/sbt-test/project/scala3-sandwich/foo-core/A.scala b/sbt/src/sbt-test/project/scala3-sandwich/foo-core/A.scala
new file mode 100644
index 000000000..be4b82a9f
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich/foo-core/A.scala
@@ -0,0 +1,5 @@
+package example
+
+object A {
+  val x = 1
+}
diff --git a/sbt/src/sbt-test/project/scala3-sandwich/test b/sbt/src/sbt-test/project/scala3-sandwich/test
new file mode 100644
index 000000000..19ccc5787
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-sandwich/test
@@ -0,0 +1,3 @@
+> fooApp/compile
+
+> barApp/compile
diff --git a/sbt/src/sbt-test/project/scala3-semanticdb/LICENSE b/sbt/src/sbt-test/project/scala3-semanticdb/LICENSE
new file mode 100644
index 000000000..728844ee3
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-semanticdb/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2015 The dotty-example-project contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/sbt/src/sbt-test/project/scala3-semanticdb/README.md b/sbt/src/sbt-test/project/scala3-semanticdb/README.md
new file mode 100644
index 000000000..daa544226
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-semanticdb/README.md
@@ -0,0 +1 @@
+Cut-n-pasted from https://github.com/scala/scala3-example-project/tree/353ccef820699f20eb012420a9deb28814481031
diff --git a/sbt/src/sbt-test/project/scala3-semanticdb/build.sbt b/sbt/src/sbt-test/project/scala3-semanticdb/build.sbt
new file mode 100644
index 000000000..7b302985e
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-semanticdb/build.sbt
@@ -0,0 +1,13 @@
+ThisBuild / scalaVersion := "3.0.0-M2"
+ThisBuild / semanticdbEnabled := true
+
+lazy val check = taskKey[Unit]("check the Scala 3 semanticdb files")
+
+Compile / check := checkTask("Main.semanticdb")
+Test / check := checkTask("Test.semanticdb")
+
+def checkTask(fileName: String): Def.Initialize[Task[Unit]] = Def.task {
+  val _ = compile.value
+  val dir = semanticdbTargetRoot.value
+  assert(IO.listFiles(dir).exists(_.getName == fileName), s"$fileName is missing")
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/scala3-semanticdb/src/main/scala/Main.scala b/sbt/src/sbt-test/project/scala3-semanticdb/src/main/scala/Main.scala
new file mode 100644
index 000000000..9deb66d0b
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-semanticdb/src/main/scala/Main.scala
@@ -0,0 +1,8 @@
+
+object Main {
+  val msg = "Hello, World!"
+
+  def main(args: Array[String]): Unit = {
+    println(msg)
+  }
+}
diff --git a/sbt/src/sbt-test/project/scala3-semanticdb/src/test/scala/Test.scala b/sbt/src/sbt-test/project/scala3-semanticdb/src/test/scala/Test.scala
new file mode 100644
index 000000000..f197443c9
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-semanticdb/src/test/scala/Test.scala
@@ -0,0 +1,3 @@
+object Test {
+  assert(Main.msg == "Hello, World!")
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/scala3-semanticdb/test b/sbt/src/sbt-test/project/scala3-semanticdb/test
new file mode 100644
index 000000000..699323992
--- /dev/null
+++ b/sbt/src/sbt-test/project/scala3-semanticdb/test
@@ -0,0 +1,3 @@
+> Compile / check
+> Test / check
+
diff --git a/sbt/src/sbt-test/project/scripted-bad-def/test b/sbt/src/sbt-test/project/scripted-bad-def/test
index 3845dd842..119d567f2 100644
--- a/sbt/src/sbt-test/project/scripted-bad-def/test
+++ b/sbt/src/sbt-test/project/scripted-bad-def/test
@@ -9,5 +9,5 @@ $ delete bad.sbt
 
 # due to the previous reload failing, this will force the project to be reloaded first
 # and this should then succeed
-> help
+> about
 
diff --git a/sbt/src/sbt-test/project/scripted-dependencies/build.sbt b/sbt/src/sbt-test/project/scripted-dependencies/build.sbt
new file mode 100644
index 000000000..088ebffd1
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-dependencies/build.sbt
@@ -0,0 +1,5 @@
+lazy val root = (project in file("."))
+  .enablePlugins(SbtPlugin)
+  .dependsOn(lib)
+
+lazy val lib = project in file("lib")
diff --git a/sbt/src/sbt-test/project/scripted-dependencies/project/plugins.sbt b/sbt/src/sbt-test/project/scripted-dependencies/project/plugins.sbt
new file mode 100644
index 000000000..529e7d656
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-dependencies/project/plugins.sbt
@@ -0,0 +1,3 @@
+libraryDependencies += {
+  "org.scala-sbt" %% "scripted-plugin" % sbtVersion.value
+}
diff --git a/sbt/src/sbt-test/project/scripted-dependencies/test b/sbt/src/sbt-test/project/scripted-dependencies/test
new file mode 100644
index 000000000..fdf3c0393
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-dependencies/test
@@ -0,0 +1,2 @@
+$ copy-file test-files/test src/sbt-test/group/name/test
+> scripted
diff --git a/sbt/src/sbt-test/project/scripted-dependencies/test-files/test b/sbt/src/sbt-test/project/scripted-dependencies/test-files/test
new file mode 100644
index 000000000..5df2af1f3
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-dependencies/test-files/test
@@ -0,0 +1 @@
+> compile
diff --git a/sbt/src/sbt-test/project/scripted-plugin/build.sbt b/sbt/src/sbt-test/project/scripted-plugin/build.sbt
new file mode 100644
index 000000000..6c91c26b3
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-plugin/build.sbt
@@ -0,0 +1,2 @@
+lazy val root = (project in file("."))
+  .enablePlugins(SbtPlugin)
diff --git a/sbt/src/sbt-test/project/scripted-plugin/test b/sbt/src/sbt-test/project/scripted-plugin/test
index ee1685ab1..3407d7bc3 100644
--- a/sbt/src/sbt-test/project/scripted-plugin/test
+++ b/sbt/src/sbt-test/project/scripted-plugin/test
@@ -4,3 +4,6 @@ $ copy-file changes/Success.scala src/sbt-test/group/demo/changes/Success.scala
 $ copy-file changes/fail src/sbt-test/group/fail/test
 > scripted group/demo
 -> scripted group/fail
+
+> set scriptedBatchExecution := true
+> scripted group/demo
diff --git a/sbt/src/sbt-test/project/scripted-skip-incompatible/build.sbt b/sbt/src/sbt-test/project/scripted-skip-incompatible/build.sbt
new file mode 100644
index 000000000..6c91c26b3
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-skip-incompatible/build.sbt
@@ -0,0 +1,2 @@
+lazy val root = (project in file("."))
+  .enablePlugins(SbtPlugin)
diff --git a/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/Fail.scala b/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/Fail.scala
new file mode 100644
index 000000000..f011d53a4
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/Fail.scala
@@ -0,0 +1 @@
+object Skipped {
diff --git a/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/build.properties b/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/build.properties
new file mode 100644
index 000000000..a8c2f849b
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/build.properties
@@ -0,0 +1 @@
+sbt.version=0.12.0
diff --git a/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/test b/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/test
new file mode 100644
index 000000000..4ed0b761f
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-skip-incompatible/changes/test
@@ -0,0 +1,2 @@
+$ copy-file changes/Fail.scala Skipped.scala
+> compile
diff --git a/sbt/src/sbt-test/project/scripted-skip-incompatible/test b/sbt/src/sbt-test/project/scripted-skip-incompatible/test
new file mode 100644
index 000000000..704535d5b
--- /dev/null
+++ b/sbt/src/sbt-test/project/scripted-skip-incompatible/test
@@ -0,0 +1,17 @@
+# Setup failing test that should be skipped when tests are discovered
+$ copy-file changes/Fail.scala src/sbt-test/group/skipped/changes/Fail.scala
+$ copy-file changes/build.properties src/sbt-test/group/skipped/project/build.properties
+$ copy-file changes/test src/sbt-test/group/skipped/test
+
+# Should fail when run explicitly
+-> scripted group/skipped
+
+# Should be skipped when discovered
+> scripted
+
+# Setup the same test without a project/build.properties file
+$ copy-file changes/Fail.scala src/sbt-test/group/not-skipped/changes/Fail.scala
+$ copy-file changes/test src/sbt-test/group/not-skipped/test
+
+# Running discovered tests should fail
+-> scripted
diff --git a/sbt/src/sbt-test/project/scripted13/build.sbt b/sbt/src/sbt-test/project/scripted13/build.sbt
index 45efde4f0..fd2fa6ebe 100644
--- a/sbt/src/sbt-test/project/scripted13/build.sbt
+++ b/sbt/src/sbt-test/project/scripted13/build.sbt
@@ -1,11 +1 @@
-scriptedSettings
-
-scriptedSbt := sbtVersion.value
-
-sbtPlugin := true
-
-sbtVersion in Global := "0.13.0-Beta2"
-
-scalaVersion in Global := "2.10.2-RC2"
-
-offline := true
+enablePlugins(SbtPlugin)
diff --git a/sbt/src/sbt-test/project/scripted13/project/plugins.sbt b/sbt/src/sbt-test/project/scripted13/project/plugins.sbt
index a2a45d929..217d3d1a5 100644
--- a/sbt/src/sbt-test/project/scripted13/project/plugins.sbt
+++ b/sbt/src/sbt-test/project/scripted13/project/plugins.sbt
@@ -1,5 +1 @@
-libraryDependencies += {
-   "org.scala-sbt" %% "scripted-plugin" % sbtVersion.value
-}
-
 offline := true
diff --git a/sbt/src/sbt-test/project/scripted13/disabled b/sbt/src/sbt-test/project/scripted13/test
similarity index 50%
rename from sbt/src/sbt-test/project/scripted13/disabled
rename to sbt/src/sbt-test/project/scripted13/test
index 3d9d074ff..1617a03a4 100644
--- a/sbt/src/sbt-test/project/scripted13/disabled
+++ b/sbt/src/sbt-test/project/scripted13/test
@@ -1,5 +1,6 @@
-# This tests that this sbt scripted plugin can launch the next one
-# It is currently disabled because there is no next plugin version
+# This tests that this sbt scripted plugin can launch the previous one
+
+> ^^0.13.18
 
 $ copy-file changes/A.scala src/sbt-test/a/b/A.scala
 > scripted
diff --git a/sbt/src/sbt-test/project/semanticdb-version/build.sbt b/sbt/src/sbt-test/project/semanticdb-version/build.sbt
new file mode 100644
index 000000000..8b5c69c23
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb-version/build.sbt
@@ -0,0 +1,18 @@
+ThisBuild / scalaVersion := "2.12.13"
+ThisBuild / semanticdbEnabled := true
+ThisBuild / semanticdbVersion := "4.4.10"
+ThisBuild / semanticdbIncludeInJar := false
+
+lazy val root = (project in file("."))
+
+lazy val check = taskKey[Unit]("Checks the configured semanticdbVersion")
+
+check := {
+  val expected = Some("4.4.10")
+  val actual = allDependencies
+    .value
+    .find(_.name == "semanticdb-scalac")
+    .map(_.revision)
+
+  assert(actual == expected, s"Expected version to be $expected, was $actual")
+}
diff --git a/sbt/src/sbt-test/project/semanticdb-version/src/main/scala/foo/Test.scala b/sbt/src/sbt-test/project/semanticdb-version/src/main/scala/foo/Test.scala
new file mode 100644
index 000000000..0bf6e4111
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb-version/src/main/scala/foo/Test.scala
@@ -0,0 +1,7 @@
+package foo
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    println("hello world")
+  }
+}
diff --git a/sbt/src/sbt-test/project/semanticdb-version/test b/sbt/src/sbt-test/project/semanticdb-version/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb-version/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/project/semanticdb/build.sbt b/sbt/src/sbt-test/project/semanticdb/build.sbt
new file mode 100644
index 000000000..fc07b3748
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb/build.sbt
@@ -0,0 +1,30 @@
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / semanticdbEnabled := true
+ThisBuild / semanticdbIncludeInJar := true
+
+// see https://github.com/sbt/sbt/issues/5886
+lazy val check = taskKey[Unit]("Checks that scalacOptions have the same number of parameters across configurations")
+lazy val anyConfigInThisProject = ScopeFilter(configurations = inAnyConfiguration)
+
+lazy val Custom = config("custom").extend(Compile)
+lazy val SystemTest = config("st").extend(IntegrationTest)
+
+lazy val root = (project in file("."))
+  .configs(IntegrationTest, Custom, SystemTest)
+  .settings(
+    inConfig(IntegrationTest)(Defaults.testSettings ++ sbt.plugins.SemanticdbPlugin.configurationSettings),
+    inConfig(Custom)(Defaults.configSettings ++ sbt.plugins.SemanticdbPlugin.configurationSettings),
+    inConfig(SystemTest)(Defaults.testSettings ++ sbt.plugins.SemanticdbPlugin.configurationSettings),
+    check := {
+      val scalacOptionsCountsAcrossConfigs = scalacOptions.?.all(anyConfigInThisProject)
+        .value
+        .map(_.toSeq.flatten.size)
+        .filterNot(_ == 0)
+        .distinct
+      assert(
+        scalacOptionsCountsAcrossConfigs.size == 1,
+        s"Configurations expected to have the same number of scalacOptions but found different numbers: $scalacOptionsCountsAcrossConfigs"
+      )
+    }
+
+  )
diff --git a/sbt/src/sbt-test/project/semanticdb/src/custom/scala/foo/Custom.scala b/sbt/src/sbt-test/project/semanticdb/src/custom/scala/foo/Custom.scala
new file mode 100644
index 000000000..931f5db96
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb/src/custom/scala/foo/Custom.scala
@@ -0,0 +1,3 @@
+package foo
+
+object Custom
diff --git a/sbt/src/sbt-test/project/semanticdb/src/it/scala/foo/IntegrationTest.scala b/sbt/src/sbt-test/project/semanticdb/src/it/scala/foo/IntegrationTest.scala
new file mode 100644
index 000000000..ae24e8449
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb/src/it/scala/foo/IntegrationTest.scala
@@ -0,0 +1,3 @@
+package foo
+
+object IntegrationTest
diff --git a/sbt/src/sbt-test/project/semanticdb/src/main/scala/foo/Compile.scala b/sbt/src/sbt-test/project/semanticdb/src/main/scala/foo/Compile.scala
new file mode 100644
index 000000000..fdd81fb04
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb/src/main/scala/foo/Compile.scala
@@ -0,0 +1,7 @@
+package foo
+
+object Compile {
+  def main(args: Array[String]): Unit = {
+    println("hello world")
+  }
+}
diff --git a/sbt/src/sbt-test/project/semanticdb/src/st/scala/foo/SystemTest.scala b/sbt/src/sbt-test/project/semanticdb/src/st/scala/foo/SystemTest.scala
new file mode 100644
index 000000000..9076368f1
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb/src/st/scala/foo/SystemTest.scala
@@ -0,0 +1,3 @@
+package foo
+
+object SystemTest
diff --git a/sbt/src/sbt-test/project/semanticdb/src/test/scala/foo/Test.scala b/sbt/src/sbt-test/project/semanticdb/src/test/scala/foo/Test.scala
new file mode 100644
index 000000000..9775d073f
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb/src/test/scala/foo/Test.scala
@@ -0,0 +1,3 @@
+package foo
+
+object Test
diff --git a/sbt/src/sbt-test/project/semanticdb/test b/sbt/src/sbt-test/project/semanticdb/test
new file mode 100644
index 000000000..4d242e8e1
--- /dev/null
+++ b/sbt/src/sbt-test/project/semanticdb/test
@@ -0,0 +1,16 @@
+> compile
+$ exists target/scala-2.12/classes/META-INF/semanticdb/src/main/scala/foo/Compile.scala.semanticdb
+
+> test:compile
+$ exists target/scala-2.12/test-classes/META-INF/semanticdb/src/test/scala/foo/Test.scala.semanticdb
+
+> it:compile
+$ exists target/scala-2.12/it-classes/META-INF/semanticdb/src/it/scala/foo/IntegrationTest.scala.semanticdb
+
+> custom:compile
+$ exists target/scala-2.12/custom-classes/META-INF/semanticdb/src/custom/scala/foo/Custom.scala.semanticdb
+
+> st:compile
+$ exists target/scala-2.12/st-classes/META-INF/semanticdb/src/st/scala/foo/SystemTest.scala.semanticdb
+
+> check
diff --git a/sbt/src/sbt-test/project/session-update-from-cmd/project/Common.scala b/sbt/src/sbt-test/project/session-update-from-cmd/project/Common.scala
index b744f5c1f..423d628f6 100644
--- a/sbt/src/sbt-test/project/session-update-from-cmd/project/Common.scala
+++ b/sbt/src/sbt-test/project/session-update-from-cmd/project/Common.scala
@@ -1,4 +1,4 @@
-import sbt._, syntax._, Keys._
+import sbt._, Keys._
 
 import sbt.internal.SessionSettings
 
@@ -11,7 +11,7 @@ object Common {
   val UpdateK1 = Command.command("UpdateK1") { st: State =>
     val ex = Project extract st
     import ex._
-    val session2 = BuiltinCommands.setThis(st, ex, Seq(k1 := {}), """k1 := {
+    val session2 = BuiltinCommands.setThis(ex, Seq(k1 := {}), """k1 := {
     |//
     |//
     |}""".stripMargin).session
@@ -24,7 +24,7 @@ object Common {
   val UpdateK3 = Command.command("UpdateK3") { st: State =>
     val ex = Project extract st
     import ex._
-    val session2 = BuiltinCommands.setThis(st, ex, Seq(k3 := {}), """k3 := {
+    val session2 = BuiltinCommands.setThis(ex, Seq(k3 := {}), """k3 := {
                                                                     |//
                                                                     |//
                                                                     |}""".stripMargin).session
diff --git a/sbt/src/sbt-test/project/setting-macro/project/PureExpressionPlugin.scala b/sbt/src/sbt-test/project/setting-macro/project/PureExpressionPlugin.scala
new file mode 100644
index 000000000..f0eea984b
--- /dev/null
+++ b/sbt/src/sbt-test/project/setting-macro/project/PureExpressionPlugin.scala
@@ -0,0 +1,15 @@
+package pkgtest
+
+import sbt._, Keys._
+
+// https://github.com/scala/bug/issues/12112
+object PureExpressionPlugin extends AutoPlugin {
+  lazy val testPureExpression = taskKey[Unit]("")
+  override def projectSettings: Seq[Setting[_]] = {
+    testPureExpression := {
+      updateFull.value
+      (Compile / compile).value
+      (Test / test).value
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/project/setting-macro/project/plugins.sbt b/sbt/src/sbt-test/project/setting-macro/project/plugins.sbt
new file mode 100644
index 000000000..9674e9d5f
--- /dev/null
+++ b/sbt/src/sbt-test/project/setting-macro/project/plugins.sbt
@@ -0,0 +1 @@
+Compile / scalacOptions += "-Xfatal-warnings"
diff --git a/sbt/src/sbt-test/project/setting-order/a.sbt b/sbt/src/sbt-test/project/setting-order/a.sbt
new file mode 100644
index 000000000..02cd89214
--- /dev/null
+++ b/sbt/src/sbt-test/project/setting-order/a.sbt
@@ -0,0 +1 @@
+Compile / scalacOptions += "a"
diff --git a/sbt/src/sbt-test/project/setting-order/b.sbt b/sbt/src/sbt-test/project/setting-order/b.sbt
new file mode 100644
index 000000000..e2ae0f78a
--- /dev/null
+++ b/sbt/src/sbt-test/project/setting-order/b.sbt
@@ -0,0 +1 @@
+Compile / scalacOptions += "b"
diff --git a/sbt/src/sbt-test/project/setting-order/build.sbt b/sbt/src/sbt-test/project/setting-order/build.sbt
new file mode 100644
index 000000000..69d74540d
--- /dev/null
+++ b/sbt/src/sbt-test/project/setting-order/build.sbt
@@ -0,0 +1,12 @@
+val check = taskKey[Unit]("")
+
+lazy val root = (project in file("."))
+  .settings(
+    Compile / scalacOptions += "multi-project",
+    check := {
+      val xs = (Compile / scalacOptions).value
+      assert(xs.toList == List("multi-project", "a", "b", "bare", "c"), s"$xs")
+    }
+  )
+
+Compile / scalacOptions += "bare"
diff --git a/sbt/src/sbt-test/project/setting-order/c.sbt b/sbt/src/sbt-test/project/setting-order/c.sbt
new file mode 100644
index 000000000..07a70ce8d
--- /dev/null
+++ b/sbt/src/sbt-test/project/setting-order/c.sbt
@@ -0,0 +1 @@
+Compile / scalacOptions += "c"
diff --git a/sbt/src/sbt-test/project/setting-order/test b/sbt/src/sbt-test/project/setting-order/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/project/setting-order/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/project/source-plugins/build.sbt b/sbt/src/sbt-test/project/source-plugins/build.sbt
index 1e0d4c099..0b5906837 100644
--- a/sbt/src/sbt-test/project/source-plugins/build.sbt
+++ b/sbt/src/sbt-test/project/source-plugins/build.sbt
@@ -4,4 +4,4 @@ organization := "org.example"
 
 proguardSettings
 
-useJGit
\ No newline at end of file
+useJGit
diff --git a/sbt/src/sbt-test/project/source-plugins/pending b/sbt/src/sbt-test/project/source-plugins/pending
index 08a542bb3..360ba64e4 100644
--- a/sbt/src/sbt-test/project/source-plugins/pending
+++ b/sbt/src/sbt-test/project/source-plugins/pending
@@ -1,2 +1,2 @@
 # just need to verify it loads
-> help
\ No newline at end of file
+> about
diff --git a/sbt/src/sbt-test/project/source-plugins/project/plugins.sbt b/sbt/src/sbt-test/project/source-plugins/project/plugins.sbt
new file mode 100644
index 000000000..6dc6ae42e
--- /dev/null
+++ b/sbt/src/sbt-test/project/source-plugins/project/plugins.sbt
@@ -0,0 +1,7 @@
+lazy val plugins = (project in file("."))
+  .dependsOn(proguard, git)
+
+// e7b4732969c137db1b5
+// d4974f7362bf55d3f52
+lazy val proguard = uri("git://github.com/sbt/sbt-proguard.git#e7b4732969c137db1b5")
+lazy val git = uri("git://github.com/sbt/sbt-git.git#2e7c2503850698d60bb")
diff --git a/sbt/src/sbt-test/project/src-plugins/project/p.sbt b/sbt/src/sbt-test/project/src-plugins/project/p.sbt
index 09360a6a8..8d6251248 100644
--- a/sbt/src/sbt-test/project/src-plugins/project/p.sbt
+++ b/sbt/src/sbt-test/project/src-plugins/project/p.sbt
@@ -1,2 +1,2 @@
 lazy val root = (project in file(".")).
-  dependsOn(file("../plugin"))
+  dependsOn(RootProject(file("../plugin")))
diff --git a/sbt/src/sbt-test/project/subproject-dependson/build.sbt b/sbt/src/sbt-test/project/subproject-dependson/build.sbt
new file mode 100644
index 000000000..9782f67c4
--- /dev/null
+++ b/sbt/src/sbt-test/project/subproject-dependson/build.sbt
@@ -0,0 +1,11 @@
+val projA = project in file("projA")
+
+val projB = project in file("projB")
+
+lazy val check = taskKey[Unit]("Verifies expected build behavior")
+
+check := {
+  val projBDeps = (dependencyClasspath in (projB, Compile)).value.map(_.data)
+  val assertion = projBDeps.filter(_.getAbsolutePath.contains("projA")).nonEmpty
+  assert(assertion, "Unable to find projA classes in projB's dependency list")
+}
diff --git a/sbt/src/sbt-test/project/subproject-dependson/projA/build.sbt b/sbt/src/sbt-test/project/subproject-dependson/projA/build.sbt
new file mode 100644
index 000000000..2cc74591f
--- /dev/null
+++ b/sbt/src/sbt-test/project/subproject-dependson/projA/build.sbt
@@ -0,0 +1 @@
+name := "projA"
diff --git a/sbt/src/sbt-test/project/subproject-dependson/projB/build.sbt b/sbt/src/sbt-test/project/subproject-dependson/projB/build.sbt
new file mode 100644
index 000000000..732b88063
--- /dev/null
+++ b/sbt/src/sbt-test/project/subproject-dependson/projB/build.sbt
@@ -0,0 +1,3 @@
+name := "projB"
+
+dependsOn(LocalProject("projA"))
diff --git a/sbt/src/sbt-test/project/subproject-dependson/test b/sbt/src/sbt-test/project/subproject-dependson/test
new file mode 100644
index 000000000..a5912a391
--- /dev/null
+++ b/sbt/src/sbt-test/project/subproject-dependson/test
@@ -0,0 +1 @@
+> check
\ No newline at end of file
diff --git a/sbt/src/sbt-test/project/test-script-file/build.sbt b/sbt/src/sbt-test/project/test-script-file/build.sbt
new file mode 100644
index 000000000..c128b140e
--- /dev/null
+++ b/sbt/src/sbt-test/project/test-script-file/build.sbt
@@ -0,0 +1 @@
+lazy val root = (project in file("."))
diff --git a/sbt/src/sbt-test/project/test-script-file/test.script b/sbt/src/sbt-test/project/test-script-file/test.script
new file mode 100644
index 000000000..dfffb838b
--- /dev/null
+++ b/sbt/src/sbt-test/project/test-script-file/test.script
@@ -0,0 +1 @@
+> test
diff --git a/sbt/src/sbt-test/project/transitive-plugins/a/build.sbt b/sbt/src/sbt-test/project/transitive-plugins/a/build.sbt
deleted file mode 100644
index 9ee2cb6a7..000000000
--- a/sbt/src/sbt-test/project/transitive-plugins/a/build.sbt
+++ /dev/null
@@ -1,15 +0,0 @@
-publishTo := (baseDirectory in ThisBuild)(x =>
-	Some(Resolver.file("test-publish", x / "repo/"))
-).value
-
-resolvers += (baseDirectory in ThisBuild)(x =>
-	"test" at (x / "repo/").asURL.toString
-).value
-
-name := "demo1"
-
-organization := "org.example"
-
-version := "0.1"
-
-sbtPlugin := true
diff --git a/sbt/src/sbt-test/project/transitive-plugins/b/build.sbt b/sbt/src/sbt-test/project/transitive-plugins/b/build.sbt
deleted file mode 100644
index 57803aeb4..000000000
--- a/sbt/src/sbt-test/project/transitive-plugins/b/build.sbt
+++ /dev/null
@@ -1,17 +0,0 @@
-publishTo := (baseDirectory in ThisBuild)(x =>
-	Some(Resolver.file("test-publish", x / "repo"))
-).value
-
-resolvers += (baseDirectory in ThisBuild)(x =>
-	"test" at (x / "repo").asURL.toString
-).value
-
-name := "demo2"
-
-organization := "org.example"
-
-version := "0.2"
-
-sbtPlugin := true
-
-addSbtPlugin("org.example" % "demo1" % "0.1")
diff --git a/sbt/src/sbt-test/project/transitive-plugins/build.sbt b/sbt/src/sbt-test/project/transitive-plugins/build.sbt
index 5865cfb1a..a3a4057ec 100644
--- a/sbt/src/sbt-test/project/transitive-plugins/build.sbt
+++ b/sbt/src/sbt-test/project/transitive-plugins/build.sbt
@@ -1,15 +1,45 @@
+ThisBuild / organization := "org.example"
+ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache"
+
 lazy val root = (project in file("."))
-
-lazy val a = proj(project in file("a"))
-lazy val b = proj(project in file("b"))
-lazy val c = proj(project in file("c"))
-
-def proj(p: Project): Project =
-  p.settings(
-    ivyPaths := (baseDirectory in root, target in root)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))).value,
-    resolvers += (appConfiguration { app => // need this to resolve sbt
-      val ivyHome = Classpaths.bootIvyHome(app) getOrElse sys.error("Launcher did not provide the Ivy home directory.")
-      Resolver.file("real-local",  ivyHome / "local")(Resolver.ivyStylePatterns)
-    }).value,
-    resolvers += Resolver.typesafeIvyRepo("releases") // not sure why this isn't included by default
+  .settings(
+    commonSettings
+  )
+
+lazy val commonSettings = Seq(
+  ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")),
+  publishTo := Some(Resolver.file("test-publish", (baseDirectory in ThisBuild).value / "repo/")),
+  // to get sbt artifacts
+  resolvers += {
+    val ivyHome = Classpaths.bootIvyHome(appConfiguration.value) getOrElse sys.error("Launcher did not provide the Ivy home directory.")
+    Resolver.file("real-local",  ivyHome / "local")(Resolver.ivyStylePatterns)
+  },
+  resolvers += Resolver.mavenLocal,
+  resolvers += ("test-repo" at ((baseDirectory in ThisBuild).value / "repo/").asURL.toString)
+)
+
+lazy val a = (project in file("a"))
+  .enablePlugins(SbtPlugin)
+  .settings(
+    commonSettings,
+    name := "demo1",
+    version := "0.1"
+  )
+
+lazy val b = (project in file("b"))
+  .enablePlugins(SbtPlugin)
+  .settings(
+    commonSettings,
+    name := "demo2",
+    version := "0.2",
+    addSbtPlugin("org.example" % "demo1" % "0.1")
+  )
+
+lazy val c = (project in file("c"))
+  .enablePlugins(SbtPlugin)
+  .settings(
+    commonSettings,
+    name := "demo3",
+    version := "0.3",
+    addSbtPlugin("org.example" % "demo2" % "0.2")
   )
diff --git a/sbt/src/sbt-test/project/transitive-plugins/c/build.sbt b/sbt/src/sbt-test/project/transitive-plugins/c/build.sbt
deleted file mode 100644
index 53fca2b24..000000000
--- a/sbt/src/sbt-test/project/transitive-plugins/c/build.sbt
+++ /dev/null
@@ -1,19 +0,0 @@
-publishTo := (baseDirectory in ThisBuild)(x =>
-	Some(Resolver.file("test-publish", x / "repo"))
-).value
-
-resolvers += (baseDirectory in ThisBuild)(x =>
-	"test" at (x / "repo").asURL.toString
-).value
-
-name := "demo3"
-
-organization := "org.example"
-
-version := "0.3"
-
-sbtPlugin := true
-
-//addSbtPlugin("org.example" % "demo1" % "0.1")
-
-addSbtPlugin("org.example" % "demo2" % "0.2")
diff --git a/sbt/src/sbt-test/project/unified/build.sbt b/sbt/src/sbt-test/project/unified/build.sbt
new file mode 100644
index 000000000..fd6471758
--- /dev/null
+++ b/sbt/src/sbt-test/project/unified/build.sbt
@@ -0,0 +1,101 @@
+import sbt.internal.CommandStrings.{ inspectBrief, inspectDetailed }
+import sbt.internal.Inspect
+import sjsonnew._, BasicJsonProtocol._
+
+val uTest = "com.lihaoyi" %% "utest" % "0.5.3"
+
+val foo = taskKey[Int]("")
+val bar = taskKey[Int]("")
+val baz = inputKey[Unit]("")
+val buildInfo = taskKey[Seq[File]]("The task that generates the build info.")
+
+lazy val root = (project in file("."))
+  .settings(
+    Global / cancelable := true,
+    ThisBuild / scalaVersion := "2.12.3",
+    console / scalacOptions += "-deprecation",
+    Compile / console / scalacOptions += "-Ywarn-numeric-widen",
+    projA / Compile / console / scalacOptions += "-feature",
+    Zero / name := "foo",
+    Zero / Zero / name := "foo",
+    Zero / Zero / Zero / name := "foo",
+
+    Test / bar := 1,
+    Test / foo := (Test / bar).value + 1,
+    Compile / foo := {
+      (Compile / bar).previous.getOrElse(1)
+    },
+    Compile / bar := {
+      (Compile / foo).previous.getOrElse(2)
+    },
+    Test / buildInfo := Nil,
+    baz := {
+      val x = (Test / buildInfo).taskValue
+      (Compile / run).evaluated
+    },
+
+    libraryDependencies += uTest % Test,
+    testFrameworks += new TestFramework("utest.runner.Framework"),
+
+    commands += Command("inspectCheck", inspectBrief, inspectDetailed)(Inspect.parser) {
+      case (s, f) =>
+        val actual = f()
+        val expected = s"""Task: Unit
+Description:
+\tExecutes all tests.
+Provided by:
+\tProjectRef(uri("${baseDirectory.value.toURI}"), "root") / Test / test
+Defined at:
+\t(sbt.Defaults.testTasks) Defaults.scala:670
+Dependencies:
+\tTest / state
+\tTest / testLoader
+\tTest / test / streams
+\tTest / executeTests
+\tTest / test / testResultLogger
+Delegates:
+\tTest / test
+\tRuntime / test
+\tCompile / test
+\ttest
+\tThisBuild / Test / test
+\tThisBuild / Runtime / test
+\tThisBuild / Compile / test
+\tThisBuild / test
+\tZero / Test / test
+\tZero / Runtime / test
+\tZero / Compile / test
+\tGlobal / test
+Related:
+\tprojA / Test / test"""
+
+        if (processText(actual) == processText(expected)) ()
+        else {
+          sys.error(s"""actual:
+$actual
+
+expected:
+$expected
+
+diff:
+""" +
+(
+  processText(actual)
+    zip processText(expected)
+    filter { case ( a, b) => a != b }
+))
+        }
+        s.log.info(actual)
+        s
+    }
+  )
+
+lazy val projA = (project in file("a"))
+
+def processText(s: String): Vector[String] = {
+  val xs = s.split(IO.Newline).toVector
+    .map( _.trim )
+    // declared location of the task is unstable.
+    .filterNot( _.contains("Defaults.scala") )
+  xs
+}
diff --git a/sbt/src/sbt-test/project/unified/src/test/scala/example/HelloTests.scala b/sbt/src/sbt-test/project/unified/src/test/scala/example/HelloTests.scala
new file mode 100644
index 000000000..a9b386667
--- /dev/null
+++ b/sbt/src/sbt-test/project/unified/src/test/scala/example/HelloTests.scala
@@ -0,0 +1,14 @@
+package example
+
+import utest._
+
+import java.nio.file.{ Files, Path, Paths }
+
+object HelloTests extends TestSuite {
+  val tests = Tests {
+    'test1 - {
+      val p = Paths.get("target", "foo")
+      Files.createFile(p)
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/project/unified/test b/sbt/src/sbt-test/project/unified/test
new file mode 100644
index 000000000..bbfaab29b
--- /dev/null
+++ b/sbt/src/sbt-test/project/unified/test
@@ -0,0 +1,28 @@
+> root/Compile/compile
+
+# "Global" now works in shell.
+> show Global/cancelable
+
+# "Global" now works in shell. optional whitespace around /
+> show Global / cancelable
+
+# "ThisBuild" now works in shell.
+> show ThisBuild/scalaVersion
+
+# "ThisBuild" now works in shell. optional whitespace around /
+> show ThisBuild / scalaVersion
+
+$ mkdir target
+> Test/test
+# Check the side-effect of executing uTest
+$ exists target/foo
+
+# use all axes
+> show root/Compile/compile/scalacOptions
+
+# use all axes. optional whitespace around /
+> show root / Compile / compile / scalacOptions
+
+> show Zero / Zero / name
+
+> inspectCheck test
diff --git a/sbt/src/sbt-test/project/unique-settings-computation/build.sbt b/sbt/src/sbt-test/project/unique-settings-computation/build.sbt
new file mode 100644
index 000000000..01a12cdaf
--- /dev/null
+++ b/sbt/src/sbt-test/project/unique-settings-computation/build.sbt
@@ -0,0 +1,9 @@
+lazy val root = project
+
+val checkComputedOnce = taskKey[Unit]("Check computed once")
+checkComputedOnce := {
+  val buildValue = (foo in ThisBuild).value
+  assert(buildValue == "build 0", "Setting in ThisBuild was computed twice")
+  val globalValue = (foo in Global).value
+  assert(globalValue == "global 0", "Setting in Global was computed twice")
+}
diff --git a/sbt/src/sbt-test/project/unique-settings-computation/disabled b/sbt/src/sbt-test/project/unique-settings-computation/disabled
new file mode 100644
index 000000000..e5cf3c46f
--- /dev/null
+++ b/sbt/src/sbt-test/project/unique-settings-computation/disabled
@@ -0,0 +1,3 @@
+> checkComputedOnce
+> setUpScripted
+> checkComputedOnce
diff --git a/sbt/src/sbt-test/project/unique-settings-computation/project/A.scala b/sbt/src/sbt-test/project/unique-settings-computation/project/A.scala
new file mode 100644
index 000000000..9558c5599
--- /dev/null
+++ b/sbt/src/sbt-test/project/unique-settings-computation/project/A.scala
@@ -0,0 +1,27 @@
+import java.util.concurrent.atomic.AtomicInteger
+import sbt._, Keys._
+
+object A extends AutoPlugin {
+  object autoImport {
+    lazy val foo = settingKey[String]("Foo.")
+  }
+  import autoImport._
+  override def trigger = allRequirements
+
+  override def buildSettings: Seq[Setting[_]] =
+    (foo := s"build ${buildCount.getAndIncrement}") ::
+    Nil
+
+  override def globalSettings: Seq[Setting[_]] =
+    (foo := s"global ${globalCount.getAndIncrement}") ::
+    (commands += setUpScripted) ::
+    Nil
+
+  def setUpScripted = Command.command("setUpScripted") { (state0: State) =>
+    Project.extract(state0).appendWithoutSession(name := "foo", state0)
+  }
+
+  // used to ensure the build-level and global settings are only added once
+  private[this] val buildCount = new AtomicInteger(0)
+  private[this] val globalCount = new AtomicInteger(0)
+}
diff --git a/sbt/src/sbt-test/project/val-order/build.sbt b/sbt/src/sbt-test/project/val-order/build.sbt
new file mode 100644
index 000000000..d34d36cdc
--- /dev/null
+++ b/sbt/src/sbt-test/project/val-order/build.sbt
@@ -0,0 +1,36 @@
+ThisBuild / scalaVersion     := "2.13.1"
+ThisBuild / version          := "0.1.0-SNAPSHOT"
+
+lazy val check = taskKey[Unit]("")
+lazy val intTask = taskKey[Int]("int task")
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "val-ordering-test",
+    ThisBuild / organization := "root",
+    check := {
+      val o = (ThisBuild / organization).value
+      assert(o == "root.api.database.web", s"$o")
+      val x = (api / intTask).value
+      assert(x == 1, x.toString)
+
+    },
+  )
+
+lazy val api = project
+  .settings(
+    intTask := 0,
+    ThisBuild / organization := (ThisBuild / organization).value + ".api",
+  )
+
+lazy val database = project
+  .settings(
+    ThisBuild / organization := (ThisBuild / organization).value + ".database",
+  )
+
+lazy val web = project
+  .dependsOn(api, database)
+  .settings(
+    api / intTask := 1,
+    ThisBuild / organization := (ThisBuild / organization).value + ".web",
+  )
diff --git a/sbt/src/sbt-test/project/val-order/test b/sbt/src/sbt-test/project/val-order/test
new file mode 100644
index 000000000..15675b169
--- /dev/null
+++ b/sbt/src/sbt-test/project/val-order/test
@@ -0,0 +1 @@
+> check
diff --git a/sbt/src/sbt-test/reporter/source-mapper/build.sbt b/sbt/src/sbt-test/reporter/source-mapper/build.sbt
new file mode 100644
index 000000000..3822f71bd
--- /dev/null
+++ b/sbt/src/sbt-test/reporter/source-mapper/build.sbt
@@ -0,0 +1,42 @@
+import sbt.internal.util.ConsoleAppender
+import sbt.internal.inc.StringVirtualFile
+import xsbti.compile.CompileOptions
+
+lazy val assertEmptySourcePositionMappers = taskKey[Unit]("checks that sourcePositionMappers is empty")
+lazy val assertAbsolutePathConversion = taskKey[Unit]("checks source mappers convert to absolute path")
+lazy val assertVirtualFile = taskKey[Unit]("checks source mappers handle virtual files")
+lazy val resetMessages = taskKey[Unit]("empties the messages list")
+
+lazy val root = (project in file("."))
+  .settings(
+    extraAppenders := { s => Seq(ConsoleAppender(FakePrintWriter)) },
+    Compile / compile / compileOptions ~= { old: CompileOptions =>
+      old.withSources(StringVirtualFile("/tmp/A.scala",
+        """object X""") +: old.sources) },
+    assertEmptySourcePositionMappers := {
+      assert {
+        sourcePositionMappers.value.isEmpty
+      }
+    },
+    assertAbsolutePathConversion := {
+      val source = (Compile/sources).value.head
+      assert {
+        FakePrintWriter.messages.exists(_.contains(s"${source.getAbsolutePath}:3:15: comparing values of types Int and String using `==` will always yield false"))
+      }
+      assert {
+        FakePrintWriter.messages.forall(!_.contains("${BASE}"))
+      }
+    },
+    assertVirtualFile := {
+      val source = (Compile/sources).value.head
+      assert {
+        FakePrintWriter.messages.exists(_.contains("${BASE}/src/main/scala/Foo.scala:3:15: comparing values of types Int and String using `==` will always yield false"))
+      }
+      assert {
+        FakePrintWriter.messages.forall(!_.contains(source.getAbsolutePath))
+      }
+    },
+    resetMessages := {
+      FakePrintWriter.resetMessages
+    }
+  )
diff --git a/sbt/src/sbt-test/reporter/source-mapper/project/FakePrintWriter.scala b/sbt/src/sbt-test/reporter/source-mapper/project/FakePrintWriter.scala
new file mode 100644
index 000000000..14d3bcdba
--- /dev/null
+++ b/sbt/src/sbt-test/reporter/source-mapper/project/FakePrintWriter.scala
@@ -0,0 +1,6 @@
+object FakePrintWriter extends java.io.PrintWriter("fake-print-writer") {
+  @volatile var messages = List.empty[String]
+  def resetMessages = messages = List.empty[String]
+  override def println(x: String): Unit = messages = x :: messages
+  override def print(x: String): Unit = messages = x :: messages
+}
diff --git a/sbt/src/sbt-test/reporter/source-mapper/src/main/scala/Foo.scala b/sbt/src/sbt-test/reporter/source-mapper/src/main/scala/Foo.scala
new file mode 100644
index 000000000..fd36a2e06
--- /dev/null
+++ b/sbt/src/sbt-test/reporter/source-mapper/src/main/scala/Foo.scala
@@ -0,0 +1,4 @@
+object Foo {
+  // Will cause a warning
+  val bar = 1 == ""
+}
diff --git a/sbt/src/sbt-test/reporter/source-mapper/test b/sbt/src/sbt-test/reporter/source-mapper/test
new file mode 100644
index 000000000..ad0ede616
--- /dev/null
+++ b/sbt/src/sbt-test/reporter/source-mapper/test
@@ -0,0 +1,14 @@
+> compile
+
+> assertEmptySourcePositionMappers
+
+> printWarnings
+> assertAbsolutePathConversion
+
+> resetMessages
+
+> set reportAbsolutePath := false
+> printWarnings
+> assertVirtualFile
+
+> resetMessages
diff --git a/sbt/src/sbt-test/run/classpath/Main.scala b/sbt/src/sbt-test/run/classpath/Main.scala
new file mode 100644
index 000000000..196834b7f
--- /dev/null
+++ b/sbt/src/sbt-test/run/classpath/Main.scala
@@ -0,0 +1,9 @@
+package t
+
+import java.nio._, charset._, file._
+
+object Main {
+  def main(args: Array[String]): Unit = {
+    println(new String(Files.readAllBytes(Paths.get(getClass().getResource("/a.txt").toURI()))))
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/run/classpath/build.sbt b/sbt/src/sbt-test/run/classpath/build.sbt
new file mode 100644
index 000000000..57556d8bb
--- /dev/null
+++ b/sbt/src/sbt-test/run/classpath/build.sbt
@@ -0,0 +1 @@
+externalDependencyClasspath in Runtime += file("conf")
\ No newline at end of file
diff --git a/sbt/src/sbt-test/run/classpath/conf/a.txt b/sbt/src/sbt-test/run/classpath/conf/a.txt
new file mode 100644
index 000000000..257cc5642
--- /dev/null
+++ b/sbt/src/sbt-test/run/classpath/conf/a.txt
@@ -0,0 +1 @@
+foo
diff --git a/sbt/src/sbt-test/run/classpath/test b/sbt/src/sbt-test/run/classpath/test
new file mode 100644
index 000000000..62ea636c1
--- /dev/null
+++ b/sbt/src/sbt-test/run/classpath/test
@@ -0,0 +1 @@
+> run
diff --git a/sbt/src/sbt-test/run/concurrent/build.sbt b/sbt/src/sbt-test/run/concurrent/build.sbt
index 415745bff..7cc16dd7d 100644
--- a/sbt/src/sbt-test/run/concurrent/build.sbt
+++ b/sbt/src/sbt-test/run/concurrent/build.sbt
@@ -7,7 +7,7 @@ def runTestTask(pre: Def.Initialize[Task[Unit]]) =
 		val cp = (fullClasspath in Compile).value
 		val main = (mainClass in Compile).value getOrElse sys.error("No main class found")
 		val args = baseDirectory.value.getAbsolutePath :: Nil
-		r.run(main, cp.files, args, streams.value.log) foreach sys.error
+		r.run(main, cp.files, args, streams.value.log).get
 	}
 
 lazy val b = project.settings(
diff --git a/sbt/src/sbt-test/run/error/changes/RunFailureMain.scala b/sbt/src/sbt-test/run/error/changes/RunFailureMain.scala
index 2971eabbe..d4e6faf42 100644
--- a/sbt/src/sbt-test/run/error/changes/RunFailureMain.scala
+++ b/sbt/src/sbt-test/run/error/changes/RunFailureMain.scala
@@ -2,6 +2,6 @@ object Spawn
 {
 	def main(args: Array[String])
 	{
-		error("Test error main")
+		sys.error("Test error main")
 	}
 }
\ No newline at end of file
diff --git a/sbt/src/sbt-test/run/fork-loader/build.sbt b/sbt/src/sbt-test/run/fork-loader/build.sbt
index a542a2d90..9ffe20e13 100644
--- a/sbt/src/sbt-test/run/fork-loader/build.sbt
+++ b/sbt/src/sbt-test/run/fork-loader/build.sbt
@@ -1,5 +1,10 @@
-name := "forked-test"
+val scalcheck = "org.scalacheck" %% "scalacheck" % "1.14.0"
 
-organization := "org.example"
+ThisBuild / scalaVersion := "2.12.12"
 
-libraryDependencies += "org.scalacheck" %% "scalacheck" % "1.10.0" % "test"
\ No newline at end of file
+lazy val root = (project in file("."))
+  .settings(
+    name := "forked-test",
+    organization := "org.example",
+    libraryDependencies += scalcheck % Test
+  )
diff --git a/sbt/src/sbt-test/run/fork/test b/sbt/src/sbt-test/run/fork/test
index 1c5cbb769..8f4fd8c25 100644
--- a/sbt/src/sbt-test/run/fork/test
+++ b/sbt/src/sbt-test/run/fork/test
@@ -1,18 +1,18 @@
-> run "fork"
+> run fork
 $ exists flag
 $ delete flag
 
-$ mkdir "forked"
+$ mkdir forked
 > set fork := true
-> 'set baseDirectory in run := baseDirectory(_ / "forked").value'
+> set baseDirectory in run := baseDirectory(_ / "forked").value
 
-> run "forked"
+> run forked
 $ exists forked/flag
 $ absent flag
 $ delete forked/flag
 
-> 'set envVars += ("flag.name" -> "env.flag")'
-> run "forked"
+> set envVars += ("flag.name" -> "env.flag")
+> run forked
 $ exists forked/env.flag
 $ absent flag
 $ absent forked/flag
diff --git a/sbt/src/sbt-test/run/spawn/src/main/scala/Spawn.scala b/sbt/src/sbt-test/run/spawn/src/main/scala/Spawn.scala
index 26085748e..762e029f8 100644
--- a/sbt/src/sbt-test/run/spawn/src/main/scala/Spawn.scala
+++ b/sbt/src/sbt-test/run/spawn/src/main/scala/Spawn.scala
@@ -23,7 +23,7 @@ object Spawn
 		catch	{ case e: InterruptedException =>
 			val msg = "TrapExit improperly interrupted non-daemon thread"
 			System.err.println(msg)
-			error(msg)
+			sys.error(msg)
 		}
 	}
 }
diff --git a/sbt/src/sbt-test/source-dependencies/abstract-type-override/build.sbt b/sbt/src/sbt-test/source-dependencies/abstract-type-override/build.sbt
index fbdcd84fe..1036709cc 100644
--- a/sbt/src/sbt-test/source-dependencies/abstract-type-override/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/abstract-type-override/build.sbt
@@ -1,9 +1,25 @@
 import sbt.internal.inc.Analysis
+import complete.DefaultParsers._
 
-InputKey[Unit]("checkNumberOfCompilerIterations") := (inputTask { (argTask: TaskKey[Seq[String]]) =>
-  (argTask, compile in Compile) map { case (args: Seq[String], a: Analysis) =>
-    assert(args.size == 1)
-    val expectedIterationsNumber = args(0).toInt
-    assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber))
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+    }
   }
-}).evaluated
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
+
+checkIterations := {
+  val expected: Int = (Space ~> NatBasic).parsed
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+  assert(expected == actual, s"Expected $expected compilations, got $actual")
+}
diff --git a/sbt/src/sbt-test/source-dependencies/abstract-type-override/project/CompileState.scala b/sbt/src/sbt-test/source-dependencies/abstract-type-override/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/abstract-type-override/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/source-dependencies/abstract-type-override/test b/sbt/src/sbt-test/source-dependencies/abstract-type-override/test
index 9ffa4fb17..30168afbf 100644
--- a/sbt/src/sbt-test/source-dependencies/abstract-type-override/test
+++ b/sbt/src/sbt-test/source-dependencies/abstract-type-override/test
@@ -4,6 +4,7 @@
 # See https://github.com/sbt/sbt/issues/726 for details
 
 # introduces first compile iteration
+> recordPreviousIterations
 > compile
 # this change adds a comment and does not change api so introduces
 # only one additional compile iteration
@@ -11,4 +12,4 @@ $ copy-file changes/Bar1.scala src/main/scala/Bar.scala
 # second iteration
 #> compile
 # check if there are only two compile iterations performed
-> checkNumberOfCompilerIterations 2
+> checkIterations 2
diff --git a/sbt/src/sbt-test/source-dependencies/backtick-quoted-names/build.sbt b/sbt/src/sbt-test/source-dependencies/backtick-quoted-names/build.sbt
deleted file mode 100644
index 8a38ef414..000000000
--- a/sbt/src/sbt-test/source-dependencies/backtick-quoted-names/build.sbt
+++ /dev/null
@@ -1 +0,0 @@
-incOptions := incOptions.value.withNameHashing(true)
diff --git a/sbt/src/sbt-test/source-dependencies/binary/build.sbt b/sbt/src/sbt-test/source-dependencies/binary/build.sbt
index 27d7016cc..9298a3b66 100644
--- a/sbt/src/sbt-test/source-dependencies/binary/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/binary/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / scalaVersion := "2.12.12"
+
 lazy val dep = project
 
 lazy val use = project.
diff --git a/sbt/src/sbt-test/source-dependencies/canon/build.sbt b/sbt/src/sbt-test/source-dependencies/canon/build.sbt
index 64c457108..1036709cc 100644
--- a/sbt/src/sbt-test/source-dependencies/canon/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/canon/build.sbt
@@ -1,10 +1,25 @@
 import sbt.internal.inc.Analysis
 import complete.DefaultParsers._
 
-val checkIterations = inputKey[Unit]("Verifies the accumlated number of iterations of incremental compilation.")
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+    }
+  }
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
   val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
   assert(expected == actual, s"Expected $expected compilations, got $actual")
 }
diff --git a/sbt/src/sbt-test/source-dependencies/canon/project/CompileState.scala b/sbt/src/sbt-test/source-dependencies/canon/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/canon/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/source-dependencies/canon/test b/sbt/src/sbt-test/source-dependencies/canon/test
index 13caf4871..24c4bcd21 100644
--- a/sbt/src/sbt-test/source-dependencies/canon/test
+++ b/sbt/src/sbt-test/source-dependencies/canon/test
@@ -5,6 +5,7 @@
 # This also verifies that compilation does not get repeatedly triggered by a mismatch in
 #  paths.
 
+> recordPreviousIterations
 > compile
 > compile
-> checkIterations 1
\ No newline at end of file
+> checkIterations 1
diff --git a/sbt/src/sbt-test/source-dependencies/constants/pending b/sbt/src/sbt-test/source-dependencies/constants/pending
index eebce96e4..7a5ae5879 100644
--- a/sbt/src/sbt-test/source-dependencies/constants/pending
+++ b/sbt/src/sbt-test/source-dependencies/constants/pending
@@ -1,5 +1,4 @@
 # Marked as pending, see https://github.com/sbt/sbt/issues/1543
-#
 # Tests if source dependencies are tracked properly
 # for compile-time constants (like final vals in top-level objects)
 # see https://issues.scala-lang.org/browse/SI-7173 for details
diff --git a/sbt/src/sbt-test/source-dependencies/continuations/Foo.scala b/sbt/src/sbt-test/source-dependencies/continuations/Foo.scala
deleted file mode 100644
index 580f7175a..000000000
--- a/sbt/src/sbt-test/source-dependencies/continuations/Foo.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-trait Foo
-trait BarA
-trait BarB
\ No newline at end of file
diff --git a/sbt/src/sbt-test/source-dependencies/continuations/Use.scala b/sbt/src/sbt-test/source-dependencies/continuations/Use.scala
deleted file mode 100644
index bdb848464..000000000
--- a/sbt/src/sbt-test/source-dependencies/continuations/Use.scala
+++ /dev/null
@@ -1,6 +0,0 @@
-import scala.util.continuations._
-
-class Use {
-  val a = new Baz
-  def bar: (Foo with BarA) @cpsParam[Unit, Unit] = a.foo
-}
diff --git a/sbt/src/sbt-test/source-dependencies/continuations/build.sbt b/sbt/src/sbt-test/source-dependencies/continuations/build.sbt
deleted file mode 100644
index 34fff642b..000000000
--- a/sbt/src/sbt-test/source-dependencies/continuations/build.sbt
+++ /dev/null
@@ -1,4 +0,0 @@
-scalaVersion := "2.10.6"
-autoCompilerPlugins := true
-libraryDependencies += compilerPlugin("org.scala-lang.plugins" % "continuations" % scalaVersion.value)
-scalacOptions += "-P:continuations:enable"
diff --git a/sbt/src/sbt-test/source-dependencies/continuations/changes/Def1.scala b/sbt/src/sbt-test/source-dependencies/continuations/changes/Def1.scala
deleted file mode 100644
index 3cc76e193..000000000
--- a/sbt/src/sbt-test/source-dependencies/continuations/changes/Def1.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-import scala.util.continuations._
-
-class Baz {
-  def foo = shiftUnit[Foo with BarA, Unit, Unit](null)
-}
diff --git a/sbt/src/sbt-test/source-dependencies/continuations/changes/Def2.scala b/sbt/src/sbt-test/source-dependencies/continuations/changes/Def2.scala
deleted file mode 100644
index 9a176dffb..000000000
--- a/sbt/src/sbt-test/source-dependencies/continuations/changes/Def2.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-import scala.util.continuations._
-
-class Baz {
-  def foo = shiftUnit[Foo with BarB, Unit, Unit](null)
-}
diff --git a/sbt/src/sbt-test/source-dependencies/continuations/test b/sbt/src/sbt-test/source-dependencies/continuations/test
deleted file mode 100644
index 2aeb714be..000000000
--- a/sbt/src/sbt-test/source-dependencies/continuations/test
+++ /dev/null
@@ -1,10 +0,0 @@
-# Compile code with a type (Foo with BarA) @cpsParam...
-# The spec says only simple types can be annotated, but scalac allows any type.
-$ copy-file changes/Def1.scala Def.scala
-> compile
-
-# To ensure it was properly processed, change it to (Foo with BarB) @cpsParam...
-# This should invalidate Use.scala, which expects it to be BarA and so compilation should fail.
-$ delete Def.scala
-$ copy-file changes/Def2.scala Def.scala
--> compile
\ No newline at end of file
diff --git a/sbt/src/sbt-test/source-dependencies/cross-source/src/main/scala-2.12/B.scala b/sbt/src/sbt-test/source-dependencies/cross-source/src/main/scala-2.12/B.scala
new file mode 100644
index 000000000..fa8ad30ea
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/cross-source/src/main/scala-2.12/B.scala
@@ -0,0 +1,3 @@
+object B {
+  def show(what: String): String = s"String interpolation is ${what.toUpperCase}!"
+}
diff --git a/sbt/src/sbt-test/source-dependencies/cross-source/test b/sbt/src/sbt-test/source-dependencies/cross-source/test
index ddea251c9..d0d770085 100644
--- a/sbt/src/sbt-test/source-dependencies/cross-source/test
+++ b/sbt/src/sbt-test/source-dependencies/cross-source/test
@@ -1,7 +1,3 @@
-# A.scala needs B.scala, it won't be in source list
-> ++2.11.4!
--> compile
-
 # A.scala needs B.scala, it would be in source list
-> ++2.10.4!
+> ++2.12.12!
 > compile
diff --git a/sbt/src/sbt-test/source-dependencies/export-jars/test b/sbt/src/sbt-test/source-dependencies/export-jars/test
index 3676fac5d..f1a605f00 100644
--- a/sbt/src/sbt-test/source-dependencies/export-jars/test
+++ b/sbt/src/sbt-test/source-dependencies/export-jars/test
@@ -5,11 +5,9 @@ $ copy-file changes/A1.scala a/A.scala
 $ copy-file changes/A2.scala a/A.scala
 
 # done this way because last modified times often have ~1s resolution
-$ sleep 2000
 > run 2
 $ copy-file changes/A3.scala a/A.scala
 
-$ sleep 2000
 > run 3
 
 $ copy-file changes/build2.sbt build2.sbt
@@ -19,9 +17,7 @@ $ copy-file changes/A1.scala a/A.scala
 > run 1
 $ copy-file changes/A2.scala a/A.scala
 
-$ sleep 2000
 > run 2
 $ copy-file changes/A3.scala a/A.scala
 
-$ sleep 2000
 > run 3
diff --git a/sbt/src/sbt-test/source-dependencies/ext/build.sbt b/sbt/src/sbt-test/source-dependencies/ext/build.sbt
index b93f974e1..1036709cc 100644
--- a/sbt/src/sbt-test/source-dependencies/ext/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/ext/build.sbt
@@ -1,10 +1,25 @@
 import sbt.internal.inc.Analysis
 import complete.DefaultParsers._
 
-val checkIterations = inputKey[Unit]("Verifies the accumlated number of iterations of incremental compilation.")
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+    }
+  }
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
-	val expected: Int = (Space ~> NatBasic).parsed
-	val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
-	assert(expected == actual, s"Expected $expected compilations, got $actual")
-}
\ No newline at end of file
+  val expected: Int = (Space ~> NatBasic).parsed
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
+  assert(expected == actual, s"Expected $expected compilations, got $actual")
+}
diff --git a/sbt/src/sbt-test/source-dependencies/ext/test b/sbt/src/sbt-test/source-dependencies/ext/disabled
similarity index 81%
rename from sbt/src/sbt-test/source-dependencies/ext/test
rename to sbt/src/sbt-test/source-dependencies/ext/disabled
index 2b01a3de7..b92cb041c 100644
--- a/sbt/src/sbt-test/source-dependencies/ext/test
+++ b/sbt/src/sbt-test/source-dependencies/ext/disabled
@@ -1,7 +1,8 @@
 # initial compilation
+> recordPreviousIterations
 > checkIterations 1
 
 # no further compilation should be necessary, since nothing changed
 # previously, a dependency on a jar in <java.home>lib/ext/ would
 # always force recompilation
-> checkIterations 1
\ No newline at end of file
+> checkIterations 1
diff --git a/sbt/src/sbt-test/source-dependencies/ext/project/CompileState.scala b/sbt/src/sbt-test/source-dependencies/ext/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/ext/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/source-dependencies/inherited_type_params/A.scala b/sbt/src/sbt-test/source-dependencies/inherited_type_params/A.scala
index 9de61dd5f..ba2f3a2c4 100644
--- a/sbt/src/sbt-test/source-dependencies/inherited_type_params/A.scala
+++ b/sbt/src/sbt-test/source-dependencies/inherited_type_params/A.scala
@@ -3,5 +3,5 @@ trait Equal[-A] {
   def equal(a1: A, a2: A): Boolean
 }
 object Test {
-  implicit def TraversableEqual[CC[X] <: collection.TraversableLike[X, CC[X]] with Traversable[X], A: Equal]: Equal[CC[A]] = error("")
+  implicit def TraversableEqual[CC[X] <: collection.TraversableLike[X, CC[X]] with Traversable[X], A: Equal]: Equal[CC[A]] = sys.error("")
 }
\ No newline at end of file
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/A.java b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/A.java
deleted file mode 100644
index 2bce1ee78..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/A.java
+++ /dev/null
@@ -1,3 +0,0 @@
-public class A {
-	public Integer x() { return 3; }
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/B.java b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/B.java
deleted file mode 100644
index 7e9bb5574..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/B.java
+++ /dev/null
@@ -1 +0,0 @@
-public class B extends A {}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/C.java b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/C.java
deleted file mode 100644
index 042c2b2a3..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/C.java
+++ /dev/null
@@ -1 +0,0 @@
-public class C extends B {}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/D.java b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/D.java
deleted file mode 100644
index 03e6ad740..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/D.java
+++ /dev/null
@@ -1,4 +0,0 @@
-public class D {
-	public static final C c = new C();
-	public static String x() { return c.x().toString(); }
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/E.java b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/E.java
deleted file mode 100644
index d28336ed5..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/E.java
+++ /dev/null
@@ -1,5 +0,0 @@
-public class E {
-	public static void main(String[] args) {
-		assert(D.x() == "3");
-	}
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/build.sbt b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/build.sbt
deleted file mode 100644
index 64c457108..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/build.sbt
+++ /dev/null
@@ -1,10 +0,0 @@
-import sbt.internal.inc.Analysis
-import complete.DefaultParsers._
-
-val checkIterations = inputKey[Unit]("Verifies the accumlated number of iterations of incremental compilation.")
-
-checkIterations := {
-  val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
-  assert(expected == actual, s"Expected $expected compilations, got $actual")
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/changes/A2.java b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/changes/A2.java
deleted file mode 100644
index 610c20407..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/changes/A2.java
+++ /dev/null
@@ -1,3 +0,0 @@
-public class A {
-	public String x() { return "3"; }
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/test b/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/test
deleted file mode 100644
index 85a7c97e9..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv-java/test
+++ /dev/null
@@ -1,9 +0,0 @@
-# 1 iteration from initial full compile
-> run
-$ copy-file changes/A2.java A.java
-
-# 1 iteration for the initial changes
-# 1 iteration to recompile all descendents and direct dependencies
-# no further iteration, because APIs of directs don't change
-> run
-> checkIterations 3
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/A.scala b/sbt/src/sbt-test/source-dependencies/less-inter-inv/A.scala
deleted file mode 100644
index a4f92f4fa..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/A.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-class A {
-	def x = 3
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/B.scala b/sbt/src/sbt-test/source-dependencies/less-inter-inv/B.scala
deleted file mode 100644
index a18aec3db..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/B.scala
+++ /dev/null
@@ -1 +0,0 @@
-class B extends A
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/C.scala b/sbt/src/sbt-test/source-dependencies/less-inter-inv/C.scala
deleted file mode 100644
index f6f5bb28f..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/C.scala
+++ /dev/null
@@ -1 +0,0 @@
-class C extends B
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/D.scala b/sbt/src/sbt-test/source-dependencies/less-inter-inv/D.scala
deleted file mode 100644
index 55959c2a9..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/D.scala
+++ /dev/null
@@ -1,4 +0,0 @@
-object D {
-  val c = new C
-  def x: String = c.x.toString
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/E.scala b/sbt/src/sbt-test/source-dependencies/less-inter-inv/E.scala
deleted file mode 100644
index f393ca20d..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/E.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-object E extends App {
-	assert(D.x == "3")
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/build.sbt b/sbt/src/sbt-test/source-dependencies/less-inter-inv/build.sbt
deleted file mode 100644
index 64c457108..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/build.sbt
+++ /dev/null
@@ -1,10 +0,0 @@
-import sbt.internal.inc.Analysis
-import complete.DefaultParsers._
-
-val checkIterations = inputKey[Unit]("Verifies the accumlated number of iterations of incremental compilation.")
-
-checkIterations := {
-  val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
-  assert(expected == actual, s"Expected $expected compilations, got $actual")
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/changes/A2.scala b/sbt/src/sbt-test/source-dependencies/less-inter-inv/changes/A2.scala
deleted file mode 100644
index acab4a1ae..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/changes/A2.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-class A {
-	def x = "3"
-}
diff --git a/sbt/src/sbt-test/source-dependencies/less-inter-inv/test b/sbt/src/sbt-test/source-dependencies/less-inter-inv/test
deleted file mode 100644
index c6df5698e..000000000
--- a/sbt/src/sbt-test/source-dependencies/less-inter-inv/test
+++ /dev/null
@@ -1,9 +0,0 @@
-# 1 iteration from initial full compile
-> run
-$ copy-file changes/A2.scala A.scala
-
-# 1 iteration for the initial changes
-# 1 iteration to recompile all descendents and direct dependencies
-# no further iteration, because APIs of directs don't change
-> run
-> checkIterations 3
diff --git a/sbt/src/sbt-test/source-dependencies/macro-annotation/build.sbt b/sbt/src/sbt-test/source-dependencies/macro-annotation/build.sbt
index 4243856d5..ae85d25a6 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-annotation/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/macro-annotation/build.sbt
@@ -1,12 +1,12 @@
-val paradiseVersion = "2.0.1"
+ThisBuild / scalaVersion := "2.12.12"
+
+val paradiseVersion = "2.1.1"
 val commonSettings = Seq(
   version := "1.0.0",
   scalacOptions ++= Seq(""),
-  scalaVersion := "2.11.4",
   resolvers += Resolver.sonatypeRepo("snapshots"),
   resolvers += Resolver.sonatypeRepo("releases"),
-  addCompilerPlugin("org.scalamacros" % "paradise" % paradiseVersion cross CrossVersion.full),
-  incOptions := incOptions.value.withNameHashing(true)
+  addCompilerPlugin("org.scalamacros" % "paradise" % paradiseVersion cross CrossVersion.full)
 )
 
 lazy val root = (project in file(".")).
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-2-11/test b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-2-11/disabled
similarity index 100%
rename from sbt/src/sbt-test/source-dependencies/macro-arg-dep-2-11/test
rename to sbt/src/sbt-test/source-dependencies/macro-arg-dep-2-11/disabled
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested-2-11/test b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested-2-11/disabled
similarity index 100%
rename from sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested-2-11/test
rename to sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested-2-11/disabled
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/build.sbt b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/build.sbt
index 264dd3d57..71627ff7c 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/build.sbt
@@ -1,5 +1,6 @@
+ThisBuild / scalaVersion := "2.12.12"
+
 val defaultSettings = Seq(
-  scalaVersion := "2.10.6",
   libraryDependencies += scalaVersion("org.scala-lang" % "scala-reflect" % _ ).value
 )
 
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Client.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Client.scala
index d80fd559e..76c16af24 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Client.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Client.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 
 object Client {
 	Provider.printTree(Provider.printTree(Foo.str))
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Foo.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Foo.scala
index 1908f0673..6f410fca2 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Foo.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/Foo.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 
 object Foo {
   def str: String = "abc"
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/changes/Foo.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/changes/Foo.scala
index e3deb0f43..4f2a62b39 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/changes/Foo.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-client/changes/Foo.scala
@@ -1,3 +1,3 @@
-package macro
+package macros
 object Foo {
 }
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-provider/Provider.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-provider/Provider.scala
index facc4a468..b39b4c282 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-provider/Provider.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-nested/macro-provider/Provider.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 import scala.language.experimental.macros
 import scala.reflect.macros._
 
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-stackoverflow/build.sbt b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-stackoverflow/build.sbt
index 218d378cb..71627ff7c 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep-stackoverflow/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep-stackoverflow/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / scalaVersion := "2.12.12"
+
 val defaultSettings = Seq(
   libraryDependencies += scalaVersion("org.scala-lang" % "scala-reflect" % _ ).value
 )
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/build.sbt b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/build.sbt
index 264dd3d57..71627ff7c 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/build.sbt
@@ -1,5 +1,6 @@
+ThisBuild / scalaVersion := "2.12.12"
+
 val defaultSettings = Seq(
-  scalaVersion := "2.10.6",
   libraryDependencies += scalaVersion("org.scala-lang" % "scala-reflect" % _ ).value
 )
 
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Client.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Client.scala
index 94ad4bcc8..0ecbe6fce 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Client.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Client.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 
 object Client {
 	Provider.printTree(Foo.str)
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Foo.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Foo.scala
index 1908f0673..6f410fca2 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Foo.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/Foo.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 
 object Foo {
   def str: String = "abc"
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/changes/Foo.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/changes/Foo.scala
index e3deb0f43..4f2a62b39 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/changes/Foo.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-client/changes/Foo.scala
@@ -1,3 +1,3 @@
-package macro
+package macros
 object Foo {
 }
diff --git a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-provider/Provider.scala b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-provider/Provider.scala
index facc4a468..b39b4c282 100644
--- a/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-provider/Provider.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro-arg-dep/macro-provider/Provider.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 import scala.language.experimental.macros
 import scala.reflect.macros._
 
diff --git a/sbt/src/sbt-test/source-dependencies/macro/build.sbt b/sbt/src/sbt-test/source-dependencies/macro/build.sbt
index 1e81806a5..71627ff7c 100644
--- a/sbt/src/sbt-test/source-dependencies/macro/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/macro/build.sbt
@@ -1,7 +1,7 @@
+ThisBuild / scalaVersion := "2.12.12"
+
 val defaultSettings = Seq(
-  scalaVersion := "2.10.6",
-  libraryDependencies += scalaVersion("org.scala-lang" % "scala-reflect" % _ ).value //,
-  //incOptions := incOptions.value.withNameHashing(true)
+  libraryDependencies += scalaVersion("org.scala-lang" % "scala-reflect" % _ ).value
 )
 
 lazy val root = (project in file(".")).
diff --git a/sbt/src/sbt-test/source-dependencies/macro/macro-client/Client.scala b/sbt/src/sbt-test/source-dependencies/macro/macro-client/Client.scala
index 90932d136..a8ed0d193 100644
--- a/sbt/src/sbt-test/source-dependencies/macro/macro-client/Client.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro/macro-client/Client.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 
 object Client {
 	Provider.tree(0)
diff --git a/sbt/src/sbt-test/source-dependencies/macro/macro-provider/Provider.scala b/sbt/src/sbt-test/source-dependencies/macro/macro-provider/Provider.scala
index 9b6d27676..e9320d32f 100644
--- a/sbt/src/sbt-test/source-dependencies/macro/macro-provider/Provider.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro/macro-provider/Provider.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 import scala.language.experimental.macros
 import scala.reflect.macros._
 
diff --git a/sbt/src/sbt-test/source-dependencies/macro/macro-provider/changes/Provider.scala b/sbt/src/sbt-test/source-dependencies/macro/macro-provider/changes/Provider.scala
index 711989b32..4b909e42c 100644
--- a/sbt/src/sbt-test/source-dependencies/macro/macro-provider/changes/Provider.scala
+++ b/sbt/src/sbt-test/source-dependencies/macro/macro-provider/changes/Provider.scala
@@ -1,4 +1,4 @@
-package macro
+package macros
 import scala.language.experimental.macros
 import scala.reflect.macros._
 
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining-java/build.sbt b/sbt/src/sbt-test/source-dependencies/pipelining-java/build.sbt
new file mode 100644
index 000000000..a5b9eef0d
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining-java/build.sbt
@@ -0,0 +1,13 @@
+ThisBuild / scalaVersion := "2.13.3"
+ThisBuild / usePipelining := true
+
+lazy val root = (project in file("."))
+  .aggregate(dep, use)
+  .settings(
+    name := "pipelining Java",
+  )
+
+lazy val dep = project
+
+lazy val use = project
+  .dependsOn(dep)
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining-java/changes/Break.java b/sbt/src/sbt-test/source-dependencies/pipelining-java/changes/Break.java
new file mode 100644
index 000000000..014567f98
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining-java/changes/Break.java
@@ -0,0 +1,2 @@
+public class Break {
+}
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining-java/dep/A.java b/sbt/src/sbt-test/source-dependencies/pipelining-java/dep/A.java
new file mode 100644
index 000000000..56fa6cd06
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining-java/dep/A.java
@@ -0,0 +1,3 @@
+public class A {
+  public static int x = 3;
+}
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining-java/test b/sbt/src/sbt-test/source-dependencies/pipelining-java/test
new file mode 100644
index 000000000..78b6178ee
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining-java/test
@@ -0,0 +1,5 @@
+> use/compile
+
+$ delete dep/A.java
+$ copy-file changes/Break.java dep/Break.java
+-> use/compile
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining-java/use/B.java b/sbt/src/sbt-test/source-dependencies/pipelining-java/use/B.java
new file mode 100644
index 000000000..60121dd8e
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining-java/use/B.java
@@ -0,0 +1,3 @@
+public class B {
+  public static int y = A.x;
+}
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining/build.sbt b/sbt/src/sbt-test/source-dependencies/pipelining/build.sbt
new file mode 100644
index 000000000..36db86700
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining/build.sbt
@@ -0,0 +1,22 @@
+ThisBuild / scalaVersion := "2.13.3"
+ThisBuild / usePipelining := true
+
+lazy val root = (project in file("."))
+  .aggregate(dep, use)
+  .settings(
+    name := "pipelining basics",
+  )
+
+lazy val dep = project
+
+lazy val use = project
+  .dependsOn(dep)
+  .settings(
+    TaskKey[Unit]("checkPickle") := {
+      val s = streams.value
+      val x = (dep / Compile / compile).value
+      val picklePath = (Compile / internalDependencyPicklePath).value
+      assert(picklePath.size == 1 &&
+        picklePath.head.data.name == "dep_2.13-0.1.0-SNAPSHOT.jar", s"picklePath = ${picklePath}")
+    },
+  )
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining/changes/Break.scala b/sbt/src/sbt-test/source-dependencies/pipelining/changes/Break.scala
new file mode 100644
index 000000000..b2dfe50e1
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining/changes/Break.scala
@@ -0,0 +1,3 @@
+package example
+
+object Break
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining/dep/A.scala b/sbt/src/sbt-test/source-dependencies/pipelining/dep/A.scala
new file mode 100644
index 000000000..2221c2ebc
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining/dep/A.scala
@@ -0,0 +1,5 @@
+package example
+
+object A {
+  val x = 3
+}
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining/test b/sbt/src/sbt-test/source-dependencies/pipelining/test
new file mode 100644
index 000000000..6b3baa1c6
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining/test
@@ -0,0 +1,9 @@
+> dep/compile
+
+> use/checkPickle
+
+> compile
+
+# making subproject dep should trigger failure
+$ copy-file changes/Break.scala dep/A.scala
+-> compile
diff --git a/sbt/src/sbt-test/source-dependencies/pipelining/use/B.scala b/sbt/src/sbt-test/source-dependencies/pipelining/use/B.scala
new file mode 100644
index 000000000..f8ec39178
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/pipelining/use/B.scala
@@ -0,0 +1,5 @@
+package example
+
+object B {
+  val y = A.x
+}
diff --git a/sbt/src/sbt-test/source-dependencies/relative-source-error/changes/absolute.sbt b/sbt/src/sbt-test/source-dependencies/relative-source-error/changes/absolute.sbt
deleted file mode 100644
index a5f2d007a..000000000
--- a/sbt/src/sbt-test/source-dependencies/relative-source-error/changes/absolute.sbt
+++ /dev/null
@@ -1 +0,0 @@
-scalaSource in Compile := baseDirectory.value / "src"
\ No newline at end of file
diff --git a/sbt/src/sbt-test/source-dependencies/relative-source-error/changes/relative.sbt b/sbt/src/sbt-test/source-dependencies/relative-source-error/changes/relative.sbt
deleted file mode 100644
index 8e898fe02..000000000
--- a/sbt/src/sbt-test/source-dependencies/relative-source-error/changes/relative.sbt
+++ /dev/null
@@ -1 +0,0 @@
-scalaSource in Compile := file("src")
\ No newline at end of file
diff --git a/sbt/src/sbt-test/source-dependencies/relative-source-error/test b/sbt/src/sbt-test/source-dependencies/relative-source-error/test
deleted file mode 100644
index fb8e9dce8..000000000
--- a/sbt/src/sbt-test/source-dependencies/relative-source-error/test
+++ /dev/null
@@ -1,7 +0,0 @@
-$ copy-file changes/relative.sbt build.sbt
-> reload
--> compile
-
-$ copy-file changes/absolute.sbt build.sbt
-> reload
-> compile
diff --git a/sbt/src/sbt-test/source-dependencies/repeated-parameters/test b/sbt/src/sbt-test/source-dependencies/repeated-parameters/disabled
similarity index 100%
rename from sbt/src/sbt-test/source-dependencies/repeated-parameters/test
rename to sbt/src/sbt-test/source-dependencies/repeated-parameters/disabled
diff --git a/sbt/src/sbt-test/source-dependencies/restore-classes/build.sbt b/sbt/src/sbt-test/source-dependencies/restore-classes/build.sbt
index 547d55a10..e0254391f 100644
--- a/sbt/src/sbt-test/source-dependencies/restore-classes/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/restore-classes/build.sbt
@@ -3,10 +3,26 @@ import complete.DefaultParsers._
 
 crossTarget in Compile := target.value
 
-val checkIterations = inputKey[Unit]("Verifies the accumlated number of iterations of incremental compilation.")
+// Reset compiler iterations, necessary because tests run in batch mode
+val recordPreviousIterations = taskKey[Unit]("Record previous iterations.")
+recordPreviousIterations := {
+  val log = streams.value.log
+  CompileState.previousIterations = {
+    val previousAnalysis = (previousCompile in Compile).value.analysis.asScala
+    previousAnalysis match {
+      case None =>
+        log.info("No previous analysis detected")
+        0
+      case Some(a: Analysis) => a.compilations.allCompilations.size
+      case Some(_) => -1 // should be unreachable but causes warnings
+    }
+  }
+}
+
+val checkIterations = inputKey[Unit]("Verifies the accumulated number of iterations of incremental compilation.")
 
 checkIterations := {
   val expected: Int = (Space ~> NatBasic).parsed
-  val actual: Int = (compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }
+  val actual: Int = ((compile in Compile).value match { case a: Analysis => a.compilations.allCompilations.size }) - CompileState.previousIterations
   assert(expected == actual, s"Expected $expected compilations, got $actual")
 }
diff --git a/sbt/src/sbt-test/source-dependencies/restore-classes/project/CompileState.scala b/sbt/src/sbt-test/source-dependencies/restore-classes/project/CompileState.scala
new file mode 100644
index 000000000..078db9c7b
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/restore-classes/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var previousIterations: Int = -1
+}
diff --git a/sbt/src/sbt-test/source-dependencies/restore-classes/test b/sbt/src/sbt-test/source-dependencies/restore-classes/test
index 028d6226c..ad191d5fe 100644
--- a/sbt/src/sbt-test/source-dependencies/restore-classes/test
+++ b/sbt/src/sbt-test/source-dependencies/restore-classes/test
@@ -2,6 +2,7 @@ $ copy-file changes/A1.scala A.scala
 $ copy-file changes/B.scala B.scala
 # B depends on A
 # 1 iteration
+> recordPreviousIterations
 > compile
 
 $ copy-file changes/A2.scala A.scala
diff --git a/sbt/src/sbt-test/source-dependencies/same-file-used-names/build.sbt b/sbt/src/sbt-test/source-dependencies/same-file-used-names/build.sbt
deleted file mode 100644
index 8a38ef414..000000000
--- a/sbt/src/sbt-test/source-dependencies/same-file-used-names/build.sbt
+++ /dev/null
@@ -1 +0,0 @@
-incOptions := incOptions.value.withNameHashing(true)
diff --git a/sbt/src/sbt-test/source-dependencies/struct/pending b/sbt/src/sbt-test/source-dependencies/struct/test
similarity index 50%
rename from sbt/src/sbt-test/source-dependencies/struct/pending
rename to sbt/src/sbt-test/source-dependencies/struct/test
index 72a7a8ebd..4effcedde 100644
--- a/sbt/src/sbt-test/source-dependencies/struct/pending
+++ b/sbt/src/sbt-test/source-dependencies/struct/test
@@ -1,6 +1,3 @@
-# Marked as pending because name hashing doesn't support structural types
-# in some cases. See: https://github.com/sbt/sbt/issues/1545
-
 > compile
 
 # modify A.scala so that it does not conform to the structural type in B.scala
diff --git a/sbt/src/sbt-test/source-dependencies/trait-member-modified/build.sbt b/sbt/src/sbt-test/source-dependencies/trait-member-modified/build.sbt
index 77dc6c5b6..d951aaaf5 100644
--- a/sbt/src/sbt-test/source-dependencies/trait-member-modified/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/trait-member-modified/build.sbt
@@ -1,4 +1,16 @@
+import xsbti.VirtualFileRef
 import sbt.internal.inc.Analysis
+import xsbti.compile.{PreviousResult, CompileAnalysis, MiniSetup}
+import xsbti.compile.analysis.{ Compilation => XCompilation }
+
+previousCompile in Compile := {
+  val previous = (previousCompile in Compile).value
+  if (!CompileState.isNew) {
+    val res = PreviousResult.of(none[CompileAnalysis].asJava, none[MiniSetup].asJava)
+    CompileState.isNew = true
+    res
+  } else previous
+}
 
 /* Performs checks related to compilations:
  *  a) checks in which compilation given set of files was recompiled
@@ -7,22 +19,24 @@ import sbt.internal.inc.Analysis
 TaskKey[Unit]("checkCompilations") := {
   val analysis = (compile in Compile).value match { case a: Analysis => a }
   val srcDir = (scalaSource in Compile).value
-  def relative(f: java.io.File): java.io.File =  f.relativeTo(srcDir) getOrElse f
-  def findFile(className: String): File = {
-    relative(analysis.relations.definesClass(className).head)
+  def findFile(className: String): VirtualFileRef = {
+    analysis.relations.definesClass(className).head
   }
   val allCompilations = analysis.compilations.allCompilations
-  val recompiledFiles: Seq[Set[java.io.File]] = allCompilations map { c =>
+  val recompiledFiles: Seq[Set[VirtualFileRef]] = allCompilations map { c: XCompilation =>
     val recompiledFiles = analysis.apis.internal.collect {
-      case (cn, api) if api.compilation.startTime == c.startTime => findFile(cn)
+      case (cn, api) if api.compilationTimestamp == c.getStartTime => findFile(cn)
     }
     recompiledFiles.toSet
   }
   def recompiledFilesInIteration(iteration: Int, fileNames: Set[String]) = {
-    val files = fileNames.map(new java.io.File(_))
-    assert(recompiledFiles(iteration) == files, "%s != %s".format(recompiledFiles(iteration), files))
+    assert(recompiledFiles(iteration).map(_.name) == fileNames,
+      s"""${recompiledFiles(iteration).map(_.name)} != $fileNames
+         |
+         |allCompilations = $allCompilations
+         |""".stripMargin)
   }
-  assert(allCompilations.size == 2)
+  assert(allCompilations.size == 2, s"All compilations is ${allCompilations.size}")
   // B.scala is just compiled at the beginning
   recompiledFilesInIteration(0, Set("B.scala"))
   // A.scala is changed and recompiled
diff --git a/sbt/src/sbt-test/source-dependencies/trait-member-modified/project/CompileState.scala b/sbt/src/sbt-test/source-dependencies/trait-member-modified/project/CompileState.scala
new file mode 100644
index 000000000..c50b231cc
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/trait-member-modified/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var isNew: Boolean = false
+}
diff --git a/sbt/src/sbt-test/source-dependencies/transitive-memberRef/build.sbt b/sbt/src/sbt-test/source-dependencies/transitive-memberRef/build.sbt
index dcd1f99f2..9124b2590 100644
--- a/sbt/src/sbt-test/source-dependencies/transitive-memberRef/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/transitive-memberRef/build.sbt
@@ -1,40 +1,66 @@
 import sbt.internal.inc.Analysis
+import xsbti.VirtualFileRef
+import xsbti.api.AnalyzedClass
+import xsbti.compile.{PreviousResult, CompileAnalysis, MiniSetup}
+import xsbti.compile.analysis.{ Compilation => XCompilation }
 
 logLevel := Level.Debug
 
-// disable sbt's heauristic which recompiles everything in case
+// Reset compile status because scripted tests are run in batch mode
+previousCompile in Compile := {
+  val previous = (previousCompile in Compile).value
+  if (!CompileState.isNew) {
+    val res = PreviousResult.of(none[CompileAnalysis].asJava, none[MiniSetup].asJava)
+    CompileState.isNew = true
+    res
+  } else previous
+}
+
+// disable sbt's heuristic which recompiles everything in case
 // some fraction (e.g. 50%) of files is scheduled to be recompiled
 // in this test we want precise information about recompiled files
 // which that heuristic would distort
 incOptions := incOptions.value.withRecompileAllFraction(1.0)
 
+Global / allowMachinePath := false
+
 /* Performs checks related to compilations:
  *  a) checks in which compilation given set of files was recompiled
  *  b) checks overall number of compilations performed
  */
 TaskKey[Unit]("checkCompilations") := {
+  val log = streams.value.log
+  val c = fileConverter.value
+  val vs = (Compile / sources).value.toVector map { x =>
+    c.toVirtualFile(x.toPath)
+  }
+  // log.info(vs.mkString(","))
+
   val analysis = (compile in Compile).value match { case a: Analysis => a }
   val srcDir = (scalaSource in Compile).value
-  def relative(f: java.io.File): java.io.File =  f.relativeTo(srcDir) getOrElse f
-  def findFile(className: String): File = {
-    relative(analysis.relations.definesClass(className).head)
+  def findFile(className: String): VirtualFileRef = {
+    analysis.relations.definesClass(className).head
   }
-  val allCompilations = analysis.compilations.allCompilations
-  val recompiledFiles: Seq[Set[java.io.File]] = allCompilations map { c =>
+  val allCompilations: Seq[XCompilation] = analysis.compilations.allCompilations
+  log.info(s"allCompilations: $allCompilations")
+  val recompiledFiles: Seq[Set[VirtualFileRef]] = allCompilations map { c: XCompilation =>
     val recompiledFiles = analysis.apis.internal.collect {
-      case (cn, api) if api.compilation.startTime == c.startTime => findFile(cn)
+      case (cn, api) if api.compilationTimestamp == c.getStartTime => findFile(cn)
     }
     recompiledFiles.toSet
   }
   def recompiledFilesInIteration(iteration: Int, fileNames: Set[String]) = {
-    val files = fileNames.map(new java.io.File(_))
-    assert(recompiledFiles(iteration) == files, "%s != %s".format(recompiledFiles(iteration), files))
+    assert(recompiledFiles(iteration).map(_.name) == fileNames,
+      s"""${recompiledFiles(iteration).map(_.name)} != $fileNames
+         |
+         |allCompilations = $allCompilations
+         |""".stripMargin)
   }
   // Y.scala is compiled only at the beginning as changes to A.scala do not affect it
   recompiledFilesInIteration(0, Set("X.scala", "Y.scala"))
   // A.scala is changed and recompiled
   recompiledFilesInIteration(1, Set("A.scala"))
-  // change in A.scala causes recompilation of B.scala, C.scala, D.scala which depend on transtiviely
+  // change in A.scala causes recompilation of B.scala, C.scala, D.scala which depend on transitively
   // and by inheritance on A.scala
   // X.scala is also recompiled because it depends by member reference on B.scala
   // Note that Y.scala is not recompiled because it depends just on X through member reference dependency
diff --git a/sbt/src/sbt-test/source-dependencies/transitive-memberRef/project/CompileState.scala b/sbt/src/sbt-test/source-dependencies/transitive-memberRef/project/CompileState.scala
new file mode 100644
index 000000000..c50b231cc
--- /dev/null
+++ b/sbt/src/sbt-test/source-dependencies/transitive-memberRef/project/CompileState.scala
@@ -0,0 +1,4 @@
+// This is necessary because tests are run in batch mode
+object CompileState {
+  @volatile var isNew: Boolean = false
+}
diff --git a/sbt/src/sbt-test/source-dependencies/type-alias/build.sbt b/sbt/src/sbt-test/source-dependencies/type-alias/build.sbt
index c5a1099aa..00edfde1d 100644
--- a/sbt/src/sbt-test/source-dependencies/type-alias/build.sbt
+++ b/sbt/src/sbt-test/source-dependencies/type-alias/build.sbt
@@ -1,3 +1 @@
 logLevel in compile := Level.Debug
-
-incOptions := incOptions.value.withNameHashing(true)
diff --git a/sbt/src/sbt-test/tests/arguments-new/build.sbt b/sbt/src/sbt-test/tests/arguments-new/build.sbt
deleted file mode 100644
index e1037fbda..000000000
--- a/sbt/src/sbt-test/tests/arguments-new/build.sbt
+++ /dev/null
@@ -1,14 +0,0 @@
-scalaVersion := "2.10.6"
-libraryDependencies += "org.scalatest" % "scalatest_2.10" % "2.0.M6-SNAP28" % "test"
-
-
-testOptions in Configurations.Test ++= {
-	def args(path: String, args: String*): Seq[TestOption] = if(file(path).exists) Tests.Argument(args : _*) :: Nil else Nil
-//
-	args("success1", "-n", "test2 test3") ++
-	args("success2", "-n", "test2") ++
-	args("success3", "-n", "test3") ++
-	args("failure1", "-n", "test1") ++
-	args("failure2", "-n", "test1 test4") ++
-	args("failure3", "-n", "test1 test3")
-}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/tests/arguments-new/src/test/scala/ArgumentTest.scala b/sbt/src/sbt-test/tests/arguments-new/src/test/scala/ArgumentTest.scala
deleted file mode 100644
index 155c6a7e3..000000000
--- a/sbt/src/sbt-test/tests/arguments-new/src/test/scala/ArgumentTest.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-
-import org.scalatest.fixture.FunSuite
-import org.scalatest.Tag
-
-class ArgumentTest extends FunSuite{
-  type FixtureParam = Map[String,Any]
-  override def withFixture(test: OneArgTest) = {
-    test(test.configMap)
-  }
-  test("1", Tag("test1")){ conf => sys.error("error #1") }
-  test("2", Tag("test2")){ conf => () }
-  test("3", Tag("test3")){ conf => () }
-  test("4", Tag("test4")){ conf => sys.error("error #4") }
-}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/tests/arguments-new/test b/sbt/src/sbt-test/tests/arguments-new/test
deleted file mode 100644
index c410396aa..000000000
--- a/sbt/src/sbt-test/tests/arguments-new/test
+++ /dev/null
@@ -1,26 +0,0 @@
-# should fail because it should run all test:tests, some of which are expected to fail (1 and 4)
--> test:test
-
-$ touch success1
-> test:test
-$ delete success1
-
-$ touch failure1
--> test:test
-$ delete failure1
-
-$ touch success2
-> test:test
-$ delete success2
-
-$ touch failure2
--> test:test
-$ delete failure2
-
-$ touch success3
-> test:test
-$ delete success3
-
-$ touch failure3
--> test:test
-$ delete failure3
\ No newline at end of file
diff --git a/sbt/src/sbt-test/tests/arguments/build.sbt b/sbt/src/sbt-test/tests/arguments/build.sbt
index 34c601886..34877ddf4 100644
--- a/sbt/src/sbt-test/tests/arguments/build.sbt
+++ b/sbt/src/sbt-test/tests/arguments/build.sbt
@@ -1,13 +1,28 @@
-libraryDependencies += "org.scalatest" % "scalatest_2.10.0-RC3" % "1.8-B1" % "test"
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
 
+ThisBuild / scalaVersion := "2.12.12"
 
-testOptions in Configurations.Test ++= {
-	def args(path: String, args: String*): Seq[TestOption] = if(file(path).exists) Tests.Argument(args : _*) :: Nil else Nil
-//
-	args("success1", "-n", "test2 test3") ++
-	args("success2", "-n", "test2") ++
-	args("success3", "-n", "test3") ++
-	args("failure1", "-n", "test1") ++
-	args("failure2", "-n", "test1 test4") ++
-	args("failure3", "-n", "test1 test3")
-}
\ No newline at end of file
+val foo = settingKey[Seq[String]]("foo")
+val checkFoo = inputKey[Unit]("check contents of foo")
+
+lazy val root = (project in file("."))
+  .settings(
+    foo := Nil,
+    checkFoo := {
+      val arguments = Def.spaceDelimited("").parsed.mkString(" ")
+      assert(foo.value.contains(arguments))
+    },
+    libraryDependencies += scalatest % Test,
+    // testOptions in Test += Tests.Argument(TestFrameworks.ScalaTest, "-f", "result.txt", "-eNDXEHLO")
+    testOptions in Configurations.Test ++= {
+      def args(path: String, args: String*): Seq[TestOption] =
+        if(file(path).exists) Tests.Argument(args : _*) :: Nil
+        else Nil
+      args("success1", "-n", "test2 test3") ++
+      args("success2", "-n", "test2") ++
+      args("success3", "-n", "test3") ++
+      args("failure1", "-n", "test1") ++
+      args("failure2", "-n", "test1 test4") ++
+      args("failure3", "-n", "test1 test3")
+    }
+  )
diff --git a/sbt/src/sbt-test/tests/arguments/src/test/scala/ArgumentTest.scala b/sbt/src/sbt-test/tests/arguments/src/test/scala/ArgumentTest.scala
index 62a4ef4a0..896e54148 100644
--- a/sbt/src/sbt-test/tests/arguments/src/test/scala/ArgumentTest.scala
+++ b/sbt/src/sbt-test/tests/arguments/src/test/scala/ArgumentTest.scala
@@ -1,12 +1,19 @@
-
-import org.scalatest.fixture.FixtureFunSuite
+import org.scalatest._
 import org.scalatest.Tag
+import org.scalatest.fixture
 
-class ArgumentTest extends FixtureFunSuite{
+class ArgumentTest extends fixture.FunSuite {
   type FixtureParam = Map[String,Any]
-  override def withFixture(test: OneArgTest): Unit = {
-    test(test.configMap)
+
+  override def withFixture(test: OneArgTest) = {
+    // Perform setup
+    val theFixture = test.configMap
+    try withFixture(test.toNoArgTest(theFixture)) // Invoke the test function
+    finally {
+      // Perform cleanup
+    }
   }
+
   test("1", Tag("test1")){ conf => sys.error("error #1") }
   test("2", Tag("test2")){ conf => () }
   test("3", Tag("test3")){ conf => () }
diff --git a/sbt/src/sbt-test/tests/arguments/test b/sbt/src/sbt-test/tests/arguments/test
index c410396aa..792eb6bc7 100644
--- a/sbt/src/sbt-test/tests/arguments/test
+++ b/sbt/src/sbt-test/tests/arguments/test
@@ -23,4 +23,10 @@ $ delete success3
 
 $ touch failure3
 -> test:test
-$ delete failure3
\ No newline at end of file
+$ delete failure3
+
+> set Compile / scalacOptions += "-Xfatal-warnings"
+
+> set foo += "an argument with spaces"
+
+> checkFoo an argument with spaces
diff --git a/sbt/src/sbt-test/tests/bak/build.sbt b/sbt/src/sbt-test/tests/bak/build.sbt
new file mode 100644
index 000000000..40b598c48
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/build.sbt
@@ -0,0 +1,45 @@
+// https://github.com/sbt/sbt/issues/1673#issuecomment-537327439
+
+val Config_0 = config("config-0").extend(Compile)
+val Config_1 = config("config-1").extend(Compile)
+val Config_2 = config("config-2").extend(Compile)
+val Config_3 = config("config-3").extend(Compile)
+val Config_4 = config("config-4").extend(Compile)
+val Config_5 = config("config-5").extend(Compile)
+val Config_6 = config("config-6").extend(Compile)
+val Config_7 = config("config-7").extend(Compile)
+val Config_8 = config("config-8").extend(Compile)
+val Config_9 = config("config-9").extend(Compile)
+val Config_10 = config("config-10").extend(Compile)
+val Config_11 = config("config-11").extend(Compile)
+val Config_12 = config("config-12").extend(Compile)
+val Config_13 = config("config-13").extend(Compile)
+val Config_14 = config("config-14").extend(Compile)
+val Config_15 = config("config-15").extend(Compile)
+
+val CustomConfigs = List(Config_0, Config_1, Config_2, Config_3, Config_4, Config_5, Config_6, Config_7, Config_8, Config_9, Config_10, Config_11, Config_12, Config_13, Config_14, Config_15)
+
+val t = taskKey[Unit]("")
+val p1 = project
+  .configs(CustomConfigs: _*)
+  .settings(
+    t := {
+        (compile in Config_0).value
+        (compile in Config_1).value
+        (compile in Config_2).value
+        (compile in Config_3).value
+        (compile in Config_4).value
+        (compile in Config_5).value
+        (compile in Config_6).value
+        (compile in Config_7).value
+        (compile in Config_8).value
+        (compile in Config_9).value
+        (compile in Config_10).value
+        (compile in Config_11).value
+        (compile in Config_12).value
+        (compile in Config_13).value
+        (compile in Config_14).value
+        (compile in Config_15).value
+    }
+  )
+  .settings(CustomConfigs.flatMap(c => inConfig(c)(Defaults.testSettings)))
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-0/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-0/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-0/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-1/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-1/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-1/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-10/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-10/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-10/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-11/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-11/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-11/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-12/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-12/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-12/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-13/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-13/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-13/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-14/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-14/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-14/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-15/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-15/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-15/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-2/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-2/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-2/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-3/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-3/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-3/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-4/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-4/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-4/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-5/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-5/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-5/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-6/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-6/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-6/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-7/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-7/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-7/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-8/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-8/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-8/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/config-9/scala/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/config-9/scala/A.scala
new file mode 100644
index 000000000..3e19b86a5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/config-9/scala/A.scala
@@ -0,0 +1,2 @@
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/main/java/p1/J.java b/sbt/src/sbt-test/tests/bak/p1/src/main/java/p1/J.java
new file mode 100644
index 000000000..3447cf9f3
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/main/java/p1/J.java
@@ -0,0 +1 @@
+package p1;
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/main/scala/p1/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/main/scala/p1/A.scala
new file mode 100644
index 000000000..accef61c7
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/p1/src/main/scala/p1/A.scala
@@ -0,0 +1,4 @@
+package p1
+
+class A
+object A
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/test/java/p1/J.java b/sbt/src/sbt-test/tests/bak/p1/src/test/java/p1/J.java
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/tests/bak/p1/src/test/scala/p1/A.scala b/sbt/src/sbt-test/tests/bak/p1/src/test/scala/p1/A.scala
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/tests/bak/test b/sbt/src/sbt-test/tests/bak/test
new file mode 100644
index 000000000..5a2768534
--- /dev/null
+++ b/sbt/src/sbt-test/tests/bak/test
@@ -0,0 +1,3 @@
+> p1/t;clean;p1/t;clean;p1/t;clean
+$ sleep 100
+> p1/t;clean;p1/t;clean;p1/t;clean
diff --git a/sbt/src/sbt-test/tests/do-not-discover/build.sbt b/sbt/src/sbt-test/tests/do-not-discover/build.sbt
index c6097a06c..4a2b5826a 100644
--- a/sbt/src/sbt-test/tests/do-not-discover/build.sbt
+++ b/sbt/src/sbt-test/tests/do-not-discover/build.sbt
@@ -1,5 +1,9 @@
-scalaVersion := "2.10.6"
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
 
-libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M6-SNAP28"
+ThisBuild / scalaVersion := "2.12.12"
 
-testOptions in Test += Tests.Argument("-r", "custom.CustomReporter")
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += scalatest,
+    Test / testOptions += Tests.Argument("-C", "custom.CustomReporter")
+  )
diff --git a/sbt/src/sbt-test/tests/done/build.sbt b/sbt/src/sbt-test/tests/done/build.sbt
index c6097a06c..4a2b5826a 100644
--- a/sbt/src/sbt-test/tests/done/build.sbt
+++ b/sbt/src/sbt-test/tests/done/build.sbt
@@ -1,5 +1,9 @@
-scalaVersion := "2.10.6"
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
 
-libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M6-SNAP28"
+ThisBuild / scalaVersion := "2.12.12"
 
-testOptions in Test += Tests.Argument("-r", "custom.CustomReporter")
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += scalatest,
+    Test / testOptions += Tests.Argument("-C", "custom.CustomReporter")
+  )
diff --git a/sbt/src/sbt-test/tests/empty/build.sbt b/sbt/src/sbt-test/tests/empty/build.sbt
index 6c6170abf..a4448f16f 100644
--- a/sbt/src/sbt-test/tests/empty/build.sbt
+++ b/sbt/src/sbt-test/tests/empty/build.sbt
@@ -4,6 +4,7 @@ testGrouping := {
     new Tests.Group(
       name = test.name,
       tests = Seq(test),
-      runPolicy = Tests.SubProcess(javaOptions = Seq.empty[String]))
+      runPolicy = Tests.SubProcess(ForkOptions().withRunJVMOptions(Vector()))
+    )
   }
 }
diff --git a/sbt/src/sbt-test/tests/filter-runners/build.sbt b/sbt/src/sbt-test/tests/filter-runners/build.sbt
new file mode 100644
index 000000000..c24c76ba9
--- /dev/null
+++ b/sbt/src/sbt-test/tests/filter-runners/build.sbt
@@ -0,0 +1,9 @@
+val scalatest = "org.scalatest" %% "scalatest" % "3.2.2"
+val munit = "org.scalameta" %% "munit" % "0.7.22"
+
+ThisBuild / scalaVersion := "2.12.12"
+
+libraryDependencies += scalatest % Test
+libraryDependencies += munit % Test
+
+testFrameworks += new TestFramework("munit.Framework")
diff --git a/sbt/src/sbt-test/tests/filter-runners/src/test/scala/example/MunitSpec.scala b/sbt/src/sbt-test/tests/filter-runners/src/test/scala/example/MunitSpec.scala
new file mode 100644
index 000000000..4d500a981
--- /dev/null
+++ b/sbt/src/sbt-test/tests/filter-runners/src/test/scala/example/MunitSpec.scala
@@ -0,0 +1,9 @@
+package example
+
+import munit.FunSuite
+
+class Spec extends FunSuite {
+  test("munit should work") {
+    assertEquals(1, 1)
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/tests/filter-runners/src/test/scala/example/ScalaTestSpec.scala b/sbt/src/sbt-test/tests/filter-runners/src/test/scala/example/ScalaTestSpec.scala
new file mode 100644
index 000000000..b9e43722c
--- /dev/null
+++ b/sbt/src/sbt-test/tests/filter-runners/src/test/scala/example/ScalaTestSpec.scala
@@ -0,0 +1,10 @@
+package example
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+class ScalaTestSpec extends AnyFlatSpec with Matchers {
+  "ScalaTest" should "work" in {
+    1 shouldBe 1
+  }
+}
diff --git a/sbt/src/sbt-test/tests/filter-runners/test b/sbt/src/sbt-test/tests/filter-runners/test
new file mode 100644
index 000000000..37b26041c
--- /dev/null
+++ b/sbt/src/sbt-test/tests/filter-runners/test
@@ -0,0 +1,2 @@
+> testOnly example.MunitSpec example.ScalaTestSpec
+> testOnly example.MunitSpec -- "--tests=munit"
diff --git a/sbt/src/sbt-test/tests/fork-async/build.sbt b/sbt/src/sbt-test/tests/fork-async/build.sbt
new file mode 100644
index 000000000..bd0bb8041
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-async/build.sbt
@@ -0,0 +1,8 @@
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += "com.lihaoyi" %% "utest" % "0.6.4" % Test,
+    testFrameworks += new TestFramework("utest.runner.Framework"),
+    Test / fork := true
+  )
diff --git a/sbt/src/sbt-test/tests/fork-async/src/test/scala/ForkAsyncTest.scala b/sbt/src/sbt-test/tests/fork-async/src/test/scala/ForkAsyncTest.scala
new file mode 100644
index 000000000..a8bc4c0f2
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-async/src/test/scala/ForkAsyncTest.scala
@@ -0,0 +1,21 @@
+import utest._
+
+import utest._
+import utest.framework._
+
+import scala.concurrent.{ ExecutionContext, Promise }
+import scala.util.Success
+
+object ForkAsyncTest extends TestSuite {
+  val g = ExecutionContext.global
+  val n = 10
+  val (testNames, promises) = (1 to n).map(i => Tree(s"$i") -> Promise[Unit]).unzip
+  val testTrees = promises.zipWithIndex.map { case (p, i) =>
+    new TestCallTree(Left {
+      if (i == (n - 1)) promises.foreach(p => g.execute(() => p.tryComplete(Success(()))))
+      p.future
+    })
+  }
+  val tests =
+    Tests(nameTree = Tree("async", testNames: _*), callTree = new TestCallTree(Right(testTrees)))
+}
diff --git a/sbt/src/sbt-test/tests/fork-async/test b/sbt/src/sbt-test/tests/fork-async/test
new file mode 100644
index 000000000..dfffb838b
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-async/test
@@ -0,0 +1 @@
+> test
diff --git a/sbt/src/sbt-test/tests/fork-parallel/build.sbt b/sbt/src/sbt-test/tests/fork-parallel/build.sbt
index d46339550..2d60ab369 100644
--- a/sbt/src/sbt-test/tests/fork-parallel/build.sbt
+++ b/sbt/src/sbt-test/tests/fork-parallel/build.sbt
@@ -1,17 +1,20 @@
 import Tests._
 import Defaults._
 
+ThisBuild / scalaVersion := "2.12.12"
 val check = taskKey[Unit]("Check that tests are executed in parallel")
 
-lazy val root = (project in file(".")).
-  settings(
-    scalaVersion := "2.11.8",
+lazy val root = (project in file("."))
+  .settings(
     libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % Test,
     fork in Test := true,
     check := {
       val nbProc = java.lang.Runtime.getRuntime().availableProcessors()
+      val log = streams.value.log
       if( nbProc < 4 ) {
-        streams.value.log.warn("With fewer than 4 processors this test is meaningless")
+        log.warn("With fewer than 4 processors this test is meaningless")
+        // mimic behavior expected by scripted
+        if (!testForkedParallel.value) sys.error("Exiting with error (note: test not performed)")
       } else {
         // we've got at least 4 processors, we'll check the upper end but also 3 and 4 as the upper might not
         // be reached if the system is under heavy load.
diff --git a/sbt/src/sbt-test/tests/fork-parallel/test b/sbt/src/sbt-test/tests/fork-parallel/test
index 5226713d3..70e542b98 100644
--- a/sbt/src/sbt-test/tests/fork-parallel/test
+++ b/sbt/src/sbt-test/tests/fork-parallel/test
@@ -1,7 +1,8 @@
+# Note: this test is meaningless on less than four cores
+
 > test
 -> check
-
 > clean
 > set testForkedParallel := true
 > test
-> check
\ No newline at end of file
+> check
diff --git a/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/build.sbt b/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/build.sbt
new file mode 100644
index 000000000..f6eacaa6d
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/build.sbt
@@ -0,0 +1,33 @@
+val specs = "org.specs2" %% "specs2-core" % "4.3.4"
+ThisBuild / scalaVersion := "2.12.12"
+
+val TestATypeTag = Tags.Tag("TestA")
+val TestBTypeTag = Tags.Tag("TestB")
+
+Global / concurrentRestrictions := Seq(Tags.limit(TestATypeTag, 1), Tags.limit(TestBTypeTag, 1))
+
+libraryDependencies += specs % Test
+inConfig(Test)(Seq(
+  testGrouping := {
+    val home = javaHome.value
+    val strategy = outputStrategy.value
+    val baseDir = baseDirectory.value
+    val options = javaOptions.value
+    val connect = connectInput.value
+    val vars = envVars.value
+
+    definedTests.value.map { test => new Tests.Group(test.name, Seq(test), Tests.SubProcess(
+      ForkOptions(
+        javaHome = home,
+        outputStrategy = strategy,
+        bootJars = Vector(),
+        workingDirectory = Some(baseDir),
+        runJVMOptions = options.toVector,
+        connectInput = connect,
+        envVars = vars
+      )
+    ), Seq((if (test.name.contains("TestA")) TestATypeTag else TestBTypeTag) -> 1))
+    }
+  },
+  TaskKey[Unit]("test-failure") := test.failure.value
+))
diff --git a/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/src/test/scala/example/Test.scala b/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/src/test/scala/example/Test.scala
new file mode 100644
index 000000000..8222e3afe
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/src/test/scala/example/Test.scala
@@ -0,0 +1,33 @@
+package example
+
+import java.io.File
+import org.specs2.mutable.Specification
+
+trait Test extends Specification {
+  def testType: String
+  "spec" should {
+    "be run one at time" in {
+      val lock = new File(s"lock${testType}")
+      println(lock)
+      lock.mkdir() should beTrue
+      Thread.sleep(2000)
+      lock.delete() should beTrue
+    }
+  }
+}
+
+class TestA0 extends Test {
+  override def testType: String = "A"
+}
+
+class TestA1 extends Test {
+  override def testType: String = "A"
+}
+
+class TestB0 extends Test {
+  override def testType: String = "B"
+}
+
+class TestB1 extends Test {
+  override def testType: String = "B"
+}
diff --git a/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/test b/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/test
new file mode 100644
index 000000000..c3fa9262d
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-test-group-parallel-custom-tags/test
@@ -0,0 +1,3 @@
+> test
+> set concurrentRestrictions in Global := Seq(Tags.limitAll(4))
+> testFailure
diff --git a/sbt/src/sbt-test/tests/fork-test-group-parallel/build.sbt b/sbt/src/sbt-test/tests/fork-test-group-parallel/build.sbt
new file mode 100644
index 000000000..bf225760b
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-test-group-parallel/build.sbt
@@ -0,0 +1,27 @@
+val specs = "org.specs2" %% "specs2-core" % "4.3.4"
+ThisBuild / scalaVersion := "2.12.12"
+
+Global / concurrentRestrictions := Seq(Tags.limitAll(4))
+libraryDependencies += specs % Test
+inConfig(Test)(Seq(
+  testGrouping := {
+    val home = javaHome.value
+    val strategy = outputStrategy.value
+    val baseDir = baseDirectory.value
+    val options = javaOptions.value
+    val connect = connectInput.value
+    val vars = envVars.value
+    definedTests.value.map { test => new Tests.Group(test.name, Seq(test), Tests.SubProcess(
+      ForkOptions(
+        javaHome = home,
+        outputStrategy = strategy,
+        bootJars = Vector(),
+        workingDirectory = Some(baseDir),
+        runJVMOptions = options.toVector,
+        connectInput = connect,
+        envVars = vars
+      )
+    ))}
+  },
+  TaskKey[Unit]("test-failure") := test.failure.value
+))
diff --git a/sbt/src/sbt-test/tests/fork-test-group-parallel/disabled b/sbt/src/sbt-test/tests/fork-test-group-parallel/disabled
new file mode 100644
index 000000000..26c3b2549
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-test-group-parallel/disabled
@@ -0,0 +1,3 @@
+> testFailure
+> set concurrentRestrictions in Global += Tags.limit(Tags.ForkedTestGroup, 1)
+> test
diff --git a/sbt/src/sbt-test/tests/fork-test-group-parallel/src/test/scala/example/Test.scala b/sbt/src/sbt-test/tests/fork-test-group-parallel/src/test/scala/example/Test.scala
new file mode 100644
index 000000000..2bd327399
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-test-group-parallel/src/test/scala/example/Test.scala
@@ -0,0 +1,23 @@
+package example
+
+import java.io.File
+import org.specs2.mutable.Specification
+
+trait Test extends Specification {
+  "spec" should {
+    "be run one at time" in {
+      val lock = new File("lock")
+      lock.mkdir() should beTrue
+      Thread.sleep(2000)
+      lock.delete() should beTrue
+    }
+  }
+}
+
+class Test0 extends Test
+
+class Test1 extends Test
+
+class Test2 extends Test
+
+class Test3 extends Test
diff --git a/sbt/src/sbt-test/tests/fork-uncaught/build.sbt b/sbt/src/sbt-test/tests/fork-uncaught/build.sbt
deleted file mode 100644
index dd42de86e..000000000
--- a/sbt/src/sbt-test/tests/fork-uncaught/build.sbt
+++ /dev/null
@@ -1,12 +0,0 @@
-scalaVersion := "2.11.8"
-
-organization := "org.example"
-
-name := "fork-uncaught"
-
-fork := true
-
-libraryDependencies ++= List(
-  "org.scala-lang.modules" %% "scala-xml" % "1.0.1",
-  "org.scalatest" %% "scalatest" % "2.2.6" % Test intransitive()
-)
diff --git a/sbt/src/sbt-test/tests/fork-uncaught/src/main/scala/Foo.scala b/sbt/src/sbt-test/tests/fork-uncaught/src/main/scala/Foo.scala
deleted file mode 100644
index 6904c903f..000000000
--- a/sbt/src/sbt-test/tests/fork-uncaught/src/main/scala/Foo.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-package foo.test
-
-object Foo { val foo = 5 }
\ No newline at end of file
diff --git a/sbt/src/sbt-test/tests/fork-uncaught/src/test/scala/FooTest.scala b/sbt/src/sbt-test/tests/fork-uncaught/src/test/scala/FooTest.scala
deleted file mode 100644
index 838ea44c4..000000000
--- a/sbt/src/sbt-test/tests/fork-uncaught/src/test/scala/FooTest.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-package foo.test
-
-import org.scalatest.{FunSpec, ShouldMatchers}
-
-class FooTest extends FunSpec with ShouldMatchers {
-
-	if(java.lang.Boolean.getBoolean("test.init.fail"))
-		sys.error("exception during construction")
-
-	describe("Foo.foo should") {
-		it("always return 5") {
-			Foo.foo should equal (5)
-		}
-	}
-}
diff --git a/sbt/src/sbt-test/tests/fork-uncaught/test b/sbt/src/sbt-test/tests/fork-uncaught/test
deleted file mode 100644
index 0f38f68bc..000000000
--- a/sbt/src/sbt-test/tests/fork-uncaught/test
+++ /dev/null
@@ -1,3 +0,0 @@
-> test
-> 'set javaOptions in Test += "-Dtest.init.fail=true"'
--> test
diff --git a/sbt/src/sbt-test/tests/fork-uncaught2/build.sbt b/sbt/src/sbt-test/tests/fork-uncaught2/build.sbt
new file mode 100644
index 000000000..2eba9d278
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-uncaught2/build.sbt
@@ -0,0 +1,17 @@
+ThisBuild / scalaVersion := "2.12.12"
+
+libraryDependencies += "org.scala-sbt" % "test-interface" % "1.0"
+
+testFrameworks := new TestFramework("build.MyFramework") :: Nil
+
+fork := true
+
+definedTests in Test += new sbt.TestDefinition(
+      "my",
+      // marker fingerprint since there are no test classes
+      // to be discovered by sbt:
+      new sbt.testing.AnnotatedFingerprint {
+        def isModule = true
+        def annotationName = "my"
+      }, true, Array()
+    )
diff --git a/sbt/src/sbt-test/tests/fork-uncaught2/src/test/scala/build/MyFramework.scala b/sbt/src/sbt-test/tests/fork-uncaught2/src/test/scala/build/MyFramework.scala
new file mode 100644
index 000000000..058630a68
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-uncaught2/src/test/scala/build/MyFramework.scala
@@ -0,0 +1,24 @@
+package build
+
+import _root_.sbt.testing._
+
+class MyFramework extends sbt.testing.Framework {
+  def fingerprints = Array(new AnnotatedFingerprint { def isModule = true; def annotationName = "my" })
+  def name = "my"
+  def runner(args: Array[String], remoteArgs: Array[String], testClassLoader: ClassLoader): Runner =
+    new MyRunner(args, remoteArgs, testClassLoader)
+}
+
+class MyRunner(val args: Array[String], val remoteArgs: Array[String],
+               val testClassLoader: ClassLoader) extends sbt.testing.Runner {
+
+  def tasks(taskDefs: Array[TaskDef]): Array[Task] =
+    if (args contains "task-boom") taskDefs map BoomTask else throw new Throwable()
+  def done(): String = ""
+
+  private case class BoomTask(taskDef: TaskDef) extends Task {
+    def tags                                                   = Array.empty[String]
+    def execute(handler: EventHandler, loggers: Array[Logger]) = throw new Throwable()
+  }
+}
+
diff --git a/sbt/src/sbt-test/tests/fork-uncaught2/test b/sbt/src/sbt-test/tests/fork-uncaught2/test
new file mode 100644
index 000000000..38c301498
--- /dev/null
+++ b/sbt/src/sbt-test/tests/fork-uncaught2/test
@@ -0,0 +1,2 @@
+-> test
+-> testOnly -- task-boom
diff --git a/sbt/src/sbt-test/tests/fork/build.sbt b/sbt/src/sbt-test/tests/fork/build.sbt
index 88832f844..77c74e51b 100644
--- a/sbt/src/sbt-test/tests/fork/build.sbt
+++ b/sbt/src/sbt-test/tests/fork/build.sbt
@@ -5,18 +5,26 @@ val groupSize = 3
 val groups = 3
 
 val check = TaskKey[Unit]("check", "Check all files were created and remove them.")
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+val scalaxml = "org.scala-lang.modules" %% "scala-xml" % "1.1.1"
 
 def groupId(idx: Int) = "group_" + (idx + 1)
 def groupPrefix(idx: Int) = groupId(idx) + "_file_"
 
-lazy val root = (project in file(".")).
-  settings(
-    scalaVersion := "2.11.8",
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / organization := "org.example"
+
+lazy val root = (project in file("."))
+  .settings(
     testGrouping in Test := {
       val tests = (definedTests in Test).value
       assert(tests.size == 3)
       for (idx <- 0 until groups) yield
-        new Group(groupId(idx), tests, SubProcess(Seq("-Dgroup.prefix=" + groupPrefix(idx))))
+        new Group(
+          groupId(idx),
+          tests,
+          SubProcess(ForkOptions().withRunJVMOptions(Vector("-Dgroup.prefix=" + groupPrefix(idx))))
+        )
     },
     check := {
       val files =
@@ -29,7 +37,7 @@ lazy val root = (project in file(".")).
     },
     concurrentRestrictions := Tags.limit(Tags.ForkedTestGroup, 2) :: Nil,
     libraryDependencies ++= List(
-      "org.scala-lang.modules" %% "scala-xml" % "1.0.1",
-      "org.scalatest" %% "scalatest" % "2.2.6" % Test
+      scalaxml,
+      scalatest % Test
     )
   )
diff --git a/sbt/src/sbt-test/tests/fork/src/test/scala/Ensemble.scala b/sbt/src/sbt-test/tests/fork/src/test/scala/Ensemble.scala
index 6d1d152d7..9dbd69cb7 100644
--- a/sbt/src/sbt-test/tests/fork/src/test/scala/Ensemble.scala
+++ b/sbt/src/sbt-test/tests/fork/src/test/scala/Ensemble.scala
@@ -1,12 +1,11 @@
 import org.scalatest.FlatSpec
-import org.scalatest.matchers.MustMatchers
 import java.io.File
 
-trait Ensemble extends FlatSpec with MustMatchers {
+trait Ensemble extends FlatSpec {
 	def i: Int
 	def prefix = System.getProperty("group.prefix")
 
-	"an ensemble" must "create all files" in {
+	"an ensemble" should "create all files" in {
 		val f = new File(prefix + i)
 		f.createNewFile
 	}
diff --git a/sbt/src/sbt-test/tests/fork2/build.sbt b/sbt/src/sbt-test/tests/fork2/build.sbt
index 3156665b5..e0e873c69 100644
--- a/sbt/src/sbt-test/tests/fork2/build.sbt
+++ b/sbt/src/sbt-test/tests/fork2/build.sbt
@@ -1,4 +1,6 @@
-scalaVersion := "2.10.6"
-fork := true
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
 
-libraryDependencies += "org.scalatest" %% "scalatest" % "1.9" % "test"
+ThisBuild / scalaVersion := "2.12.12"
+
+fork := true
+libraryDependencies += scalatest % Test
diff --git a/sbt/src/sbt-test/tests/fork2/changes/Test.scala b/sbt/src/sbt-test/tests/fork2/changes/Test.scala
index f0ecc32bb..6706da71f 100644
--- a/sbt/src/sbt-test/tests/fork2/changes/Test.scala
+++ b/sbt/src/sbt-test/tests/fork2/changes/Test.scala
@@ -1,9 +1,8 @@
 import org.scalatest.FlatSpec
-import org.scalatest.matchers.MustMatchers
 
-class Test extends FlatSpec with MustMatchers {
+class Test extends FlatSpec {
 	val v = Option(System.getenv("tests.max.value")) getOrElse Int.MaxValue
-	"A simple equation" must "hold" in {
-		Int.MaxValue must equal (v)
+	"A simple equation" should "hold" in {
+		assert(Int.MaxValue == v)
 	}
 }
diff --git a/sbt/src/sbt-test/tests/it/build.sbt b/sbt/src/sbt-test/tests/it/build.sbt
index 421d8c032..fd96cc57a 100644
--- a/sbt/src/sbt-test/tests/it/build.sbt
+++ b/sbt/src/sbt-test/tests/it/build.sbt
@@ -1,9 +1,10 @@
-lazy val root = (project in file(".")).
-  configs(IntegrationTest).
-  settings(
-    scalaVersion := "2.10.6",
-    Defaults.itSettings,
-    libraryDependencies += specs
-  )
+ThisBuild / scalaVersion := "2.12.12"
 
-lazy val specs = "org.specs2" % "specs2_2.10" % "1.12.3" % IntegrationTest
+val specs = "org.specs2" %% "specs2-core" % "4.3.4"
+
+lazy val root = (project in file("."))
+  .configs(IntegrationTest)
+  .settings(
+    Defaults.itSettings,
+    libraryDependencies += specs % IntegrationTest
+  )
diff --git a/sbt/src/sbt-test/tests/junit-xml-report/build.sbt b/sbt/src/sbt-test/tests/junit-xml-report/build.sbt
index 18e504dd6..8fae2d48f 100644
--- a/sbt/src/sbt-test/tests/junit-xml-report/build.sbt
+++ b/sbt/src/sbt-test/tests/junit-xml-report/build.sbt
@@ -5,21 +5,37 @@ import Defaults._
 val checkReport = taskKey[Unit]("Check the test reports")
 val checkNoReport = taskKey[Unit]("Check that no reports are present")
 
-val oneSecondReportFile = "target/test-reports/a.pkg.OneSecondTest.xml"
-val failingReportFile = "target/test-reports/another.pkg.FailingTest.xml"
+val oneSecondReportFile = "target/test-reports/TEST-a.pkg.OneSecondTest.xml"
+val failingReportFile = "target/test-reports/TEST-another.pkg.FailingTest.xml"
+
+val flatSuiteReportFile = "target/test-reports/TEST-my.scalatest.MyFlatSuite.xml"
+val nestedSuitesReportFile = "target/test-reports/TEST-my.scalatest.MyNestedSuites.xml"
+
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+val junitinterface = "com.novocode" % "junit-interface" % "0.11"
+
+ThisBuild / scalaVersion := "2.12.12"
 
 lazy val root = (project in file(".")).
   settings(
-    scalaVersion := "2.11.8",
-    libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % Test,
-
+    libraryDependencies += junitinterface % Test,
+    libraryDependencies += scalatest % Test,
     // TODO use matchers instead of sys.error
     checkReport := {
       val oneSecondReport = XML.loadFile(oneSecondReportFile)
       if( oneSecondReport.label != "testsuite" ) sys.error("Report should have a root <testsuite> element.")
       // somehow the 'success' event doesn't go through... TODO investigate
 //      if( (oneSecondReport \ "@time").text.toFloat < 1f ) sys.error("expected test to take at least 1 sec")
-      if( (oneSecondReport \ "@name").text != "a.pkg.OneSecondTest" ) sys.error("wrong test name: " + (oneSecondReport \ "@name").text)
+      if( (oneSecondReport \ "@tests").text != "1" ) sys.error("expected 1 tests")
+      if( (oneSecondReport \ "@failures").text != "0" ) sys.error("expected 0 failures")
+      if( (oneSecondReport \ "@name").text != "a.pkg.OneSecondTest" ) sys.error("wrong fixture name: " + (oneSecondReport \ "@name").text)
+      oneSecondReport foreach { testsuite =>
+        val className = testsuite \ "testcase" \@ "classname"
+        if( className != "a.pkg.OneSecondTest" ) sys.error(s"wrong class name: $className")
+
+        val actualTestName = testsuite \ "testcase" \@ "name"
+        if( actualTestName != "oneSecond") sys.error(s"wrong test names: $actualTestName")
+      }
       // TODO more checks
 
       val failingReport = XML.loadFile(failingReportFile)
@@ -28,11 +44,50 @@ lazy val root = (project in file(".")).
       if( (failingReport \ "@name").text != "another.pkg.FailingTest" ) sys.error("wrong test name: " + (failingReport \ "@name").text)
       // TODO more checks -> the two test cases with time etc..
 
+      val scalaTestFlatReport = XML.loadFile(flatSuiteReportFile)
+      if( scalaTestFlatReport.label != "testsuite" ) sys.error("Report should have a root <testsuite> element.")
+      if( (scalaTestFlatReport \ "@tests").text != "3" ) sys.error("expected 3 tests")
+      if( (scalaTestFlatReport \ "@failures").text != "1" ) sys.error("expected 1 failures")
+      if( (scalaTestFlatReport \ "@name").text != "my.scalatest.MyFlatSuite" ) sys.error("wrong fixture name: " + (scalaTestFlatReport \ "@name").text)
+      scalaTestFlatReport foreach { testsuite =>
+        val classNames = (testsuite \ "testcase").map(_ \@ "classname")
+        if( classNames.length != 3 ) sys.error(s"expected 3 classname's, actual result: " + classNames.length)
+        if( classNames.toSet != Set("my.scalatest.MyFlatSuite") ) sys.error(s"wrong class names: ${classNames.mkString(", ")}")
+
+        val expectedTestNames = Set(
+          "Passing test should pass",
+          "Passing test should also pass with file.extension",
+          "Failing test should fail"
+        )
+        val actualTestName = (testsuite \ "testcase").map(_ \@ "name")
+        if( actualTestName.toSet != expectedTestNames) sys.error(s"wrong test names: ${actualTestName.mkString(", ")}")
+      }
+
+      val nestedSuitesReport = XML.loadFile(nestedSuitesReportFile)
+      if( nestedSuitesReport.label != "testsuite" ) sys.error("Report should have a root <testsuite> element.")
+      if( (nestedSuitesReport \ "@tests").text != "2" ) sys.error("expected 2 tests")
+      if( (nestedSuitesReport \ "@failures").text != "1" ) sys.error("expected 1 failures")
+      if( (nestedSuitesReport \ "@name").text != "my.scalatest.MyNestedSuites" ) sys.error("wrong fixture name: " + (nestedSuitesReport \ "@name").text)
+      nestedSuitesReport foreach { testsuite =>
+        val classNames = (testsuite \ "testcase").map(_ \@ "classname")
+        if( classNames.length != 2 ) sys.error(s"expected 2 classname's, actual result: " + classNames.length)
+        if( classNames.toSet != Set("my.scalatest.MyInnerSuite") ) sys.error(s"wrong class names: ${classNames.mkString(", ")}")
+
+        val actualTestName = (testsuite \ "testcase").map(_ \@ "name")
+        if( actualTestName.toSet != Set("Inner passing test should pass", "Inner failing test should fail")) sys.error(s"wrong test names: ${actualTestName.mkString(", ")}")
+      }
+
       // TODO check console output is in the report
     },
 
     checkNoReport := {
-      if( file(oneSecondReportFile).exists() ) sys.error(oneSecondReportFile + " should not exist")
-      if( file(failingReportFile).exists() ) sys.error(failingReportFile + " should not exist")
+      for (f <- Seq(
+        oneSecondReportFile,
+        failingReportFile,
+        flatSuiteReportFile,
+        nestedSuitesReportFile
+      )) {
+        if( file(f).exists() ) sys.error(f + " should not exist")
+      }
     }
   )
diff --git a/sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/tests.scala b/sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/junit-tests.scala
similarity index 96%
rename from sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/tests.scala
rename to sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/junit-tests.scala
index e2843e233..897610825 100644
--- a/sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/tests.scala
+++ b/sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/junit-tests.scala
@@ -27,7 +27,7 @@ package another.pkg {
 
 package console.test.pkg {
 	// we won't check console output in the report
-	// until SBT supports that
+	// until sbt supports that
 	class ConsoleTests {
 		@Test
 		def sayHello(): Unit = {
diff --git a/sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/scala-tests.scala b/sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/scala-tests.scala
new file mode 100644
index 000000000..8e9e707e1
--- /dev/null
+++ b/sbt/src/sbt-test/tests/junit-xml-report/src/test/scala/scala-tests.scala
@@ -0,0 +1,30 @@
+import org.scalatest._
+
+package my.scalatest {
+  class MyFlatSuite extends FlatSpec {
+    "Passing test" should "pass" in {
+
+    }
+
+    it should "also pass with file.extension" in {
+
+    }
+
+    "Failing test" should "fail" in {
+      sys.error("wah wah")
+    }
+  }
+
+  @DoNotDiscover
+  class MyInnerSuite(arg: String) extends FlatSpec {
+    "Inner passing test" should "pass" in {
+
+    }
+
+    "Inner failing test" should "fail" in {
+      sys.error("wah wah")
+    }
+  }
+
+  class MyNestedSuites extends Suites(new MyInnerSuite("arrrrrg!"))
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/tests/munit/build.sbt b/sbt/src/sbt-test/tests/munit/build.sbt
new file mode 100644
index 000000000..53b13bf93
--- /dev/null
+++ b/sbt/src/sbt-test/tests/munit/build.sbt
@@ -0,0 +1,9 @@
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val munit = "org.scalameta" %% "munit" % "0.7.22"
+
+lazy val root = (project in file("."))
+  .settings(
+    Compile / scalacOptions += "-Yrangepos",
+    libraryDependencies += munit % Test
+  )
diff --git a/sbt/src/sbt-test/tests/munit/src/test/scala/ClueSuite.scala b/sbt/src/sbt-test/tests/munit/src/test/scala/ClueSuite.scala
new file mode 100644
index 000000000..f4e44be9a
--- /dev/null
+++ b/sbt/src/sbt-test/tests/munit/src/test/scala/ClueSuite.scala
@@ -0,0 +1,40 @@
+package testpkg
+
+import munit._
+
+class ClueSuite extends FunSuite {
+  val x = 42
+  val y = 32
+  checkPrint(
+    "clues",
+    clues(x, y),
+    """|Clues {
+       |  x: Int = 42
+       |  y: Int = 32
+       |}
+       |""".stripMargin
+  )
+
+  val z: List[Int] = List(1)
+  checkPrint(
+    "list",
+    clues(z),
+    """|Clues {
+       |  z: List[Int] = List(
+       |    1
+       |  )
+       |}
+       |""".stripMargin
+  )
+
+  def checkPrint(
+      options: TestOptions,
+      clues: Clues,
+      expected: String
+  )(implicit loc: Location): Unit = {
+    test(options) {
+      val obtained = munitPrint(clues)
+      assertNoDiff(obtained, expected)
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/tests/munit/test b/sbt/src/sbt-test/tests/munit/test
new file mode 100644
index 000000000..dfffb838b
--- /dev/null
+++ b/sbt/src/sbt-test/tests/munit/test
@@ -0,0 +1 @@
+> test
diff --git a/sbt/src/sbt-test/tests/nested-inproc-par/build.sbt b/sbt/src/sbt-test/tests/nested-inproc-par/build.sbt
index a6b9aba9a..bd76bb20c 100644
--- a/sbt/src/sbt-test/tests/nested-inproc-par/build.sbt
+++ b/sbt/src/sbt-test/tests/nested-inproc-par/build.sbt
@@ -1,7 +1,10 @@
-scalaVersion := "2.10.6"
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
 
-libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M6-SNAP28"
+ThisBuild / scalaVersion := "2.12.12"
 
-testOptions in Test += Tests.Argument("-r", "custom.CustomReporter")
-
-parallelExecution in Test := true
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += scalatest,
+    Test / testOptions += Tests.Argument("-C", "custom.CustomReporter"),
+    Test / parallelExecution := true
+  )
diff --git a/sbt/src/sbt-test/tests/nested-inproc-seq/build.sbt b/sbt/src/sbt-test/tests/nested-inproc-seq/build.sbt
index 85610ee5d..21b809d76 100644
--- a/sbt/src/sbt-test/tests/nested-inproc-seq/build.sbt
+++ b/sbt/src/sbt-test/tests/nested-inproc-seq/build.sbt
@@ -1,7 +1,10 @@
-scalaVersion := "2.10.6"
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
 
-libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M6-SNAP28"
+ThisBuild / scalaVersion := "2.12.12"
 
-testOptions in Test += Tests.Argument("-r", "custom.CustomReporter")
-
-parallelExecution in Test := false
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += scalatest,
+    Test / testOptions += Tests.Argument("-C", "custom.CustomReporter"),
+    Test / parallelExecution := false
+  )
diff --git a/sbt/src/sbt-test/tests/nested-subproc/build.sbt b/sbt/src/sbt-test/tests/nested-subproc/build.sbt
index 3302653bd..dc50503e9 100644
--- a/sbt/src/sbt-test/tests/nested-subproc/build.sbt
+++ b/sbt/src/sbt-test/tests/nested-subproc/build.sbt
@@ -1,10 +1,11 @@
-lazy val root = (project in file(".")).
-  settings(
-    scalaVersion := "2.11.8",
-    libraryDependencies ++= List(
-      "org.scala-lang.modules" %% "scala-xml" % "1.0.1",
-      "org.scalatest" %% "scalatest" % "2.2.6"
-    ),
-    testOptions in Test += Tests.Argument("-r", "custom.CustomReporter"),
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+val scalaxml = "org.scala-lang.modules" %% "scala-xml" % "1.1.1"
+
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies ++= List(scalatest, scalaxml),
+    Test / testOptions += Tests.Argument("-C", "custom.CustomReporter"),
     fork := true
   )
diff --git a/sbt/src/sbt-test/tests/nested-tests/build.sbt b/sbt/src/sbt-test/tests/nested-tests/build.sbt
new file mode 100644
index 000000000..d4737f0f5
--- /dev/null
+++ b/sbt/src/sbt-test/tests/nested-tests/build.sbt
@@ -0,0 +1,8 @@
+val scalcheck = "org.scalacheck" %% "scalacheck" % "1.14.0"
+
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / version := "0.0.1" 
+ThisBuild / organization := "org.catastrophe"
+
+libraryDependencies += scalcheck % Test
+name := "broken"
diff --git a/sbt/src/sbt-test/tests/nested-tests/src/test/scala/q/X.scala b/sbt/src/sbt-test/tests/nested-tests/src/test/scala/q/X.scala
new file mode 100644
index 000000000..6c80f0bce
--- /dev/null
+++ b/sbt/src/sbt-test/tests/nested-tests/src/test/scala/q/X.scala
@@ -0,0 +1,25 @@
+package q
+
+//
+// On 1.0.3+ this test will say:
+// [info] + Nesting.startsWith: OK, passed 100 tests.
+// [info] Passed: Total 1, Failed 0, Errors 0, Passed 1
+//
+// On 1.0.0 to 1.0.2 it will crash with:
+// [error] java.lang.ClassNotFoundException: q.X.Y$
+//
+
+import org.scalacheck.{Prop, Properties}
+import Prop.forAll
+
+class U extends Properties("Nesting")
+object X extends U {
+    property("startsWith") = forAll { (a: String, b: String) =>
+    (a+b).startsWith(a)
+  }
+  object Y extends U {
+    property("endsWith") = forAll { (a: String, b: String) =>
+      (a+b).endsWith(b)
+    }
+  }
+}
diff --git a/sbt/src/sbt-test/tests/nested-tests/test b/sbt/src/sbt-test/tests/nested-tests/test
new file mode 100644
index 000000000..c8987ae90
--- /dev/null
+++ b/sbt/src/sbt-test/tests/nested-tests/test
@@ -0,0 +1,2 @@
+> test
+
diff --git a/sbt/src/sbt-test/tests/one-class-multi-framework/build.sbt b/sbt/src/sbt-test/tests/one-class-multi-framework/build.sbt
index 80a62d3ce..27b51b848 100644
--- a/sbt/src/sbt-test/tests/one-class-multi-framework/build.sbt
+++ b/sbt/src/sbt-test/tests/one-class-multi-framework/build.sbt
@@ -1,6 +1,5 @@
-scalaVersion := "2.10.2"
-
-libraryDependencies += "com.novocode" % "junit-interface" % "0.10-M4" % "test"
-
-libraryDependencies += "org.specs2" %% "specs2" % "2.1.1" % "test"
-
+val specsJunit = "org.specs2" %% "specs2-junit" % "4.3.4"
+val junitinterface = "com.novocode" % "junit-interface" % "0.11"
+ThisBuild / scalaVersion := "2.12.12"
+libraryDependencies += junitinterface % Test
+libraryDependencies += specsJunit % Test
diff --git a/sbt/src/sbt-test/tests/order/build.sbt b/sbt/src/sbt-test/tests/order/build.sbt
index d6f36add2..53ce38e0e 100644
--- a/sbt/src/sbt-test/tests/order/build.sbt
+++ b/sbt/src/sbt-test/tests/order/build.sbt
@@ -1,3 +1,5 @@
-parallelExecution in Test := false
+val scalcheck = "org.scalacheck" %% "scalacheck" % "1.14.0"
 
-libraryDependencies += "org.scalacheck" %% "scalacheck" % "1.10.0" % "test"
+ThisBuild / scalaVersion := "2.12.12"
+Test / parallelExecution := false
+libraryDependencies += scalcheck % Test
diff --git a/sbt/src/sbt-test/tests/resources/build.sbt b/sbt/src/sbt-test/tests/resources/build.sbt
index 7905ed044..858e7a1c2 100644
--- a/sbt/src/sbt-test/tests/resources/build.sbt
+++ b/sbt/src/sbt-test/tests/resources/build.sbt
@@ -1,2 +1,3 @@
-scalaVersion := "2.10.6"
-libraryDependencies += "org.specs2" % "specs2_2.10" % "1.12.3" % "test"
+val specs = "org.specs2" %% "specs2-core" % "4.3.4"
+ThisBuild / scalaVersion := "2.12.12"
+libraryDependencies += specs % Test
diff --git a/sbt/src/sbt-test/tests/scala-instance-classloader/build.sbt b/sbt/src/sbt-test/tests/scala-instance-classloader/build.sbt
index 96aa4ea10..3e73d9178 100644
--- a/sbt/src/sbt-test/tests/scala-instance-classloader/build.sbt
+++ b/sbt/src/sbt-test/tests/scala-instance-classloader/build.sbt
@@ -1,32 +1,37 @@
 import sbt.internal.inc.ScalaInstance
 
 lazy val OtherScala = config("other-scala").hide
+lazy val junitinterface = "com.novocode" % "junit-interface" % "0.11"
+lazy val akkaActor = "com.typesafe.akka" %% "akka-actor" % "2.5.17"
+ThisBuild / scalaVersion := "2.12.13"
 
-configs(OtherScala)
+lazy val root = (project in file("."))
+  .configs(OtherScala)
+  .settings(
+    libraryDependencies += {
+      "org.scala-lang" % "scala-compiler" % scalaVersion.value % OtherScala.name 
+    },
+    managedClasspath in OtherScala := Classpaths.managedJars(OtherScala, classpathTypes.value, update.value),
 
-libraryDependencies += "org.scala-lang" % "scala-compiler" % "2.11.1" % OtherScala.name
+    // Hack in the scala instance
+    scalaInstance := {
+      val rawJars = (managedClasspath in OtherScala).value.map(_.data)
+      val scalaHome = (target.value / "scala-home")
+      def removeVersion(name: String): String =
+        name.replaceAll("\\-2.12.11", "")
+      for(jar <- rawJars) {
+        val tjar = scalaHome / s"lib/${removeVersion(jar.getName)}"
+        IO.copyFile(jar, tjar)
+      }
+      IO.listFiles(scalaHome).foreach(f => System.err.println(s" * $f}"))
+      ScalaInstance(scalaHome, appConfiguration.value.provider.scalaProvider.launcher)
+    },
 
-managedClasspath in OtherScala := Classpaths.managedJars(OtherScala, classpathTypes.value, update.value)
+    libraryDependencies += junitinterface % Test,
+    libraryDependencies += akkaActor % Test,
 
-// Hack in the scala instance
-scalaInstance := {
-  val rawJars = (managedClasspath in OtherScala).value.map(_.data)
-  val scalaHome = (target.value / "scala-home")
-  def removeVersion(name: String): String =
-    name.replaceAll("\\-2.11.1", "")
-  for(jar <- rawJars) {
-    val tjar = scalaHome / s"lib/${removeVersion(jar.getName)}"
-    IO.copyFile(jar, tjar)
-  }
-  IO.listFiles(scalaHome).foreach(f => System.err.println(s" * $f}"))
-  ScalaInstance(scalaHome, appConfiguration.value.provider.scalaProvider.launcher)
-}
-
-
-libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % "test"
-
-libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.3.3" % "test"
-
-scalaVersion := "2.11.0"
-
-ivyScala := ivyScala.value map {_.copy(overrideScalaVersion = sbtPlugin.value)}
+    scalaModuleInfo := {
+      val old = scalaModuleInfo.value
+      old map { _.withOverrideScalaVersion(sbtPlugin.value) }
+    }
+  )
diff --git a/sbt/src/sbt-test/tests/scala-instance-classloader/src/test/scala/Test.scala b/sbt/src/sbt-test/tests/scala-instance-classloader/src/test/scala/Test.scala
index 6006e8257..666c041b5 100644
--- a/sbt/src/sbt-test/tests/scala-instance-classloader/src/test/scala/Test.scala
+++ b/sbt/src/sbt-test/tests/scala-instance-classloader/src/test/scala/Test.scala
@@ -1,6 +1,8 @@
 package akka.actor
 
 import org.junit._
+import scala.concurrent._
+import scala.concurrent.duration._
 
 class BadTest {
 
@@ -10,11 +12,10 @@ class BadTest {
     // * Load something from our own classloader that's INSIDE the scala library
     // * Try to load that same something from the THREAD CONTEXT classloader.
     // * Ensure we can do both, i.e. the second used to be filtered and broken.
-    val current = Thread.currentThread.getContextClassLoader
-    val mine = this.getClass.getClassLoader
     val system = ActorSystem()
     def evilGetThreadExectionContextName =
       system.asInstanceOf[ActorSystemImpl].internalCallingThreadExecutionContext.getClass.getName
+    Await.result(system.terminate(), 5.seconds)
     val expected = "scala.concurrent.Future$InternalCallbackExecutor$"
     Assert.assertEquals("Failed to grab appropriate Akka name", expected, evilGetThreadExectionContextName)
   }
diff --git a/sbt/src/sbt-test/tests/scalatest/build.sbt b/sbt/src/sbt-test/tests/scalatest/build.sbt
new file mode 100644
index 000000000..1f501a862
--- /dev/null
+++ b/sbt/src/sbt-test/tests/scalatest/build.sbt
@@ -0,0 +1,12 @@
+ThisBuild / scalaVersion     := "2.13.1"
+ThisBuild / version          := "0.1.0-SNAPSHOT"
+ThisBuild / organization     := "com.example"
+ThisBuild / organizationName := "example"
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "sbt-5308",
+    libraryDependencies += "org.scalatest" %% "scalatest" % "3.1.0" % Test,
+    libraryDependencies += "com.vladsch.flexmark" % "flexmark-all" % "0.35.10" % Test,
+    Test / testOptions += Tests.Argument(TestFrameworks.ScalaTest, "-h", "target/generated/test-reports"),
+  )
diff --git a/sbt/src/sbt-test/tests/scalatest/src/test/scala/example/HelloSpec.scala b/sbt/src/sbt-test/tests/scalatest/src/test/scala/example/HelloSpec.scala
new file mode 100644
index 000000000..b1878dee1
--- /dev/null
+++ b/sbt/src/sbt-test/tests/scalatest/src/test/scala/example/HelloSpec.scala
@@ -0,0 +1,9 @@
+package example
+
+import org.scalatest._
+
+class HelloSpec extends FlatSpec with Matchers {
+  "hello" should "say hello" in {
+    assert("hello" == "hello")
+  }
+}
diff --git a/sbt/src/sbt-test/tests/scalatest/test b/sbt/src/sbt-test/tests/scalatest/test
new file mode 100644
index 000000000..dfffb838b
--- /dev/null
+++ b/sbt/src/sbt-test/tests/scalatest/test
@@ -0,0 +1 @@
+> test
diff --git a/sbt/src/sbt-test/tests/serial/build.sbt b/sbt/src/sbt-test/tests/serial/build.sbt
index eed39ce49..11e892129 100644
--- a/sbt/src/sbt-test/tests/serial/build.sbt
+++ b/sbt/src/sbt-test/tests/serial/build.sbt
@@ -1,27 +1,29 @@
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+
+ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / organization := "com.example"
+ThisBuild / version      := "0.0.1-SNAPSHOT"
+
 val commonSettings = Seq(
-  libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1" % "test"
+  libraryDependencies += scalatest % Test
 )
 
-lazy val root = (project in file(".")).
-  aggregate(sub1, sub2).
-  settings(inThisBuild(List(
-      organization := "com.softwaremill",
-      version := "0.0.1-SNAPSHOT",
-      scalaVersion := "2.10.6"
-    )),
+lazy val root = (project in file("."))
+  .aggregate(sub1, sub2)
+  .settings(
     commonSettings
   )
 
 lazy val rootRef = LocalProject("root")
 
-lazy val sub1 = project.
-  dependsOn(rootRef).
-  settings(
+lazy val sub1 = project
+  .dependsOn(rootRef)
+  .settings(
     commonSettings
   )
 
-lazy val sub2 = project.
-  dependsOn(rootRef).
-  settings(
+lazy val sub2 = project
+  .dependsOn(rootRef)
+  .settings(
     commonSettings
   )
diff --git a/sbt/src/sbt-test/tests/setup-cleanup/base.sbt b/sbt/src/sbt-test/tests/setup-cleanup/base.sbt
index 0afca122e..516692e12 100644
--- a/sbt/src/sbt-test/tests/setup-cleanup/base.sbt
+++ b/sbt/src/sbt-test/tests/setup-cleanup/base.sbt
@@ -1,2 +1,3 @@
-scalaVersion := "2.10.6"
-libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1"
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+ThisBuild / scalaVersion := "2.12.12"
+libraryDependencies += scalatest
diff --git a/sbt/src/sbt-test/tests/setup-cleanup/changes/setup.sbt b/sbt/src/sbt-test/tests/setup-cleanup/changes/setup.sbt
index d9abc7285..5b3634567 100644
--- a/sbt/src/sbt-test/tests/setup-cleanup/changes/setup.sbt
+++ b/sbt/src/sbt-test/tests/setup-cleanup/changes/setup.sbt
@@ -1,7 +1,9 @@
-testOptions in Test +=
+testOptions in Test += {
+  val baseDir = baseDirectory.value
 	Tests.Setup { () =>
-		IO.touch(baseDirectory.value / "setup")
+		IO.touch(baseDir / "setup")
 	}
+}
 
 testOptions in Test += {
 	val t = baseDirectory.value / "tested"
@@ -11,4 +13,4 @@ testOptions in Test += {
 		IO.delete(t)
 		IO.touch(c)
 	}
-}
\ No newline at end of file
+}
diff --git a/sbt/src/sbt-test/tests/setup-cleanup/src/test/scala/CheckSetupCleanup.scala b/sbt/src/sbt-test/tests/setup-cleanup/src/test/scala/CheckSetupCleanup.scala
index 054d6019b..5a4b72a7d 100644
--- a/sbt/src/sbt-test/tests/setup-cleanup/src/test/scala/CheckSetupCleanup.scala
+++ b/sbt/src/sbt-test/tests/setup-cleanup/src/test/scala/CheckSetupCleanup.scala
@@ -1,17 +1,15 @@
 import org.scalatest.FlatSpec
-import org.scalatest.matchers.MustMatchers
 import java.io.File
 
-class CheckSetupCleanup extends FlatSpec with MustMatchers
-{
+class CheckSetupCleanup extends FlatSpec {
 	val f = new File("setup")
-	"setup file" must "exist" in {
+	"setup file" should "exist" in {
 		assert(f.exists, "Setup file didn't exist: " + f.getAbsolutePath)
 		f.delete()
 	}
 
 	val t = new File("tested")
-	"cleanup file" must "not exist" in {
+	"cleanup file" should "not exist" in {
 		assert(!t.exists, "Cleanup file already existed: " + t.getAbsolutePath)
 		t.createNewFile()
 	}
diff --git a/sbt/src/sbt-test/tests/single-runner/build.sbt b/sbt/src/sbt-test/tests/single-runner/build.sbt
index c6097a06c..be394850b 100644
--- a/sbt/src/sbt-test/tests/single-runner/build.sbt
+++ b/sbt/src/sbt-test/tests/single-runner/build.sbt
@@ -1,5 +1,4 @@
-scalaVersion := "2.10.6"
-
-libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M6-SNAP28"
-
-testOptions in Test += Tests.Argument("-r", "custom.CustomReporter")
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+ThisBuild / scalaVersion := "2.12.12"
+libraryDependencies += scalatest
+Test / testOptions += Tests.Argument("-C", "custom.CustomReporter")
diff --git a/sbt/src/sbt-test/tests/source-directory-name/test b/sbt/src/sbt-test/tests/source-directory-name/test
index 23b3323ba..9fc35bcff 100644
--- a/sbt/src/sbt-test/tests/source-directory-name/test
+++ b/sbt/src/sbt-test/tests/source-directory-name/test
@@ -1,2 +1,2 @@
 > compile
-$ exists target/scala-2.11/classes/ch/epfl/scala/Client.class
+$ exists target/scala-2.12/classes/ch/epfl/scala/Client.class
diff --git a/sbt/src/sbt-test/tests/specs-run/build.sbt b/sbt/src/sbt-test/tests/specs-run/build.sbt
index c9f3e0f04..07a4350f6 100644
--- a/sbt/src/sbt-test/tests/specs-run/build.sbt
+++ b/sbt/src/sbt-test/tests/specs-run/build.sbt
@@ -1,4 +1,4 @@
-lazy val specs2 = "org.specs2" %% "specs2" % "2.3.11"
-scalaVersion := "2.11.8"
+val specs = "org.specs2" %% "specs2-core" % "4.3.4"
+ThisBuild / scalaVersion := "2.12.12"
 
-libraryDependencies += specs2 % Test
+libraryDependencies += specs % Test
diff --git a/sbt/src/sbt-test/tests/t543/build.sbt b/sbt/src/sbt-test/tests/t543/build.sbt
index 9d48c0433..982d2822b 100644
--- a/sbt/src/sbt-test/tests/t543/build.sbt
+++ b/sbt/src/sbt-test/tests/t543/build.sbt
@@ -4,14 +4,14 @@ import java.io.{ CharArrayWriter, PrintWriter }
 
 val marker = new File("marker")
 val check = TaskKey[Unit]("check", "Check correct error has been returned.")
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+val scalaxml = "org.scala-lang.modules" %% "scala-xml" % "1.1.1"
+
+ThisBuild / scalaVersion := "2.12.12"
 
 lazy val root = (project in file(".")).
   settings(
-    libraryDependencies ++= List(
-      "org.scala-lang.modules" %% "scala-xml" % "1.0.1",
-      "org.scalatest" %% "scalatest" % "2.2.6"
-    ),
-    scalaVersion := "2.11.8",
+    libraryDependencies ++= List(scalaxml, scalatest),
     fork := true,
     testListeners += new TestReportListener {
       def testEvent(event: TestEvent): Unit = {
@@ -26,7 +26,7 @@ lazy val root = (project in file(".")).
       }
       def startGroup(name: String): Unit = ()
       def endGroup(name: String, t: Throwable): Unit = ()
-      def endGroup(name: String, result: TestResult.Value): Unit = ()
+      def endGroup(name: String, result: TestResult): Unit = ()
     },
     check := {
       val exists = marker.exists
diff --git a/sbt/src/sbt-test/tests/t543/test b/sbt/src/sbt-test/tests/t543/disabled
similarity index 100%
rename from sbt/src/sbt-test/tests/t543/test
rename to sbt/src/sbt-test/tests/t543/disabled
diff --git a/sbt/src/sbt-test/tests/t543/src/test/scala/Test.scala b/sbt/src/sbt-test/tests/t543/src/test/scala/Test.scala
index 84ea70f61..7cc7c481c 100644
--- a/sbt/src/sbt-test/tests/t543/src/test/scala/Test.scala
+++ b/sbt/src/sbt-test/tests/t543/src/test/scala/Test.scala
@@ -2,7 +2,7 @@ import org.scalatest.FunSuite
 
 class SBT543 extends FunSuite {
   class MyCustomException(message: String) extends RuntimeException(message)
-  test("throws a custom excpetion") {
+  test("throws a custom exception") {
     throw new MyCustomException("this is a custom exception")
   }
 }
diff --git a/sbt/src/sbt-test/tests/task/build.sbt b/sbt/src/sbt-test/tests/task/build.sbt
index c6097a06c..be394850b 100644
--- a/sbt/src/sbt-test/tests/task/build.sbt
+++ b/sbt/src/sbt-test/tests/task/build.sbt
@@ -1,5 +1,4 @@
-scalaVersion := "2.10.6"
-
-libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M6-SNAP28"
-
-testOptions in Test += Tests.Argument("-r", "custom.CustomReporter")
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+ThisBuild / scalaVersion := "2.12.12"
+libraryDependencies += scalatest
+Test / testOptions += Tests.Argument("-C", "custom.CustomReporter")
diff --git a/sbt/src/sbt-test/tests/test-cross/build.sbt b/sbt/src/sbt-test/tests/test-cross/build.sbt
new file mode 100644
index 000000000..cb9eb5f62
--- /dev/null
+++ b/sbt/src/sbt-test/tests/test-cross/build.sbt
@@ -0,0 +1,8 @@
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.6"
+
+lazy val root = (project in file("."))
+  .settings(
+    // Verifies that a different scala library version still works in test
+    scalaVersion := "2.11.12",
+    libraryDependencies += scalatest % Test
+  )
diff --git a/sbt/src/sbt-test/tests/test-cross/src/test/scala/Test.scala b/sbt/src/sbt-test/tests/test-cross/src/test/scala/Test.scala
new file mode 100644
index 000000000..8a6430745
--- /dev/null
+++ b/sbt/src/sbt-test/tests/test-cross/src/test/scala/Test.scala
@@ -0,0 +1,8 @@
+import java.io.File
+import org.scalatest.FlatSpec
+
+class Test extends FlatSpec {
+  "a test" should "pass" in {
+    assert(true)
+  }
+}
diff --git a/sbt/src/sbt-test/tests/test-cross/test b/sbt/src/sbt-test/tests/test-cross/test
new file mode 100644
index 000000000..dfffb838b
--- /dev/null
+++ b/sbt/src/sbt-test/tests/test-cross/test
@@ -0,0 +1 @@
+> test
diff --git a/sbt/src/sbt-test/tests/test-exclude/build.sbt b/sbt/src/sbt-test/tests/test-exclude/build.sbt
index 3d05c8130..9fd396d27 100644
--- a/sbt/src/sbt-test/tests/test-exclude/build.sbt
+++ b/sbt/src/sbt-test/tests/test-exclude/build.sbt
@@ -1,6 +1,8 @@
-lazy val root = (project in file(".")).
-  settings(
-    scalaVersion := "2.10.6",
-    libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1" % Test,
-    parallelExecution in test := false
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies += scalatest % Test,
+    Test / parallelExecution := false
   )
diff --git a/sbt/src/sbt-test/tests/test-exclude/src/test/scala/Test.scala b/sbt/src/sbt-test/tests/test-exclude/src/test/scala/Test.scala
index c7b0235e2..f23b47fba 100644
--- a/sbt/src/sbt-test/tests/test-exclude/src/test/scala/Test.scala
+++ b/sbt/src/sbt-test/tests/test-exclude/src/test/scala/Test.scala
@@ -1,14 +1,13 @@
 import java.io.File
 import org.scalatest.FlatSpec
-import org.scalatest.matchers.ShouldMatchers
 
-class Test1 extends FlatSpec with ShouldMatchers {
+class Test1 extends FlatSpec {
   "a test" should "pass" in {
     new File("target/Test1.run").createNewFile()
   }
 }
 
-class Test2 extends FlatSpec with ShouldMatchers {
+class Test2 extends FlatSpec {
   "a test" should "pass" in {
     new File("target/Test2.run").createNewFile()
   }
diff --git a/sbt/src/sbt-test/tests/test-quick/build.sbt b/sbt/src/sbt-test/tests/test-quick/build.sbt
index 8efb08911..0fb62b441 100644
--- a/sbt/src/sbt-test/tests/test-quick/build.sbt
+++ b/sbt/src/sbt-test/tests/test-quick/build.sbt
@@ -1,9 +1,9 @@
-lazy val root = (project in file(".")).
-  settings(
-    scalaVersion := "2.11.8",
-    libraryDependencies ++= List(
-      "org.scala-lang.modules" %% "scala-xml" % "1.0.1",
-      "org.scalatest" %% "scalatest" % "2.2.6"
-    ),
-    parallelExecution in test := false
+val scalatest = "org.scalatest" %% "scalatest" % "3.0.5"
+val scalaxml = "org.scala-lang.modules" %% "scala-xml" % "1.1.1"
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file("."))
+  .settings(
+    libraryDependencies ++= List(scalaxml, scalatest),
+    Test / parallelExecution := false
   )
diff --git a/sbt/src/sbt-test/tests/test-quick/test b/sbt/src/sbt-test/tests/test-quick/disabled
similarity index 100%
rename from sbt/src/sbt-test/tests/test-quick/test
rename to sbt/src/sbt-test/tests/test-quick/disabled
diff --git a/sbt/src/sbt-test/watch/alias/build.sbt b/sbt/src/sbt-test/watch/alias/build.sbt
new file mode 100644
index 000000000..f1d0d6c0a
--- /dev/null
+++ b/sbt/src/sbt-test/watch/alias/build.sbt
@@ -0,0 +1,6 @@
+val foo = taskKey[Unit]("foo")
+foo := println("foo")
+
+foo / watchOnIteration := { (_, _, _) => sbt.nio.Watch.CancelWatch }
+addCommandAlias("bar", "foo")
+addCommandAlias("baz", "foo")
diff --git a/sbt/src/sbt-test/watch/alias/test b/sbt/src/sbt-test/watch/alias/test
new file mode 100644
index 000000000..6781c97b8
--- /dev/null
+++ b/sbt/src/sbt-test/watch/alias/test
@@ -0,0 +1,3 @@
+> ~bar
+
+> ~baz
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/before-command/build.sbt b/sbt/src/sbt-test/watch/before-command/build.sbt
new file mode 100644
index 000000000..34d88a1f9
--- /dev/null
+++ b/sbt/src/sbt-test/watch/before-command/build.sbt
@@ -0,0 +1,5 @@
+import java.nio.file.{ Files, Paths }
+
+watchBeforeCommand := { () => Files.write(Paths.get("foo"), "foo".getBytes) }
+
+watchOnIteration := { (_, _, _) => sbt.nio.Watch.CancelWatch }
diff --git a/sbt/src/sbt-test/watch/before-command/test b/sbt/src/sbt-test/watch/before-command/test
new file mode 100644
index 000000000..5bfcff311
--- /dev/null
+++ b/sbt/src/sbt-test/watch/before-command/test
@@ -0,0 +1,3 @@
+> ~compile
+
+$ exists foo
diff --git a/sbt/src/sbt-test/watch/command-parser/build.sbt b/sbt/src/sbt-test/watch/command-parser/build.sbt
new file mode 100644
index 000000000..26befc01f
--- /dev/null
+++ b/sbt/src/sbt-test/watch/command-parser/build.sbt
@@ -0,0 +1,13 @@
+import Build._
+
+organization := "sbt"
+
+name := "scripted-watch-parser"
+
+setStringValue := setStringValueImpl.evaluated
+
+checkStringValue := checkStringValueImpl.evaluated
+
+setStringValue / watchTriggers := baseDirectory.value.toGlob / "string.txt" :: Nil
+
+watchOnFileInputEvent := { (_, _) => sbt.nio.Watch.CancelWatch }
diff --git a/sbt/src/sbt-test/watch/command-parser/project/Build.scala b/sbt/src/sbt-test/watch/command-parser/project/Build.scala
new file mode 100644
index 000000000..0650b3ad8
--- /dev/null
+++ b/sbt/src/sbt-test/watch/command-parser/project/Build.scala
@@ -0,0 +1,16 @@
+import sbt._
+
+import Keys.baseDirectory
+
+object Build {
+  val setStringValue = inputKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    IO.write(baseDirectory.value / stringFile, string)
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    assert(IO.read(baseDirectory.value / stringFile) == string)
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/command-parser/test b/sbt/src/sbt-test/watch/command-parser/test
new file mode 100644
index 000000000..55f3bff5f
--- /dev/null
+++ b/sbt/src/sbt-test/watch/command-parser/test
@@ -0,0 +1,24 @@
+> ~; setStringValue string.txt foo; setStringValue string.txt bar
+
+> checkStringValue string.txt bar
+
+> ~;setStringValue string.txt foo;setStringValue string.txt bar; checkStringValue string.txt bar
+
+> ~;   setStringValue string.txt foo;setStringValue string.txt bar; checkStringValue string.txt bar
+
+> ~; setStringValue string.txt foo; setStringValue string.txt bar; checkStringValue string.txt bar
+
+# no leading semicolon
+> ~ setStringValue string.txt foo; setStringValue string.txt bar; checkStringValue string.txt bar
+
+> ~ setStringValue string.txt foo
+
+> checkStringValue string.txt foo
+
+# All of the other tests have involved input tasks, so include commands with regular tasks as well.
+> ~; compile; setStringValue string.txt baz; checkStringValue string.txt baz
+# Ensure that trailing semi colons work
+> ~ compile; setStringValue string.txt baz; checkStringValue string.txt baz;
+
+# Ensure that no space is required between '~' and the command
+> ~compile;setStringValue string.txt foo;checkStringValue string.txt foo
diff --git a/sbt/src/sbt-test/watch/commands/build.sbt b/sbt/src/sbt-test/watch/commands/build.sbt
new file mode 100644
index 000000000..1ac4e953a
--- /dev/null
+++ b/sbt/src/sbt-test/watch/commands/build.sbt
@@ -0,0 +1,56 @@
+import java.nio.file.Files
+
+import scala.collection.JavaConverters._
+
+val foo = taskKey[Unit]("foo")
+foo := {
+  val fooTxt = baseDirectory.value / "foo.txt"
+  val _ = println(s"foo inputs: ${foo.inputFiles}")
+  IO.write(fooTxt, "foo")
+  println(s"foo wrote to $foo")
+}
+foo / fileInputs += baseDirectory.value.toGlob / "foo.txt"
+
+Global / watchTriggers += baseDirectory.value.toGlob / "bar.txt"
+
+commands ++= Seq(
+  Command.command("eval-foo") { s =>
+    Project.extract(s).runTask(foo, s)
+    s
+  },
+  Command.command("write-bar") { s =>
+    val bar = Project.extract(s).get(baseDirectory) / "bar.txt"
+    IO.write(bar, "bar")
+    println(s"write-bar wrote to $bar")
+    s
+  }
+)
+
+watchOnFileInputEvent := { (_, _) => sbt.nio.Watch.CancelWatch }
+
+/*
+ * This test ensures that when watching a cross build that commands are run for multiple scala
+ * versions. It also checks that the fileInputs are automatically detected during task evaluation
+ * even though we can't directly inspect the fileInputs of the cross ('+') command.
+ */
+val expectFailure = taskKey[Unit]("expect failure")
+expectFailure := {
+  val main = baseDirectory.value.toPath / "src" / "main"
+  val crossDir = main / (if (scalaVersion.value.startsWith("2.11")) "scala-2.11" else "scala-2.12")
+  (Compile / compile).result.value.toEither match {
+    case Left(_) =>
+      Files.write(crossDir / "Foo.scala", "class Foo".getBytes)
+      throw new IllegalStateException("Compilation failed.")
+    case Right(_) =>
+      if (!Files.walk(main).iterator.asScala.exists(_.getFileName.toString == "first.scala"))
+        Files.write(crossDir / "first.scala", "class first".getBytes)
+      else Files.write(crossDir / "second.scala", "class second".getBytes)
+  }
+}
+expectFailure / watchOnFileInputEvent := { (_, e) =>
+  if (e.path.getFileName.toString == "second.scala") sbt.nio.Watch.CancelWatch
+  else sbt.nio.Watch.Trigger
+}
+
+
+crossScalaVersions := Seq("2.11.12", "2.12.12")
diff --git a/sbt/src/sbt-test/watch/commands/src/main/scala-2.11/Foo.scala b/sbt/src/sbt-test/watch/commands/src/main/scala-2.11/Foo.scala
new file mode 100644
index 000000000..cc04bc468
--- /dev/null
+++ b/sbt/src/sbt-test/watch/commands/src/main/scala-2.11/Foo.scala
@@ -0,0 +1 @@
+class Foo {
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/commands/src/main/scala-2.12/Foo.scala b/sbt/src/sbt-test/watch/commands/src/main/scala-2.12/Foo.scala
new file mode 100644
index 000000000..cc04bc468
--- /dev/null
+++ b/sbt/src/sbt-test/watch/commands/src/main/scala-2.12/Foo.scala
@@ -0,0 +1 @@
+class Foo {
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/commands/src/main/scala/Bar.scala b/sbt/src/sbt-test/watch/commands/src/main/scala/Bar.scala
new file mode 100644
index 000000000..4a643c4dd
--- /dev/null
+++ b/sbt/src/sbt-test/watch/commands/src/main/scala/Bar.scala
@@ -0,0 +1 @@
+class Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/commands/test b/sbt/src/sbt-test/watch/commands/test
new file mode 100644
index 000000000..2eeb6d22c
--- /dev/null
+++ b/sbt/src/sbt-test/watch/commands/test
@@ -0,0 +1,6 @@
+> ~ eval-foo
+
+> ~ write-bar
+
+> set watchOnFileInputEvent := (expectFailure / watchOnFileInputEvent).value
+> ~ +expectFailure
diff --git a/sbt/src/sbt-test/watch/custom-config/build.sbt b/sbt/src/sbt-test/watch/custom-config/build.sbt
new file mode 100644
index 000000000..1c8d34f46
--- /dev/null
+++ b/sbt/src/sbt-test/watch/custom-config/build.sbt
@@ -0,0 +1,5 @@
+import sbt.input.aggregation.Build
+
+val root = Build.root
+val foo = Build.foo
+val bar = Build.bar
diff --git a/sbt/src/sbt-test/watch/custom-config/project/Build.scala b/sbt/src/sbt-test/watch/custom-config/project/Build.scala
new file mode 100644
index 000000000..7d88ac738
--- /dev/null
+++ b/sbt/src/sbt-test/watch/custom-config/project/Build.scala
@@ -0,0 +1,44 @@
+package sbt.input.aggregation
+
+import sbt._
+import Keys._
+import sbt.nio.Keys._
+import sbt.nio.Watch
+
+object Build {
+  val setStringValue = inputKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed.map(_.trim)
+    IO.write(file(stringFile), string)
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    assert(IO.read(file(stringFile)) == string)
+  }
+  lazy val foo = project.settings(
+    watchStartMessage := { (count: Int, _, _) => Some(s"FOO $count") },
+    Compile / compile / watchTriggers += baseDirectory.value.toGlob / "foo.txt",
+    Compile / compile / watchStartMessage := { (count: Int, _, _) =>
+      // this checks that Compile / compile / watchStartMessage
+      // is preferred to Compile / watchStartMessage
+      val outputFile = baseDirectory.value / "foo.txt"
+      IO.write(outputFile, "compile")
+      Some(s"compile $count")
+    },
+    Compile / watchStartMessage := { (count: Int, _, _) => Some(s"Compile $count") },
+    Runtime / watchStartMessage := { (count: Int, _, _) => Some(s"Runtime $count") },
+    setStringValue := {
+      val _ = (fileInputs in (bar, setStringValue)).value
+      setStringValueImpl.evaluated
+    },
+    checkStringValue := checkStringValueImpl.evaluated,
+    watchOnFileInputEvent := { (_, _) => Watch.CancelWatch }
+  )
+  lazy val bar = project.settings(
+    fileInputs in setStringValue += baseDirectory.value.toGlob / "foo.txt"
+  )
+  lazy val root = (project in file(".")).aggregate(foo, bar).settings(
+    watchOnFileInputEvent := { (_, _) => Watch.CancelWatch }
+  )
+}
diff --git a/sbt/src/sbt-test/watch/custom-config/test b/sbt/src/sbt-test/watch/custom-config/test
new file mode 100644
index 000000000..1b878cf44
--- /dev/null
+++ b/sbt/src/sbt-test/watch/custom-config/test
@@ -0,0 +1,7 @@
+> ~ foo/Runtime/setStringValue bar/foo.txt foo
+
+> checkStringValue bar/foo.txt foo
+
+> ~ foo/compile
+
+> checkStringValue foo/foo.txt compile
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/dynamic-inputs/build.sbt b/sbt/src/sbt-test/watch/dynamic-inputs/build.sbt
new file mode 100644
index 000000000..3e1169f6d
--- /dev/null
+++ b/sbt/src/sbt-test/watch/dynamic-inputs/build.sbt
@@ -0,0 +1,3 @@
+import sbt.watch.task.Build
+
+val root = Build.root
diff --git a/sbt/src/sbt-test/watch/dynamic-inputs/project/Build.scala b/sbt/src/sbt-test/watch/dynamic-inputs/project/Build.scala
new file mode 100644
index 000000000..d2e72376a
--- /dev/null
+++ b/sbt/src/sbt-test/watch/dynamic-inputs/project/Build.scala
@@ -0,0 +1,42 @@
+package sbt.watch.task
+
+import java.nio.file.Path
+import sbt._
+import Keys._
+import sbt.nio.Keys._
+import sbt.nio.Watch
+
+object Build {
+  val reloadFile = settingKey[File]("file to toggle whether or not to reload")
+  val setStringValue = taskKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  val foo = taskKey[Seq[Path]]("foo")
+  def setStringValueImpl: Def.Initialize[Task[Unit]] = Def.task {
+    val i = (setStringValue / fileInputs).value
+    val (stringFile, string) = ("foo.txt", "bar")
+    val absoluteFile = baseDirectory.value.toPath.resolve(stringFile).toFile
+    IO.write(absoluteFile, string)
+    println(s"wrote to $absoluteFile")
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    assert(IO.read(file(stringFile)) == string)
+  }
+  lazy val root = (project in file(".")).settings(
+    reloadFile := baseDirectory.value / "reload",
+    foo / fileInputs += baseDirectory.value.toGlob / "foo.txt",
+    foo := foo.inputFiles,
+    setStringValue := Def.taskDyn {
+      // This hides foo / fileInputs from the input graph
+      Def.taskDyn {
+        val inputs = foo.value
+        // By putting setStringValueImpl.value inside a Def.task, we ensure that
+        // (foo / fileInputs).value is registered with the file repository before modifying the file.
+        if (inputs.isEmpty) Def.task(setStringValueImpl.value)
+        else Def.task(assert(false))
+      }
+    }.value,
+    checkStringValue := checkStringValueImpl.evaluated,
+    watchOnFileInputEvent := { (_, _) => Watch.CancelWatch },
+  )
+}
diff --git a/sbt/src/sbt-test/watch/dynamic-inputs/test b/sbt/src/sbt-test/watch/dynamic-inputs/test
new file mode 100644
index 000000000..40acc0551
--- /dev/null
+++ b/sbt/src/sbt-test/watch/dynamic-inputs/test
@@ -0,0 +1,7 @@
+# This tests that we can override the state transformation in the watch task
+# In the build, watchOnEvent should return CancelWatch which should be successful, but we
+# override watchTasks to fail the state instead
+
+> ~ root / setStringValue
+
+> checkStringValue foo.txt bar
diff --git a/sbt/src/sbt-test/watch/file-input-aggregation/build.sbt b/sbt/src/sbt-test/watch/file-input-aggregation/build.sbt
new file mode 100644
index 000000000..6eda20341
--- /dev/null
+++ b/sbt/src/sbt-test/watch/file-input-aggregation/build.sbt
@@ -0,0 +1,7 @@
+import sbt.input.aggregation.Build
+
+val root = Build.root
+val foo = Build.foo
+val bar = Build.bar
+
+Global / watchTriggers += baseDirectory.value.toGlob / "baz.txt"
diff --git a/sbt/src/sbt-test/watch/file-input-aggregation/project/Build.scala b/sbt/src/sbt-test/watch/file-input-aggregation/project/Build.scala
new file mode 100644
index 000000000..32b999320
--- /dev/null
+++ b/sbt/src/sbt-test/watch/file-input-aggregation/project/Build.scala
@@ -0,0 +1,107 @@
+package sbt
+package input.aggregation
+
+import java.nio.file.Paths
+import sbt.Keys._
+import sbt.internal.DynamicInput
+import sbt.nio.Keys._
+
+/**
+ * This test is for internal logic so it must be in the sbt package because it uses package
+ * private apis.
+ */
+object Build {
+  val setStringValue = inputKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  val checkTriggers = taskKey[Unit]("Check that the triggers are correctly aggregated.")
+  val checkGlobs = taskKey[Unit](
+    "Check that the globs are correctly aggregated and that the globs are the union of the inputs and the triggers"
+  )
+  def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed.map(_.trim)
+    IO.write(file(stringFile), string)
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    assert(IO.read(file(stringFile)) == string)
+  }
+  def triggers(t: Seq[DynamicInput]): Seq[Glob] = t.collect {
+    // This is a hack to exclude the default compile and resource file inputs
+    case i if !i.glob.toString.contains("*") => i.glob
+  }
+
+  lazy val foo = project
+    .settings(
+      setStringValue := {
+        val _ = (fileInputs in (bar, setStringValue)).value
+        setStringValueImpl.evaluated
+      },
+      checkStringValue := checkStringValueImpl.evaluated,
+      watchOnFileInputEvent := { (_, _) =>
+        Watch.CancelWatch
+      },
+      Compile / compile / watchOnIteration := { (_, _, _) =>
+        Watch.CancelWatch
+      },
+      checkTriggers := {
+        val actual = triggers((Compile / compile / transitiveDynamicInputs).value).toSet
+        val base = baseDirectory.value.getParentFile.toGlob
+        // This checks that since foo depends on bar there is a transitive trigger generated
+        // for the "bar.txt" trigger added to bar / Compile / unmanagedResources (which is a
+        // transitive dependency of
+        val expected: Set[Glob] = Set(base / "baz.txt", base / "bar" / "bar.txt")
+        assert(actual == expected)
+      },
+      Test / test / watchTriggers += baseDirectory.value.toGlob / "test.txt",
+      Test / checkTriggers := {
+        val testTriggers = triggers((Test / test / transitiveDynamicInputs).value).toSet
+        // This validates that since the "test.txt" trigger is only added to the Test / test task,
+        // that the Test / compile does not pick it up. Both of them pick up the the triggers that
+        // are found in the test above for the compile configuration because of the transitive
+        // classpath dependency that is added in Defaults.internalDependencies.
+        val compileTriggers = triggers((Test / compile / transitiveDynamicInputs).value).toSet
+        val base = baseDirectory.value.getParentFile.toGlob
+        val expected: Set[Glob] =
+          Set(base / "baz.txt", base / "bar" / "bar.txt", base / "foo" / "test.txt")
+        assert(testTriggers == expected)
+        assert((testTriggers - (base / "foo" / "test.txt")) == compileTriggers)
+      },
+    )
+    .dependsOn(bar)
+
+  lazy val bar = project.settings(
+    fileInputs in setStringValue += baseDirectory.value.toGlob / "foo.txt",
+    setStringValue / watchTriggers += baseDirectory.value.toGlob / "bar.txt",
+    // This trigger should transitively propagate to foo / compile and foo / Test / compile
+    Compile / unmanagedResources / watchTriggers += baseDirectory.value.toGlob / "bar.txt",
+    checkTriggers := {
+      val base = baseDirectory.value.getParentFile.toGlob
+      val actual = triggers((Compile / compile / transitiveDynamicInputs).value).toSet
+      val expected: Set[Glob] = Set(base / "bar" / "bar.txt", base / "baz.txt")
+      assert(actual == expected)
+    },
+    // This trigger should not transitively propagate to any foo task
+    Test / unmanagedResources / watchTriggers += baseDirectory.value.toGlob / "bar-test.txt",
+    Test / checkTriggers := {
+      val testTriggers = triggers((Test / test / transitiveDynamicInputs).value).toSet
+      val compileTriggers = triggers((Test / compile / transitiveDynamicInputs).value).toSet
+      val base = baseDirectory.value.getParentFile.toGlob
+      val expected: Set[Glob] =
+        Set(base / "baz.txt", base / "bar" / "bar.txt", base / "bar" / "bar-test.txt")
+      assert(testTriggers == expected)
+      assert(testTriggers == compileTriggers)
+    },
+  )
+  lazy val root = (project in file("."))
+    .aggregate(foo, bar)
+    .settings(
+      watchOnFileInputEvent := { (_, _) =>
+        Watch.CancelWatch
+      },
+      checkTriggers := {
+        val actual = triggers((Compile / compile / transitiveDynamicInputs).value)
+        val expected: Seq[Glob] = baseDirectory.value.toGlob / "baz.txt" :: Nil
+        assert(actual == expected)
+      },
+    )
+}
diff --git a/sbt/src/sbt-test/watch/file-input-aggregation/test b/sbt/src/sbt-test/watch/file-input-aggregation/test
new file mode 100644
index 000000000..8746a23db
--- /dev/null
+++ b/sbt/src/sbt-test/watch/file-input-aggregation/test
@@ -0,0 +1,9 @@
+> checkTriggers
+
+> Test / checkTriggers
+
+# do not set the project here to ensure the bar/bar.txt trigger is captured by aggregation
+# also add random spaces and multiple commands to ensure the parser is sane.
+> ~ setStringValue bar/bar.txt bar; root /   setStringValue bar/bar.txt baz
+
+> checkStringValue bar/bar.txt baz
diff --git a/sbt/src/sbt-test/watch/input-parser/build.sbt b/sbt/src/sbt-test/watch/input-parser/build.sbt
new file mode 100644
index 000000000..755a02a0f
--- /dev/null
+++ b/sbt/src/sbt-test/watch/input-parser/build.sbt
@@ -0,0 +1,2 @@
+ThisBuild / useSuperShell := false
+val root = sbt.input.parser.Build.root
diff --git a/sbt/src/sbt-test/watch/input-parser/disabled b/sbt/src/sbt-test/watch/input-parser/disabled
new file mode 100644
index 000000000..8169581ba
--- /dev/null
+++ b/sbt/src/sbt-test/watch/input-parser/disabled
@@ -0,0 +1,17 @@
+# this should exit because watchStartMessage writes "\n" to Build.outputStream, which in turn
+# triggers a CancelWatch
+> ~ compile
+
+> set watchStartMessage := sbt.input.parser.Build.alternativeStartMessage
+
+> set watchInputParser := sbt.input.parser.Build.helloOrByeParser
+
+# this should exit because we write "xybyexyblahxyhelloxy" to Build.outputStream. The
+# helloOrByeParser will produce Watch.Ignore and Watch.CancelWatch but the
+# Watch.CancelWatch event should win.
+> ~ compile
+
+> set watchStartMessage := sbt.input.parser.Build.otherAlternativeStartMessage
+
+# this is the same as above except that hello appears before bye in the string
+> ~ compile
diff --git a/sbt/src/sbt-test/watch/input-parser/project/Build.scala b/sbt/src/sbt-test/watch/input-parser/project/Build.scala
new file mode 100644
index 000000000..903981e89
--- /dev/null
+++ b/sbt/src/sbt-test/watch/input-parser/project/Build.scala
@@ -0,0 +1,37 @@
+package sbt
+package input.parser
+
+import complete.Parser
+import complete.Parser._
+
+import java.io.{ PipedInputStream, PipedOutputStream }
+import Keys._
+import sbt.nio.Keys._
+
+object Build {
+  val root = (project in file(".")).settings(
+    watchInputStream := inputStream,
+    watchStartMessage := { (_, _, _) =>
+      Build.outputStream.write('\n'.toByte)
+      Build.outputStream.flush()
+      Some("default start message")
+    }
+  )
+  val outputStream = new PipedOutputStream()
+  val inputStream = new PipedInputStream(outputStream)
+  val byeParser: Parser[Watch.Action] = "bye" ^^^ Watch.CancelWatch
+  val helloParser: Parser[Watch.Action] = "hello" ^^^ Watch.Ignore
+  // Note that the order is byeParser | helloParser. In general, we want the higher priority
+  // action to come first because otherwise we would potentially scan past it.
+  val helloOrByeParser: Parser[Watch.Action] = byeParser | helloParser
+  val alternativeStartMessage: (Int, ProjectRef, Seq[String]) => Option[String] = { (_, _, _) =>
+    outputStream.write("xybyexyblahxyhelloxy".getBytes)
+    outputStream.flush()
+    Some("alternative start message")
+  }
+  val otherAlternativeStartMessage: (Int, ProjectRef, Seq[String]) => Option[String] = { (_, _, _) =>
+    outputStream.write("xyhellobyexyblahx".getBytes)
+    outputStream.flush()
+    Some("other alternative start message")
+  }
+}
diff --git a/sbt/src/sbt-test/watch/legacy-sources/build.sbt b/sbt/src/sbt-test/watch/legacy-sources/build.sbt
new file mode 100644
index 000000000..9c20c4496
--- /dev/null
+++ b/sbt/src/sbt-test/watch/legacy-sources/build.sbt
@@ -0,0 +1,21 @@
+Global / watchSources += new sbt.internal.io.Source(baseDirectory.value, "global.txt", NothingFilter, false)
+
+val setStringValue = inputKey[Unit]("set a global string to a value")
+val checkStringValue = inputKey[Unit]("check the value of a global")
+
+def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+  val Seq(stringFile, string) = Def.spaceDelimited().parsed.map(_.trim)
+  IO.write(file(stringFile), string)
+}
+def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+  val Seq(stringFile, string) = Def.spaceDelimited().parsed
+  assert(IO.read(file(stringFile)) == string)
+}
+
+watchSources in setStringValue += new sbt.internal.io.Source(baseDirectory.value, "foo.txt", NothingFilter, false)
+
+setStringValue := setStringValueImpl.evaluated
+
+checkStringValue := checkStringValueImpl.evaluated
+
+watchOnFileInputEvent := { (_, _) => Watch.CancelWatch }
diff --git a/sbt/src/sbt-test/watch/legacy-sources/test b/sbt/src/sbt-test/watch/legacy-sources/test
new file mode 100644
index 000000000..834087ccb
--- /dev/null
+++ b/sbt/src/sbt-test/watch/legacy-sources/test
@@ -0,0 +1,3 @@
+> ~ setStringValue foo.txt foo
+
+> checkStringValue foo.txt foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/managed/build.sbt b/sbt/src/sbt-test/watch/managed/build.sbt
new file mode 100644
index 000000000..42d425cfe
--- /dev/null
+++ b/sbt/src/sbt-test/watch/managed/build.sbt
@@ -0,0 +1,21 @@
+import java.nio.file.Files
+
+import scala.concurrent.duration._
+
+Compile / sourceGenerators += Def.task {
+  baseDirectory.value / "sources" / "Write.scala" :: Nil
+}.taskValue
+
+val runTest = taskKey[Unit]("run the test")
+runTest := Def.taskDyn {
+  val args = s" ${baseDirectory.value}"
+  (Runtime / run).toTask(args)
+}.value
+
+runTest / watchTriggers += baseDirectory.value.toGlob / "*.txt"
+watchAntiEntropy := 0.milliseconds
+watchOnFileInputEvent := { (count, e) =>
+  if (new String(Files.readAllBytes(e.path)) == "ok") Watch.CancelWatch
+  else if (count < 2) Watch.Trigger
+  else new Watch.HandleError(new IllegalStateException(s"Wrong event triggered the build: $e"))
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/managed/changes/Write.scala b/sbt/src/sbt-test/watch/managed/changes/Write.scala
new file mode 100644
index 000000000..2cbfcf767
--- /dev/null
+++ b/sbt/src/sbt-test/watch/managed/changes/Write.scala
@@ -0,0 +1,7 @@
+import java.nio.file._
+
+object Write {
+  def main(args: Array[String]): Unit = {
+    Files.write(Paths.get(args(0)).resolve("output.txt"), "ok".getBytes)
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/managed/sources/Write.scala b/sbt/src/sbt-test/watch/managed/sources/Write.scala
new file mode 100644
index 000000000..f899d0a5e
--- /dev/null
+++ b/sbt/src/sbt-test/watch/managed/sources/Write.scala
@@ -0,0 +1,12 @@
+import java.nio.file._
+object Write {
+  def main(args: Array[String]): Unit = {
+    val dir = Paths.get(args(0))
+    Files.write(
+      dir.resolve("sources").resolve("Write.scala"),
+      Files.readAllBytes(dir.resolve("changes").resolve("Write.scala")),
+    )
+    val output = dir.resolve("output.txt")
+    Files.write(output, "failure".getBytes)
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/managed/success.txt b/sbt/src/sbt-test/watch/managed/success.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/sbt/src/sbt-test/watch/managed/test b/sbt/src/sbt-test/watch/managed/test
new file mode 100644
index 000000000..b513556cb
--- /dev/null
+++ b/sbt/src/sbt-test/watch/managed/test
@@ -0,0 +1 @@
+> ~runTest
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/multi-error/build.sbt b/sbt/src/sbt-test/watch/multi-error/build.sbt
new file mode 100644
index 000000000..2e9cd6c3d
--- /dev/null
+++ b/sbt/src/sbt-test/watch/multi-error/build.sbt
@@ -0,0 +1,8 @@
+import java.nio.file._
+watchOnIteration := { (_, _, _) => Watch.CancelWatch }
+
+val copyFile = taskKey[Unit]("copy a file")
+copyFile := {
+  val base = baseDirectory.value.toPath
+  Files.copy(base / "changes" / "Foo.txt", base / "Foo.txt")
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/multi-error/changes/Foo.txt b/sbt/src/sbt-test/watch/multi-error/changes/Foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/watch/multi-error/changes/Foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/multi-error/src/main/scala/Foo.scala b/sbt/src/sbt-test/watch/multi-error/src/main/scala/Foo.scala
new file mode 100644
index 000000000..c4de1ce06
--- /dev/null
+++ b/sbt/src/sbt-test/watch/multi-error/src/main/scala/Foo.scala
@@ -0,0 +1 @@
+object Foo {
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/multi-error/test b/sbt/src/sbt-test/watch/multi-error/test
new file mode 100644
index 000000000..7088568c9
--- /dev/null
+++ b/sbt/src/sbt-test/watch/multi-error/test
@@ -0,0 +1,3 @@
+> ~compile; copyFile
+
+$ absent Foo.txt
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-change/build.sbt b/sbt/src/sbt-test/watch/on-change/build.sbt
new file mode 100644
index 000000000..542ca3643
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/build.sbt
@@ -0,0 +1,36 @@
+import java.nio.file._
+import java.nio.file.attribute.FileTime
+
+import scala.concurrent.duration._
+
+watchTriggeredMessage := { (i, path: Path, c) =>
+  val prev = watchTriggeredMessage.value
+  if (path.getFileName.toString == "C.scala")
+    throw new IllegalStateException("C.scala should not trigger")
+  prev(i, path, c)
+}
+
+watchOnIteration := { (i: Int, _, _) =>
+  val base = baseDirectory.value.toPath
+  val src =
+    base.resolve("src").resolve("main").resolve("scala").resolve("sbt").resolve("test")
+  val changes = base.resolve("changes")
+  def copy(fileName: String): Unit = {
+    val content =
+      new String(Files.readAllBytes(changes.resolve(fileName))) + "\n" + ("//" * i)
+    Files.write(src.resolve(fileName), content.getBytes)
+  }
+  val c = src.resolve("C.scala")
+  Files.setLastModifiedTime(c, FileTime.fromMillis(Files.getLastModifiedTime(c).toMillis + 1111))
+  if (i < 5) copy("A.scala")
+  else copy("B.scala")
+  println(s"Waiting for changes...")
+  Watch.Ignore
+}
+
+watchOnFileInputEvent := { (_, event: Watch.Event) =>
+  if (event.path.getFileName.toString == "B.scala") Watch.CancelWatch
+  else Watch.Trigger
+}
+
+watchAntiEntropy := 0.millis
diff --git a/sbt/src/sbt-test/watch/on-change/changes/A.scala b/sbt/src/sbt-test/watch/on-change/changes/A.scala
new file mode 100644
index 000000000..c0f3723e9
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/changes/A.scala
@@ -0,0 +1,3 @@
+package sbt.test
+
+class A
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-change/changes/B.scala b/sbt/src/sbt-test/watch/on-change/changes/B.scala
new file mode 100644
index 000000000..b09c653dd
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/changes/B.scala
@@ -0,0 +1,3 @@
+package sbt.test
+
+class B
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-change/changes/C.scala b/sbt/src/sbt-test/watch/on-change/changes/C.scala
new file mode 100644
index 000000000..c4f0b26b3
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/changes/C.scala
@@ -0,0 +1,3 @@
+package sbt.test
+
+class C
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/A.scala b/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/A.scala
new file mode 100644
index 000000000..8a803930e
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/A.scala
@@ -0,0 +1,3 @@
+package sbt.test
+
+class A {
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/B.scala b/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/B.scala
new file mode 100644
index 000000000..dc7d2140d
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/B.scala
@@ -0,0 +1,3 @@
+package sbt.test
+
+class B {
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/C.scala b/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/C.scala
new file mode 100644
index 000000000..c4f0b26b3
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/src/main/scala/sbt/test/C.scala
@@ -0,0 +1,3 @@
+package sbt.test
+
+class C
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-change/test b/sbt/src/sbt-test/watch/on-change/test
new file mode 100644
index 000000000..d2a71e6d9
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-change/test
@@ -0,0 +1,3 @@
+> ~compile
+
+> compile
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-start-watch/build.sbt b/sbt/src/sbt-test/watch/on-start-watch/build.sbt
new file mode 100644
index 000000000..808416d2a
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-start-watch/build.sbt
@@ -0,0 +1,26 @@
+val checkCount = inputKey[Unit]("check that compile has run a specified number of times")
+val failingTask = taskKey[Unit]("should always fail")
+val resetCount = taskKey[Unit]("reset compile count")
+
+checkCount := {
+  val expected = Def.spaceDelimited().parsed.head.toInt
+  if (Count.get != expected)
+    throw new IllegalStateException(s"Expected $expected compilation runs, got ${Count.get}")
+}
+
+resetCount := {
+  Count.reset()
+}
+
+failingTask := {
+  throw new IllegalStateException("failed")
+}
+
+watchOnIteration := { (count, project, commands) =>
+  val extra = baseDirectory.value / "extra.sbt"
+  IO.copyFile(baseDirectory.value / "changes" / "extra.sbt", extra, CopyOptions().withOverwrite(true))
+  Watch.defaultStartWatch(count, project, commands).foreach(_.linesIterator.foreach(l => println(s"[info] $l")))
+  Watch.Ignore
+}
+
+Global / onChangedBuildSource := ReloadOnSourceChanges
diff --git a/sbt/src/sbt-test/watch/on-start-watch/changes/extra.sbt b/sbt/src/sbt-test/watch/on-start-watch/changes/extra.sbt
new file mode 100644
index 000000000..85c2f3c85
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-start-watch/changes/extra.sbt
@@ -0,0 +1,12 @@
+val checkReloaded = taskKey[Unit]("Asserts that the build was reloaded")
+checkReloaded := { () }
+
+watchOnIteration := { (_, _, _) => sbt.nio.Watch.CancelWatch }
+
+Compile / compile := {
+  Count.increment()
+  // Trigger a new build by updating the last modified time
+  val file = (Compile / scalaSource).value / "A.scala"
+  IO.write(file, IO.read(file) + ("\n" * Count.get))
+  (Compile / compile).value
+}
diff --git a/sbt/src/sbt-test/watch/on-start-watch/extra.sbt b/sbt/src/sbt-test/watch/on-start-watch/extra.sbt
new file mode 100644
index 000000000..a419d1c94
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-start-watch/extra.sbt
@@ -0,0 +1,5 @@
+Compile / compile := {
+  Count.increment()
+  // Trigger a new build by updating the last modified time
+  (Compile / compile).value
+}
diff --git a/sbt/src/sbt-test/watch/on-start-watch/project/Count.scala b/sbt/src/sbt-test/watch/on-start-watch/project/Count.scala
new file mode 100644
index 000000000..67d3bf940
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-start-watch/project/Count.scala
@@ -0,0 +1,10 @@
+import sbt._
+import scala.util.Try
+
+object Count {
+  private var count = 0
+  def get: Int = count
+  def increment(): Unit = count += 1
+  def reset(): Unit = count = 0
+  def reloadCount(file: File): Int = Try(IO.read(file).toInt).getOrElse(0)
+}
diff --git a/sbt/src/sbt-test/watch/on-start-watch/src/main/scala/A.scala b/sbt/src/sbt-test/watch/on-start-watch/src/main/scala/A.scala
new file mode 100644
index 000000000..df9e4d3d5
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-start-watch/src/main/scala/A.scala
@@ -0,0 +1,3 @@
+package a
+
+class A
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/on-start-watch/test b/sbt/src/sbt-test/watch/on-start-watch/test
new file mode 100644
index 000000000..f796f7a13
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-start-watch/test
@@ -0,0 +1,21 @@
+> ~compile
+> checkReloaded
+
+# verify that the watch terminates when we reach the specified count
+> resetCount
+> set watchOnIteration := { (count: Int, _, _) => if (count == 2) sbt.nio.Watch.CancelWatch else sbt.nio.Watch.Ignore }
+> ~compile
+> checkCount 2
+
+# verify that the watch terminates and returns an error when we reach the specified count
+> resetCount
+> set watchOnIteration := { (count: Int, _, _) => if (count == 2) new sbt.nio.Watch.HandleError(new Exception("")) else sbt.nio.Watch.Ignore }
+# Returning Watch.HandleError causes the '~' command to fail
+-> ~compile
+> checkCount 2
+
+# verify that a re-build is triggered when we reach the specified count
+> resetCount
+> set watchOnIteration := { (count: Int, _, _) => if (count == 2) sbt.nio.Watch.Trigger else if (count == 3) sbt.nio.Watch.CancelWatch else sbt.nio.Watch.Ignore }
+> ~compile
+> checkCount 3
diff --git a/sbt/src/sbt-test/watch/on-termination/build.sbt b/sbt/src/sbt-test/watch/on-termination/build.sbt
new file mode 100644
index 000000000..3e1169f6d
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-termination/build.sbt
@@ -0,0 +1,3 @@
+import sbt.watch.task.Build
+
+val root = Build.root
diff --git a/sbt/src/sbt-test/watch/on-termination/project/Build.scala b/sbt/src/sbt-test/watch/on-termination/project/Build.scala
new file mode 100644
index 000000000..1b954a2b7
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-termination/project/Build.scala
@@ -0,0 +1,27 @@
+package sbt.watch.task
+
+import sbt._
+import Keys._
+import sbt.nio.Watch
+import sbt.nio.Keys._
+
+object Build {
+  val reloadFile = settingKey[File]("file to toggle whether or not to reload")
+  val setStringValue = inputKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed.map(_.trim)
+    IO.write(file(stringFile), string)
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    assert(IO.read(file(stringFile)) == string)
+  }
+  lazy val root = (project in file(".")).settings(
+    reloadFile := baseDirectory.value / "reload",
+    setStringValue / watchTriggers += baseDirectory.value.toGlob / "foo.txt",
+    setStringValue := setStringValueImpl.evaluated,
+    checkStringValue := checkStringValueImpl.evaluated,
+    watchOnFileInputEvent := { (_, _) => new Watch.HandleError(new IllegalStateException("")) },
+  )
+}
diff --git a/sbt/src/sbt-test/watch/on-termination/test b/sbt/src/sbt-test/watch/on-termination/test
new file mode 100644
index 000000000..32a8094d0
--- /dev/null
+++ b/sbt/src/sbt-test/watch/on-termination/test
@@ -0,0 +1,7 @@
+# This tests that we can override the state transformation in the watch task
+# In the build, watchOnEvent should return CancelWatch which should be successful, but we
+# override watchTasks to fail the state instead
+
+-> ~ root / setStringValue foo.txt bar
+
+> checkStringValue foo.txt bar
diff --git a/sbt/src/sbt-test/watch/overlapping/build.sbt b/sbt/src/sbt-test/watch/overlapping/build.sbt
new file mode 100644
index 000000000..c55168579
--- /dev/null
+++ b/sbt/src/sbt-test/watch/overlapping/build.sbt
@@ -0,0 +1,24 @@
+import java.nio.file.Files
+import java.nio.file.attribute.FileTime
+
+import scala.concurrent.duration._
+
+val foo = taskKey[Unit]("foo.txt")
+foo / watchForceTriggerOnAnyChange := true
+foo / fileInputs := baseDirectory.value.toGlob / "files" / "foo.txt" :: Nil
+foo / watchTriggers := baseDirectory.value.toGlob / ** / "foo.txt" :: Nil
+foo := {
+  foo.inputFiles.foreach { p =>
+    Files.setLastModifiedTime(p, FileTime.fromMillis(Files.getLastModifiedTime(p).toMillis + 3000))
+  }
+  sbt.nio.Stamps.check(foo).value
+}
+
+watchAntiEntropy := 0.seconds
+watchOnFileInputEvent := { (count, event: Watch.Event) =>
+  assert(event.path.getFileName.toString == "foo.txt")
+  if (new String(Files.readAllBytes(event.path)) == "foo") {
+    if (count < 3) Watch.Trigger
+    else Watch.CancelWatch
+  } else new Watch.HandleError(new IllegalStateException("Wrong stamp was set"))
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/overlapping/files/foo.txt b/sbt/src/sbt-test/watch/overlapping/files/foo.txt
new file mode 100644
index 000000000..191028156
--- /dev/null
+++ b/sbt/src/sbt-test/watch/overlapping/files/foo.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/overlapping/project/Stamps.scala b/sbt/src/sbt-test/watch/overlapping/project/Stamps.scala
new file mode 100644
index 000000000..b8389d791
--- /dev/null
+++ b/sbt/src/sbt-test/watch/overlapping/project/Stamps.scala
@@ -0,0 +1,16 @@
+package sbt
+package nio
+
+import java.nio.file._
+import sbt.nio.Keys._
+
+object Stamps {
+  def check(key: TaskKey[_]): Def.Initialize[Task[Unit]] = Def.task {
+    (key / inputFileStamps).value.map {
+      case (p, FileStamp.Hash(_)) =>
+      case (p, _) =>
+        Files.write(p, "fail".getBytes)
+        throw new IllegalStateException("Got incorrect stamp: $s")
+    }
+  }
+}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/overlapping/test b/sbt/src/sbt-test/watch/overlapping/test
new file mode 100644
index 000000000..e51dd3f49
--- /dev/null
+++ b/sbt/src/sbt-test/watch/overlapping/test
@@ -0,0 +1 @@
+> ~foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/symlinks/build.sbt b/sbt/src/sbt-test/watch/symlinks/build.sbt
new file mode 100644
index 000000000..09e1b7ad3
--- /dev/null
+++ b/sbt/src/sbt-test/watch/symlinks/build.sbt
@@ -0,0 +1,46 @@
+import java.nio.file.{ Files, Paths }
+import java.nio.file.StandardCopyOption.REPLACE_EXISTING
+
+val createSymlinks = taskKey[Unit]("create symlinks to source files and directories")
+createSymlinks := {
+  val base = baseDirectory.value.toPath
+  val srcDir = base / "src" / "main" / "scala"
+  val foo = Files.createDirectories(srcDir / "file-source") / "Foo.scala"
+  Files.createSymbolicLink(srcDir / "sources", Files.createDirectories(base / "sources"))
+  Files.deleteIfExists(foo)
+  Files.createSymbolicLink(foo, base / "file-source" / "Foo.scala")
+}
+
+ThisBuild / watchOnFileInputEvent := {
+  val srcDir = baseDirectory.value.toPath / "src" / "main" / "scala"
+  (_: Int, event: Watch.Event) =>
+    event.path match {
+      case p if p == (srcDir / "file-source" / "Foo.scala") => Watch.CancelWatch
+      case p if p == (srcDir / "sources" / "Bar.scala")     => Watch.CancelWatch
+      case _                                                => Watch.Ignore
+    }
+}
+
+val copySource = inputKey[Unit]("copy a source file from changes")
+copySource := {
+  val relative = Def.spaceDelimited("").parsed.head.split("/") match {
+    case Array(head)            => Paths.get(head)
+    case Array(head, tail @ _*) => tail.foldLeft(Paths.get(head))(_ / _)
+  }
+  val base = baseDirectory.value.toPath
+  Files.copy((base / "changes").resolve(relative), base.resolve(relative), REPLACE_EXISTING)
+}
+
+val removeLink = inputKey[Unit]("remove a symlink")
+removeLink := {
+  val relative = Def.spaceDelimited("").parsed.head.split("/") match {
+    case Array(head)            => Paths.get(head)
+    case Array(head, tail @ _*) => tail.foldLeft(Paths.get(head))(_ / _)
+  }
+  val srcDir = baseDirectory.value.toPath / "src" / "main" / "scala"
+  Files.deleteIfExists(srcDir.resolve(relative))
+}
+
+commands += Command.single("skipWindows") { (state, command) =>
+  if (scala.util.Properties.isWin) state else command :: state
+}
diff --git a/sbt/src/sbt-test/watch/symlinks/changes/file-source/Foo.scala b/sbt/src/sbt-test/watch/symlinks/changes/file-source/Foo.scala
new file mode 100644
index 000000000..f72abf33f
--- /dev/null
+++ b/sbt/src/sbt-test/watch/symlinks/changes/file-source/Foo.scala
@@ -0,0 +1 @@
+class Foo {}
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/symlinks/changes/sources/Bar.scala b/sbt/src/sbt-test/watch/symlinks/changes/sources/Bar.scala
new file mode 100644
index 000000000..f124ae515
--- /dev/null
+++ b/sbt/src/sbt-test/watch/symlinks/changes/sources/Bar.scala
@@ -0,0 +1,3 @@
+package sources
+
+class Bar
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/symlinks/disabled b/sbt/src/sbt-test/watch/symlinks/disabled
new file mode 100644
index 000000000..70ab7d943
--- /dev/null
+++ b/sbt/src/sbt-test/watch/symlinks/disabled
@@ -0,0 +1,15 @@
+> createSymlinks
+
+> skipWindows ~compile; copySource file-source/Foo.scala
+
+> ~compile; copySource sources/Bar.scala
+
+> skipWindows ~compile; removeLink file-source/Foo.scala
+
+> ~compile; removeLink sources
+
+> ~compile; createSymlinks
+
+> copySource sources/Bar.scala
+
+> ~compile; removeLink sources/Bar.scala
diff --git a/sbt/src/sbt-test/watch/symlinks/file-source/Foo.scala b/sbt/src/sbt-test/watch/symlinks/file-source/Foo.scala
new file mode 100644
index 000000000..43c42f145
--- /dev/null
+++ b/sbt/src/sbt-test/watch/symlinks/file-source/Foo.scala
@@ -0,0 +1 @@
+class Foo
\ No newline at end of file
diff --git a/sbt/src/sbt-test/watch/task/build.sbt b/sbt/src/sbt-test/watch/task/build.sbt
new file mode 100644
index 000000000..3e1169f6d
--- /dev/null
+++ b/sbt/src/sbt-test/watch/task/build.sbt
@@ -0,0 +1,3 @@
+import sbt.watch.task.Build
+
+val root = Build.root
diff --git a/sbt/src/sbt-test/watch/task/changes/Build.scala b/sbt/src/sbt-test/watch/task/changes/Build.scala
new file mode 100644
index 000000000..28a790802
--- /dev/null
+++ b/sbt/src/sbt-test/watch/task/changes/Build.scala
@@ -0,0 +1,29 @@
+package sbt.watch.task
+
+import sbt._
+import Keys._
+import sbt.nio.Keys._
+import sbt.nio.Watch
+
+object Build {
+  val setStringValue = inputKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed.map(_.trim)
+    IO.write(file(stringFile), string)
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    assert(IO.read(file(stringFile)) == string)
+  }
+  lazy val root = (project in file(".")).settings(
+    setStringValue / watchTriggers += baseDirectory.value.toGlob / "foo.txt",
+    setStringValue := setStringValueImpl.evaluated,
+    checkStringValue := checkStringValueImpl.evaluated,
+    watchStartMessage := { (_, _, _) =>
+      IO.touch(baseDirectory.value / "foo.txt", true)
+      Some("watching")
+    },
+    watchOnIteration := { (_, _, _) => Watch.CancelWatch }
+  )
+}
diff --git a/sbt/src/sbt-test/watch/task/disabled b/sbt/src/sbt-test/watch/task/disabled
new file mode 100644
index 000000000..93022959f
--- /dev/null
+++ b/sbt/src/sbt-test/watch/task/disabled
@@ -0,0 +1,12 @@
+# this tests that if the watch _task_ is able to reload the project
+
+# the original version of the build will only return Watch.Reload for trigger events  while the
+# updated version will return Watch.CancelWatch. If this test exits, it more or less works.
+$ copy-file changes/Build.scala project/Build.scala
+
+# setStringValue has foo.txt as a watch source so running that command should first trigger a
+# reload. After the project has been reloaded, the next write to setStringValue will also
+# trigger a CancelWatch event, hence we exit.
+> watch root / setStringValue foo.txt bar
+
+> checkStringValue foo.txt bar
diff --git a/sbt/src/sbt-test/watch/task/project/Build.scala b/sbt/src/sbt-test/watch/task/project/Build.scala
new file mode 100644
index 000000000..86ddc1258
--- /dev/null
+++ b/sbt/src/sbt-test/watch/task/project/Build.scala
@@ -0,0 +1,36 @@
+package sbt.watch.task
+
+import sbt._
+import Keys._
+import sbt.nio.Keys._
+import sbt.nio.Watch
+
+object Build {
+  val reloadFile = settingKey[File]("file to toggle whether or not to reload")
+  val setStringValue = inputKey[Unit]("set a global string to a value")
+  val checkStringValue = inputKey[Unit]("check the value of a global")
+  def setStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed.map(_.trim)
+    IO.write(file(stringFile), string)
+  }
+  def checkStringValueImpl: Def.Initialize[InputTask[Unit]] = Def.inputTask {
+    val Seq(stringFile, string) = Def.spaceDelimited().parsed
+    assert(IO.read(file(stringFile)) == string)
+  }
+  lazy val root = (project in file(".")).settings(
+    reloadFile := baseDirectory.value / "reload",
+    setStringValue / watchTriggers += baseDirectory.value.toGlob / "foo.txt",
+    setStringValue := setStringValueImpl.evaluated,
+    checkStringValue := checkStringValueImpl.evaluated,
+    watchStartMessage := { (_, _, _) =>
+      IO.touch(baseDirectory.value / "foo.txt", true)
+      Some("watching")
+    },
+    watchOnFileInputEvent := { (_, _) =>
+      if (reloadFile.value.exists) Watch.CancelWatch else {
+        IO.touch(reloadFile.value, true)
+        Watch.Reload
+      }
+    }
+  )
+}
diff --git a/sbt/src/test/scala/sbt/IllegalReferenceSpec.scala b/sbt/src/test/scala/sbt/IllegalReferenceSpec.scala
new file mode 100644
index 000000000..e94817b57
--- /dev/null
+++ b/sbt/src/test/scala/sbt/IllegalReferenceSpec.scala
@@ -0,0 +1,89 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import org.scalatest
+import org.scalatest.{ TestData, fixture }
+
+import scala.tools.reflect.{ FrontEnd, ToolBoxError }
+
+class IllegalReferenceSpec extends fixture.FunSuite with fixture.TestDataFixture {
+  private def toolboxClasspath(td: TestData): String =
+    td.configMap.get("sbt.server.classpath") match {
+      case Some(s: String) => s
+      case _               => throw new IllegalStateException("No classpath specified.")
+    }
+  def eval(code: String, compileOptions: String = ""): Any = {
+    val m = scala.reflect.runtime.currentMirror
+    import scala.tools.reflect.ToolBox
+    val tb = m.mkToolBox(options = compileOptions)
+    tb.eval(tb.parse(code))
+  }
+  private def expectError(
+      errorSnippet: String,
+      compileOptions: String = ""
+  )(code: String)(implicit td: TestData): scalatest.Assertion = {
+    val errorMessage = intercept[ToolBoxError] {
+      eval(code, s"$compileOptions -cp ${toolboxClasspath(td)}")
+      println(s"Test failed -- compilation was successful! Expected:\n$errorSnippet")
+    }.getMessage
+    val userMessage =
+      s"""
+         |FOUND: $errorMessage
+         |EXPECTED: $errorSnippet
+      """.stripMargin
+    assert(errorMessage.contains(errorSnippet), userMessage)
+  }
+  private class CachingToolbox(implicit td: TestData) {
+    private[this] val m = scala.reflect.runtime.currentMirror
+    private[this] var _infos: List[FrontEnd#Info] = Nil
+    private[this] val frontEnd = new FrontEnd {
+      override def display(info: Info): Unit = _infos ::= info
+      def interactive(): Unit = {}
+    }
+
+    import scala.tools.reflect.ToolBox
+    val toolbox = m.mkToolBox(frontEnd, options = s"-cp ${toolboxClasspath(td)}")
+    def eval(code: String): Any = toolbox.eval(toolbox.parse(code))
+    def infos: List[FrontEnd#Info] = _infos
+  }
+
+  test("Def.sequential should be legal within Def.taskDyn") { implicit td =>
+    val toolbox = new CachingToolbox
+    // This example was taken from @dos65 in https://github.com/sbt/sbt/issues/3110
+    val build =
+      s"""
+         |import sbt._
+         |import Keys._
+         |
+         |Def.taskDyn[Int] {
+         |  // Calling baseDirectory.value will cause the task macros to add a reference to
+         |  // `Def.toITask(sbt.Keys.baseDirectory)`. This, in turn, causes `Def` to be added
+         |  // to a list of local definitions. Later on, we dereference `Def` with
+         |  // `Def.sequential` which used to erroneously cause an illegal dynamic reference.
+         |  Def.unit(baseDirectory.value)
+         |  Def.sequential(Def.task(42))
+         |}.dependencies.headOption.map(_.key.label)
+       """.stripMargin
+    assert(toolbox.eval(build) == Some("baseDirectory"))
+    assert(toolbox.infos.isEmpty)
+  }
+  test("Local task defs should be illegal within Def.task") { implicit td =>
+    val build =
+      s"""
+         |import sbt._
+         |import Keys._
+         |
+         |Def.task[Int] {
+         |  def foo = Def.task(5)
+         |  foo.value
+         |}.dependencies.headOption.map(_.key.label)
+       """.stripMargin
+    expectError("Illegal dynamic reference: foo")(build)
+  }
+}
diff --git a/sbt/src/test/scala/sbt/RunFromSourceMain.scala b/sbt/src/test/scala/sbt/RunFromSourceMain.scala
new file mode 100644
index 000000000..ae6240a8b
--- /dev/null
+++ b/sbt/src/test/scala/sbt/RunFromSourceMain.scala
@@ -0,0 +1,174 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.io.File.pathSeparator
+
+import sbt.internal.scriptedtest.ScriptedLauncher
+import sbt.util.LoggerContext
+
+import scala.annotation.tailrec
+import scala.sys.process.Process
+import sbt.internal.SysProp
+
+object RunFromSourceMain {
+  def fork(
+      workingDirectory: File,
+      scalaVersion: String,
+      sbtVersion: String,
+      classpath: Seq[File]
+  ): Process = {
+    val fo = ForkOptions()
+      .withOutputStrategy(OutputStrategy.StdoutOutput)
+    fork(fo, workingDirectory, scalaVersion, sbtVersion, classpath)
+  }
+
+  def fork(
+      fo0: ForkOptions,
+      workingDirectory: File,
+      scalaVersion: String,
+      sbtVersion: String,
+      cp: Seq[File]
+  ): Process = {
+    val fo = fo0
+      .withWorkingDirectory(workingDirectory)
+      .withRunJVMOptions((sys.props.get("sbt.ivy.home") match {
+        case Some(home) => Vector(s"-Dsbt.ivy.home=$home")
+        case _          => Vector()
+      }) ++ fo0.runJVMOptions)
+    implicit val runner = new ForkRun(fo)
+    val options =
+      Vector(workingDirectory.toString, scalaVersion, sbtVersion, cp.mkString(pathSeparator))
+    val context = LoggerContext(useLog4J = SysProp.useLog4J)
+    val log = context.logger("RunFromSourceMain.fork", None, None)
+    try runner.fork("sbt.RunFromSourceMain", cp, options, log)
+    finally context.close()
+  }
+
+  def main(args: Array[String]): Unit = args match {
+    case Array() =>
+      sys.error(
+        s"Must specify working directory, scala version and sbt version and classpath as the first three arguments"
+      )
+    case Array(wd, scalaVersion, sbtVersion, classpath, args @ _*) =>
+      System.setProperty("jna.nosys", "true")
+      if (args.exists(_.startsWith("<"))) System.setProperty("sbt.io.virtual", "false")
+      val context = LoggerContext(useLog4J = SysProp.useLog4J)
+      try run(file(wd), scalaVersion, sbtVersion, classpath, args, context)
+      finally context.close()
+  }
+
+  // this arrangement is because Scala does not always properly optimize away
+  // the tail recursion in a catch statement
+  @tailrec private[sbt] def run(
+      baseDir: File,
+      scalaVersion: String,
+      sbtVersion: String,
+      classpath: String,
+      args: Seq[String],
+      context: LoggerContext
+  ): Unit =
+    runImpl(baseDir, scalaVersion, sbtVersion, classpath, args, context: LoggerContext) match {
+      case Some((baseDir, args)) => run(baseDir, scalaVersion, sbtVersion, classpath, args, context)
+      case None                  => ()
+    }
+
+  private def runImpl(
+      baseDir: File,
+      scalaVersion: String,
+      sbtVersion: String,
+      classpath: String,
+      args: Seq[String],
+      context: LoggerContext,
+  ): Option[(File, Seq[String])] = {
+    try launch(defaultBootDirectory, baseDir, scalaVersion, sbtVersion, classpath, args, context) map exit
+    catch {
+      case r: xsbti.FullReload => Some((baseDir, r.arguments()))
+      case scala.util.control.NonFatal(e) =>
+        e.printStackTrace(); errorAndExit(e.toString)
+    }
+  }
+
+  private def launch(
+      bootDirectory: File,
+      baseDirectory: File,
+      scalaVersion: String,
+      sbtVersion: String,
+      classpath: String,
+      arguments: Seq[String],
+      context: LoggerContext,
+  ): Option[Int] = {
+    ScriptedLauncher
+      .launch(
+        scalaHome(bootDirectory, scalaVersion, context),
+        sbtVersion,
+        scalaVersion,
+        bootDirectory,
+        baseDirectory,
+        classpath.split(java.io.File.pathSeparator).map(file),
+        arguments.toArray
+      )
+      .orElse(null) match {
+      case null                   => None
+      case i if i == Int.MaxValue => None
+      case i                      => Some(i)
+    }
+  }
+
+  private lazy val defaultBootDirectory: File =
+    file(sys.props("user.home")) / ".sbt" / "scripted" / "boot"
+  private def scalaHome(bootDirectory: File, scalaVersion: String, context: LoggerContext): File = {
+    val log = context.logger("run-from-source", None, None)
+    val scalaHome0 = bootDirectory / s"scala-$scalaVersion"
+    if ((scalaHome0 / "lib" / "scala-library.jar").exists) scalaHome0
+    else {
+      log.info(s"""scalaHome ($scalaHome0) wasn't found""")
+      val fakeboot = bootDirectory / "fakeboot"
+      val scalaHome1 = fakeboot / s"scala-$scalaVersion"
+      val scalaHome1Lib = scalaHome1 / "lib"
+      val scalaHome1Temp = scalaHome1 / "temp"
+      if (scalaHome1Lib.exists) log.info(s"""using $scalaHome1 that was found""")
+      else {
+        log.info(s"""creating $scalaHome1 by downloading scala-compiler $scalaVersion""")
+        IO.createDirectories(List(scalaHome1Lib, scalaHome1Temp))
+        val lm = {
+          import sbt.librarymanagement.ivy.IvyDependencyResolution
+          val ivyConfig = InlineIvyConfiguration().withLog(log)
+          IvyDependencyResolution(
+            ivyConfig.withResolvers(
+              ivyConfig.resolvers ++ Seq(
+                "scala-ea" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
+                "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-pr-validation-snapshots/",
+              )
+            )
+          )
+        }
+        val Name = """(.*)(?:\-[\d.]+)\.jar""".r
+        val BinPre = """(.*)(?:\-[\d.]+)-(?:bin|pre)-.*\.jar""".r
+        val module = "org.scala-lang" % "scala-compiler" % scalaVersion
+        lm.retrieve(module, scalaModuleInfo = None, scalaHome1Temp, log) match {
+          case Left(w) => throw w.resolveException
+          case Right(_) =>
+            val jars = (scalaHome1Temp ** "*.jar").get
+            assert(jars.nonEmpty, s"no jars for scala $scalaVersion")
+            jars.foreach { f =>
+              val name = f.getName match {
+                case Name(name)   => name
+                case BinPre(name) => name
+              }
+              IO.copyFile(f, scalaHome1Lib / s"$name.jar")
+            }
+        }
+      }
+      scalaHome1
+    }
+  }
+
+  private def errorAndExit(msg: String): Nothing = { System.err.println(msg); exit(1) }
+  private def exit(code: Int): Nothing = System.exit(code).asInstanceOf[Nothing]
+}
diff --git a/sbt/src/test/scala/sbt/internal/scriptedtest/ScriptedLauncher.java b/sbt/src/test/scala/sbt/internal/scriptedtest/ScriptedLauncher.java
new file mode 100644
index 000000000..a2710c66d
--- /dev/null
+++ b/sbt/src/test/scala/sbt/internal/scriptedtest/ScriptedLauncher.java
@@ -0,0 +1,578 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.scriptedtest;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.FileVisitor;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Optional;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
+import xsbti.AppConfiguration;
+import xsbti.AppMain;
+import xsbti.AppProvider;
+import xsbti.ApplicationID;
+import xsbti.ComponentProvider;
+import xsbti.CrossValue;
+import xsbti.GlobalLock;
+import xsbti.Launcher;
+import xsbti.MavenRepository;
+import xsbti.Predefined;
+import xsbti.PredefinedRepository;
+import xsbti.Repository;
+import xsbti.ScalaProvider;
+
+public class ScriptedLauncher {
+  private static URL URLForClass(final Class<?> clazz)
+      throws MalformedURLException, ClassNotFoundException {
+    final String path = clazz.getCanonicalName().replace('.', '/') + ".class";
+    final URL url = clazz.getClassLoader().getResource(path);
+    if (url == null) throw new ClassNotFoundException(clazz.getCanonicalName());
+    return new URL(url.toString().replaceAll(path + "$", ""));
+  }
+
+  public static Optional<Integer> launch(
+      final File scalaHome,
+      final String sbtVersion,
+      final String scalaVersion,
+      final File bootDirectory,
+      final File baseDir,
+      final File[] classpath,
+      String[] arguments)
+      throws InvocationTargetException, ClassNotFoundException, NoSuchMethodException,
+          IllegalAccessException, IOException {
+    String[] args = arguments;
+    Object appID = null;
+    if (System.getProperty("sbt.launch.jar") == null) {
+      final ClassLoader previous = Thread.currentThread().getContextClassLoader();
+      final URL configURL = URLForClass(xsbti.AppConfiguration.class);
+      final URL mainURL = URLForClass(sbt.xMain.class);
+      final URL scriptedURL = URLForClass(ScriptedLauncher.class);
+      final ClassLoader topLoader = new URLClassLoader(new URL[] {configURL}, top());
+      final URLClassLoader loader = new URLClassLoader(new URL[] {mainURL, scriptedURL}, topLoader);
+      try {
+        while (true) {
+          final Class<?> clazz = loader.loadClass("sbt.internal.scriptedtest.ScriptedLauncher");
+          final Class<?> reboot = loader.loadClass("xsbti.Reboot");
+          final Class<?> exit = loader.loadClass("xsbti.Exit");
+
+          Method method =
+              clazz.getDeclaredMethod(
+                  "getConf",
+                  ClassLoader.class,
+                  File.class,
+                  String.class,
+                  String.class,
+                  File.class,
+                  File.class,
+                  File[].class,
+                  String[].class,
+                  loader.loadClass("xsbti.ApplicationID"));
+          Thread.currentThread().setContextClassLoader(loader);
+          try {
+            final Object conf =
+                method.invoke(
+                    null,
+                    topLoader,
+                    scalaHome,
+                    sbtVersion,
+                    scalaVersion,
+                    bootDirectory,
+                    baseDir,
+                    classpath,
+                    args,
+                    appID);
+            final Object launchResult =
+                clazz
+                    .getDeclaredMethod(
+                        "launchImpl", ClassLoader.class, ClassLoader.class, Object.class)
+                    .invoke(null, topLoader, loader, conf);
+            if (reboot.isAssignableFrom(launchResult.getClass())) {
+              final Object a = reboot.getDeclaredMethod("arguments").invoke(launchResult);
+              final int length = Array.getLength(a);
+              args = new String[length];
+              for (int j = 0; j < length; ++j) {
+                args[j] = (String) Array.get(a, j);
+              }
+              appID = reboot.getDeclaredMethod("app").invoke(launchResult);
+            } else if (exit.isAssignableFrom(launchResult.getClass())) {
+              return Optional.of((Integer) exit.getDeclaredMethod("code").invoke(launchResult));
+            }
+          } catch (final InvocationTargetException e) {
+            Throwable t = e.getCause();
+            while (t != null && !t.getClass().getCanonicalName().equals("xsbti.FullReload"))
+              t = t.getCause();
+            final RuntimeException reload = t == null ? null : (RuntimeException) t;
+            if (reload != null) {
+              final boolean clean =
+                  (boolean) reload.getClass().getDeclaredMethod("clean").invoke(reload);
+              if (clean) deleteRecursive(bootDirectory);
+              final Object reloadArgs =
+                  reload.getClass().getDeclaredMethod("arguments").invoke(reload);
+              throw new xsbti.FullReload((String[]) reloadArgs, true);
+            }
+            if (e.getCause() instanceof RuntimeException) throw (RuntimeException) e.getCause();
+            throw new RuntimeException(e.getCause());
+          }
+        }
+      } finally {
+        swap(loader, previous);
+      }
+    } else {
+      final URL url = new URL("file:" + System.getProperty("sbt.launch.jar"));
+      final URLClassLoader loader = new URLClassLoader(new URL[] {url}, top());
+      final Class<?> boot = loader.loadClass("xsbt.boot.Boot");
+      // If we don't initialize the arguments this way, then the call to invoke on
+      // xsbt.boot.Boot.main fails with an IllegalArgumentException
+      final Object newArgs = Array.newInstance(loader.loadClass("java.lang.String"), args.length);
+      for (int i = 0; i < args.length; ++i) ((String[]) newArgs)[i] = args[i];
+      final ClassLoader previous = Thread.currentThread().getContextClassLoader();
+
+      try {
+        Thread.currentThread().setContextClassLoader(loader);
+        boot.getDeclaredMethod("main", newArgs.getClass()).invoke(null, newArgs);
+        return Optional.empty();
+      } finally {
+        swap(loader, previous);
+      }
+    }
+  }
+
+  private static ClassLoader top() {
+    ClassLoader result = ClassLoader.getSystemClassLoader();
+    while (result.getParent() != null) result = result.getParent();
+    return result;
+  }
+
+  private static void swap(final URLClassLoader old, final ClassLoader stashed) {
+    try {
+      old.close();
+    } catch (final Exception e) {
+    }
+    Thread.currentThread().setContextClassLoader(stashed);
+  }
+
+  private static boolean copy(final File[] files, final File toDirectory) throws IOException {
+    boolean result = true;
+    for (final File file : files) {
+      try {
+        Files.createDirectories(toDirectory.toPath());
+        Files.copy(file.toPath(), toDirectory.toPath().resolve(file.getName()));
+      } catch (final FileAlreadyExistsException e) {
+        result = false;
+      }
+    }
+    return result;
+  }
+
+  @SuppressWarnings("unused")
+  public static Object launchImpl(
+      final ClassLoader topLoader, final ClassLoader loader, final Object conf)
+      throws ClassNotFoundException, InvocationTargetException, IllegalAccessException,
+          NoSuchMethodException, InstantiationException {
+    final Class<?> clazz = loader.loadClass("sbt.xMain");
+    final Object instance = clazz.getConstructor().newInstance();
+    final Method run = clazz.getDeclaredMethod("run", loader.loadClass("xsbti.AppConfiguration"));
+    return run.invoke(instance, conf);
+  }
+
+  @SuppressWarnings("unused")
+  public static AppConfiguration getConf(
+      final ClassLoader topLoader,
+      final File scalaHome,
+      final String sbtVersion,
+      final String scalaVersion,
+      final File bootDirectory,
+      final File baseDir,
+      final File[] classpath,
+      String[] args,
+      final ApplicationID appID) {
+
+    final File libDir = new File(scalaHome, "lib");
+    final AtomicReference<File[]> classpathExtra = new AtomicReference<>(new File[0]);
+    final ApplicationID id =
+        appID != null
+            ? appID
+            : new ApplicationID() {
+              @Override
+              public String groupID() {
+                return "org.scala-sbt";
+              }
+
+              @Override
+              public String name() {
+                return "sbt";
+              }
+
+              @Override
+              public String version() {
+                return sbtVersion;
+              }
+
+              @Override
+              public String mainClass() {
+                return "sbt.xMain";
+              }
+
+              @Override
+              public String[] mainComponents() {
+                return new String[] {"xsbti", "extra"};
+              }
+
+              @Deprecated
+              @Override
+              public boolean crossVersioned() {
+                return false;
+              }
+
+              @Override
+              public CrossValue crossVersionedValue() {
+                return CrossValue.Disabled;
+              }
+
+              @Override
+              public File[] classpathExtra() {
+                return classpathExtra.get();
+              }
+            };
+    final File appHome =
+        scalaHome.toPath().resolve(id.groupID()).resolve(id.name()).resolve(id.version()).toFile();
+    final ComponentProvider provider =
+        new ComponentProvider() {
+          @Override
+          public File componentLocation(String id) {
+            return new File(appHome, id);
+          }
+
+          @Override
+          public File[] component(String componentID) {
+            final File dir = componentLocation(componentID);
+            final File[] files = dir.listFiles(File::isFile);
+            return files == null ? new File[0] : files;
+          }
+
+          @Override
+          public void defineComponent(String componentID, File[] components) {
+            final File dir = componentLocation(componentID);
+            if (dir.exists()) {
+              final StringBuilder files = new StringBuilder();
+              for (final File file : components) {
+                if (files.length() > 0) {
+                  files.append(',');
+                }
+                files.append(file.toString());
+              }
+              throw new RuntimeException(
+                  "Cannot redefine component. ID: " + id + ", files: " + files);
+            } else {
+              try {
+                copy(components, dir);
+              } catch (final IOException e) {
+                e.printStackTrace(System.err);
+              }
+            }
+          }
+
+          @Override
+          public boolean addToComponent(String componentID, File[] components) {
+            try {
+              boolean result = copy(components, componentLocation(componentID));
+              final File[] extra = componentLocation(componentID).listFiles();
+              classpathExtra.set(extra == null ? new File[0] : extra);
+              return result;
+            } catch (final IOException e) {
+              return true;
+            }
+          }
+
+          @Override
+          public File lockFile() {
+            return new File(appHome, "sbt.components.lock");
+          }
+        };
+    assert (libDir.exists());
+    final File[] jars = libDir.listFiles(f -> f.isFile() && f.getName().endsWith(".jar"));
+    final URL[] urls = new URL[jars.length];
+    for (int i = 0; i < jars.length; ++i) {
+      try {
+        urls[i] = jars[i].toURI().toURL();
+      } catch (final IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+    return new AppConfiguration() {
+      @Override
+      public String[] arguments() {
+        return args;
+      }
+
+      @Override
+      public File baseDirectory() {
+        return baseDir;
+      }
+
+      @Override
+      public AppProvider provider() {
+        return new AppProvider() {
+          final AppProvider self = this;
+          final ScalaProvider scalaProvider =
+              new ScalaProvider() {
+                private final ScalaProvider sp = this;
+                private final String scalaOrg = "org.scala-lang";
+                private final Repository[] repos =
+                    new Repository[] {
+                      (PredefinedRepository) () -> Predefined.Local,
+                      (PredefinedRepository) () -> Predefined.MavenCentral,
+                      newMavenRepo(
+                          "scala-ea",
+                          "https://scala-ci.typesafe.com/artifactory/scala-integration/"),
+                      newMavenRepo(
+                          "scala-pr",
+                          "https://scala-ci.typesafe.com/artifactory/scala-pr-validation-snapshots/")
+                    };
+                private final Launcher launcher =
+                    new Launcher() {
+                      @Override
+                      public ScalaProvider getScala(String version) {
+                        return getScala(version, "");
+                      }
+
+                      @Override
+                      public ScalaProvider getScala(String version, String reason) {
+                        return getScala(version, reason, scalaOrg);
+                      }
+
+                      @Override
+                      public ScalaProvider getScala(
+                          String version, String reason, String scalaOrg) {
+                        return sp;
+                      }
+
+                      @Override
+                      public AppProvider app(ApplicationID id, String version) {
+                        return self;
+                      }
+
+                      @Override
+                      public ClassLoader topLoader() {
+                        return topLoader;
+                      }
+
+                      class foo extends Throwable {
+                        foo(final Exception e) {
+                          super(e.getMessage(), null, true, false);
+                        }
+                      }
+
+                      @Override
+                      public GlobalLock globalLock() {
+                        return new GlobalLock() {
+                          @Override
+                          public <T> T apply(File lockFile, Callable<T> run) {
+                            try {
+                              return run.call();
+                            } catch (final Exception e) {
+                              throw new RuntimeException(new foo(e)) {
+                                @Override
+                                public StackTraceElement[] getStackTrace() {
+                                  return new StackTraceElement[0];
+                                }
+                              };
+                            }
+                          }
+                        };
+                      }
+
+                      @Override
+                      public File bootDirectory() {
+                        return bootDirectory;
+                      }
+
+                      @Override
+                      public Repository[] ivyRepositories() {
+                        return repos;
+                      }
+
+                      @Override
+                      public Repository[] appRepositories() {
+                        return repos;
+                      }
+
+                      @Override
+                      public boolean isOverrideRepositories() {
+                        return false;
+                      }
+
+                      @Override
+                      public File ivyHome() {
+                        final String home = System.getProperty("sbt.ivy.home");
+                        return home == null
+                            ? new File(System.getProperty("user.home"), ".ivy2")
+                            : new File(home);
+                      }
+
+                      @Override
+                      public String[] checksums() {
+                        return new String[] {"sha1", "md5"};
+                      }
+                    };
+
+                @Override
+                public Launcher launcher() {
+                  return launcher;
+                }
+
+                @Override
+                public String version() {
+                  return scalaVersion;
+                }
+
+                @Override
+                public ClassLoader loader() {
+                  return new URLClassLoader(urls, topLoader);
+                }
+
+                @Override
+                public File[] jars() {
+                  return jars;
+                }
+
+                @Deprecated
+                @Override
+                public File libraryJar() {
+                  return new File(libDir, "scala-library.jar");
+                }
+
+                @Deprecated
+                @Override
+                public File compilerJar() {
+                  return new File(libDir, "scala-compiler.jar");
+                }
+
+                @Override
+                public AppProvider app(ApplicationID id) {
+                  return self;
+                }
+              };
+
+          @Override
+          public ScalaProvider scalaProvider() {
+            return scalaProvider;
+          }
+
+          @Override
+          public ApplicationID id() {
+            return id;
+          }
+
+          @Override
+          public ClassLoader loader() {
+            return new URLClassLoader(urls, topLoader);
+          }
+
+          @Deprecated
+          @Override
+          public Class<? extends AppMain> mainClass() {
+            return AppMain.class;
+          }
+
+          @Override
+          public Class<?> entryPoint() {
+            return AppMain.class;
+          }
+
+          @Override
+          public AppMain newMain() {
+            try {
+              return (AppMain) loader().loadClass("sbt.xMain").getConstructor().newInstance();
+            } catch (final Exception e) {
+              throw new RuntimeException(e);
+            }
+          }
+
+          @Override
+          public File[] mainClasspath() {
+            return classpath;
+          }
+
+          @Override
+          public ComponentProvider components() {
+            return provider;
+          }
+        };
+      }
+    };
+  }
+
+  private static void deleteRecursive(final File directory) {
+    try {
+      Files.walkFileTree(
+          directory.toPath(),
+          new FileVisitor<Path>() {
+            @Override
+            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+                throws IOException {
+              if (attrs.isRegularFile()) Files.deleteIfExists(file);
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult visitFileFailed(Path file, IOException exc) {
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult postVisitDirectory(Path dir, IOException exc)
+                throws IOException {
+              Files.deleteIfExists(dir);
+              return FileVisitResult.CONTINUE;
+            }
+          });
+    } catch (final IOException e) {
+    }
+  }
+
+  private static MavenRepository newMavenRepo(final String id, final String url) {
+    return new MavenRepository() {
+      @Override
+      public String id() {
+        return id;
+      }
+
+      @Override
+      public boolean allowInsecureProtocol() {
+        return false;
+      }
+
+      @Override
+      public URL url() {
+        try {
+          return new URL(url);
+        } catch (MalformedURLException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    };
+  }
+}
diff --git a/scripted-plugin/src/main/scala/sbt/ScriptedPlugin.scala b/scripted-plugin/src/main/scala/sbt/ScriptedPlugin.scala
new file mode 100644
index 000000000..e00e0ef31
--- /dev/null
+++ b/scripted-plugin/src/main/scala/sbt/ScriptedPlugin.scala
@@ -0,0 +1,11 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+// ScriptedPlugin has moved to main.
+private[sbt] object ScriptedPluginNote
diff --git a/scripted-sbt-old/src/main/scala/sbt/test/OldScriptedTests.scala b/scripted-sbt-old/src/main/scala/sbt/test/OldScriptedTests.scala
new file mode 100644
index 000000000..2497a27fe
--- /dev/null
+++ b/scripted-sbt-old/src/main/scala/sbt/test/OldScriptedTests.scala
@@ -0,0 +1,32 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.test
+
+import java.io.File
+
+/**
+ * This is a bincompat place holder sbt.test package that we are now trying to hide
+ * because of the name conflict with Keys.test.
+ */
+@deprecated("Use sbt.scriptedtest.ScriptedRunner.", "1.2.0")
+private[sbt] class ScriptedRunner extends sbt.scriptedtest.ScriptedRunner
+
+/**
+ * This is a bincompat place holder for sbt.test package that we are now trying to hide
+ * because of the name conflict with Keys.test.
+ */
+@deprecated("Use sbt.scriptedtest.ScriptedTests.", "1.2.0")
+private[sbt] object ScriptedTests extends ScriptedRunner {
+
+  /** Represents the function that runs the scripted tests, both in single or batch mode. */
+  type TestRunner = () => Seq[Option[String]]
+
+  val emptyCallback: File => Unit = _ => ()
+  def main(args: Array[String]): Unit =
+    sbt.scriptedtest.ScriptedTests.main(args)
+}
diff --git a/scripted-sbt-redux/NOTICE b/scripted-sbt-redux/NOTICE
new file mode 100644
index 000000000..89cb6a81c
--- /dev/null
+++ b/scripted-sbt-redux/NOTICE
@@ -0,0 +1,4 @@
+sbt: Scripted Testing
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under BSD-3-Clause license (see LICENSE)
diff --git a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/BatchScriptRunner.scala b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/BatchScriptRunner.scala
new file mode 100644
index 000000000..3fcad568d
--- /dev/null
+++ b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/BatchScriptRunner.scala
@@ -0,0 +1,77 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package scriptedtest
+
+import java.util.concurrent.{ Executors, TimeUnit, TimeoutException }
+
+import scala.collection.mutable
+import scala.concurrent.duration._
+import sbt.internal.scripted._
+
+private[sbt] object BatchScriptRunner {
+  type States = mutable.HashMap[StatementHandler, StatementHandler#State]
+}
+
+/** Defines an alternative script runner that allows batch execution. */
+private[sbt] class BatchScriptRunner extends ScriptRunner with AutoCloseable {
+  import BatchScriptRunner.States
+  private[this] val service = Executors.newCachedThreadPool()
+
+  /** Defines a method to run batched execution.
+   *
+   * @param statements The list of handlers and statements.
+   * @param states The states of the runner. In case it's empty, inherited apply is called.
+   */
+  def apply(statements: List[(StatementHandler, Statement)], states: States): Unit = {
+    if (states.isEmpty) super.apply(statements)
+    else statements.foreach(st => processStatement(st._1, st._2, states))
+  }
+
+  def initStates(states: States, handlers: Seq[StatementHandler]): Unit =
+    handlers.foreach(handler => states(handler) = handler.initialState)
+
+  def cleanUpHandlers(handlers: Seq[StatementHandler], states: States): Unit = {
+    for (handler <- handlers; state <- states.get(handler)) {
+      try handler.finish(state.asInstanceOf[handler.State])
+      catch { case _: Exception => () }
+    }
+  }
+
+  private val timeout = 5.minutes
+  def processStatement(handler: StatementHandler, statement: Statement, states: States): Unit = {
+    val state = states(handler).asInstanceOf[handler.State]
+    val nextStateFuture = service.submit(
+      () =>
+        try Right(handler(statement.command, statement.arguments, state))
+        catch { case e: Exception => Left(e) }
+    )
+    try {
+      nextStateFuture.get(timeout.toMillis, TimeUnit.MILLISECONDS) match {
+        case Left(err) =>
+          if (statement.successExpected) {
+            err match {
+              case t: TestFailed =>
+                throw new TestException(statement, "Command failed: " + t.getMessage, null)
+              case _ => throw new TestException(statement, "Command failed", err)
+            }
+          } else
+            ()
+        case Right(s) =>
+          if (statement.successExpected)
+            states(handler) = s
+          else
+            throw new TestException(statement, "Command succeeded but failure was expected", null)
+      }
+    } catch {
+      case e: TimeoutException => throw new TestException(statement, "Command timed out", e)
+    }
+  }
+
+  override def close(): Unit = service.shutdown()
+}
diff --git a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/RemoteSbtCreator.scala b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/RemoteSbtCreator.scala
new file mode 100644
index 000000000..41044871f
--- /dev/null
+++ b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/RemoteSbtCreator.scala
@@ -0,0 +1,68 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package scriptedtest
+
+import xsbt.IPC
+
+import scala.sys.process.{ BasicIO, Process }
+
+private[sbt] sealed trait RemoteSbtCreatorProp
+private[sbt] object RemoteSbtCreatorProp {
+  case class LauncherBased(launcherJar: File) extends RemoteSbtCreatorProp
+  case class RunFromSourceBased(scalaVersion: String, sbtVersion: String, classpath: Seq[File])
+      extends RemoteSbtCreatorProp
+}
+
+abstract class RemoteSbtCreator private[sbt] {
+  def newRemote(server: IPC.Server): Process
+}
+
+final class LauncherBasedRemoteSbtCreator(
+    directory: File,
+    launcher: File,
+    log: Logger,
+    launchOpts: Seq[String] = Nil,
+) extends RemoteSbtCreator {
+  def newRemote(server: IPC.Server) = {
+    val launcherJar = launcher.getAbsolutePath
+    val globalBase = "-Dsbt.global.base=" + (new File(directory, "global")).getAbsolutePath
+    val scripted = "-Dsbt.scripted=true"
+    val args = List("<" + server.port)
+    val cmd = "java" :: launchOpts.toList ::: globalBase :: scripted :: "-jar" :: launcherJar :: args ::: Nil
+    val io = BasicIO(false, log).withInput(_.close())
+    val p = Process(cmd, directory) run (io)
+    val thread = new Thread() { override def run() = { p.exitValue(); server.close() } }
+    thread.start()
+    p
+  }
+}
+
+final class RunFromSourceBasedRemoteSbtCreator(
+    directory: File,
+    log: Logger,
+    launchOpts: Seq[String] = Nil,
+    scalaVersion: String,
+    sbtVersion: String,
+    classpath: Seq[File],
+) extends RemoteSbtCreator {
+  def newRemote(server: IPC.Server): Process = {
+    val globalBase = "-Dsbt.global.base=" + new File(directory, "global").getAbsolutePath
+    val scripted = "-Dsbt.scripted=true"
+    val mainClassName = "sbt.RunFromSourceMain"
+    val cpString = classpath.mkString(java.io.File.pathSeparator)
+    val args =
+      List(mainClassName, directory.toString, scalaVersion, sbtVersion, cpString, "<" + server.port)
+    val cmd = "java" :: launchOpts.toList ::: globalBase :: scripted :: "-cp" :: cpString :: args ::: Nil
+    val io = BasicIO(false, log).withInput(_.close())
+    val p = Process(cmd, directory) run (io)
+    val thread = new Thread() { override def run() = { p.exitValue(); server.close() } }
+    thread.start()
+    p
+  }
+}
diff --git a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/SbtHandler.scala b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/SbtHandler.scala
new file mode 100644
index 000000000..b8af69c58
--- /dev/null
+++ b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/SbtHandler.scala
@@ -0,0 +1,89 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package scriptedtest
+
+import java.io.IOException
+import java.net.SocketException
+
+import scala.sys.process.Process
+
+import sbt.internal.scripted.{ StatementHandler, TestFailed }
+import sbt.internal.util.RunningProcesses
+
+import xsbt.IPC
+
+final case class SbtInstance(process: Process, server: IPC.Server)
+
+final class SbtHandler(remoteSbtCreator: RemoteSbtCreator) extends StatementHandler {
+  Signals.register(() => RunningProcesses.killAll())
+
+  type State = Option[SbtInstance]
+
+  def initialState = None
+
+  def apply(command: String, arguments: List[String], i: Option[SbtInstance]): Option[SbtInstance] =
+    onSbtInstance(i) { (_, server) =>
+      send((command :: arguments).mkString(" "), server)
+      receive(s"$command failed", server)
+    }
+
+  def onSbtInstance(i: Option[SbtInstance])(f: (Process, IPC.Server) => Unit): Option[SbtInstance] =
+    i match {
+      case Some(SbtInstance(_, server)) if server.isClosed => finish(i); onNewSbtInstance(f)
+      case Some(SbtInstance(process, server))              => f(process, server); i
+      case None                                            => onNewSbtInstance(f)
+    }
+
+  private[this] def onNewSbtInstance(f: (Process, IPC.Server) => Unit): Option[SbtInstance] = {
+    val server = IPC.unmanagedServer
+    val p =
+      try newRemote(server)
+      catch { case e: Throwable => server.close(); throw e }
+    val i = Some(SbtInstance(p, server))
+    try f(p, server)
+    catch {
+      case e: Throwable =>
+        // TODO: closing is necessary only because StatementHandler uses exceptions for signaling errors
+        finish(i)
+        throw e
+    }
+    i
+  }
+
+  def finish(state: State) = state match {
+    case None =>
+    case Some(SbtInstance(process, server)) =>
+      try {
+        send("exit", server)
+        process.exitValue()
+        ()
+      } catch {
+        case _: IOException => process.destroy()
+      } finally {
+        if (process.isAlive) process.destroy()
+        RunningProcesses.remove(process)
+      }
+  }
+
+  def send(message: String, server: IPC.Server) = server.connection(_.send(message))
+
+  def receive(errorMessage: String, server: IPC.Server) =
+    server.connection { ipc =>
+      val resultMessage = ipc.receive
+      if (!resultMessage.toBoolean) throw new TestFailed(errorMessage)
+    }
+
+  def newRemote(server: IPC.Server): Process = {
+    val p = remoteSbtCreator.newRemote(server)
+    RunningProcesses.add(p)
+    try receive("Remote sbt initialization failed", server)
+    catch { case _: SocketException => throw new TestFailed("Remote sbt initialization failed") }
+    p
+  }
+}
diff --git a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala
new file mode 100644
index 000000000..cec073175
--- /dev/null
+++ b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala
@@ -0,0 +1,676 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package scriptedtest
+
+import java.io.{ FileNotFoundException, IOException }
+import java.net.SocketException
+import java.nio.file.Files
+import java.util.Properties
+import java.util.concurrent.ForkJoinPool
+
+import sbt.internal.io.Resources
+import sbt.internal.scripted._
+import RemoteSbtCreatorProp._
+
+import scala.annotation.nowarn
+import scala.collection.parallel.ForkJoinTaskSupport
+import scala.collection.{ GenSeq, mutable }
+import scala.util.control.NonFatal
+
+final class ScriptedTests(
+    resourceBaseDirectory: File,
+    bufferLog: Boolean,
+    launchOpts: Seq[String],
+) {
+  import ScriptedTests.TestRunner
+
+  private val testResources = new Resources(resourceBaseDirectory)
+
+  val ScriptFilename = "test"
+  val PendingScriptFilename = "pending"
+
+  /** Returns a sequence of test runners that have to be applied in the call site. */
+  def singleScriptedTest(
+      group: String,
+      name: String,
+      prescripted: File => Unit,
+      log: Logger,
+      prop: RemoteSbtCreatorProp
+  ): Seq[TestRunner] = {
+
+    // Test group and names may be file filters (like '*')
+    for {
+      groupDir <- (resourceBaseDirectory * group).get
+      nme <- (groupDir * name).get
+      if !(nme.isFile)
+    } yield {
+      val g = groupDir.getName
+      val n = nme.getName
+      val label = s"$g / $n"
+      () => {
+        log.info(s"Running $label")
+        val result = testResources.readWriteResourceDirectory(g, n) { testDirectory =>
+          val buffer = new BufferedLogger(new FullLogger(log))
+          val singleTestRunner = () => {
+            val handlers = createScriptedHandlers(testDirectory, buffer, prop)
+            val runner = new BatchScriptRunner
+            val states = new mutable.HashMap[StatementHandler, StatementHandler#State]()
+            try commonRunTest(label, testDirectory, prescripted, handlers, runner, states, buffer)
+            finally runner.close()
+          }
+          runOrHandleDisabled(label, testDirectory, singleTestRunner, buffer)
+        }
+        Seq(result)
+      }
+    }
+  }
+
+  private def createScriptedHandlers(
+      testDir: File,
+      buffered: Logger,
+      prop: RemoteSbtCreatorProp
+  ): Map[Char, StatementHandler] = {
+    val fileHandler = new FileCommands(testDir)
+    val remoteSbtCreator =
+      prop match {
+        case LauncherBased(launcherJar) =>
+          new LauncherBasedRemoteSbtCreator(testDir, launcherJar, buffered, launchOpts)
+        case RunFromSourceBased(scalaVersion, sbtVersion, classpath) =>
+          new RunFromSourceBasedRemoteSbtCreator(
+            testDir,
+            buffered,
+            launchOpts,
+            scalaVersion,
+            sbtVersion,
+            classpath
+          )
+      }
+    val sbtHandler = new SbtHandler(remoteSbtCreator)
+    Map('$' -> fileHandler, '>' -> sbtHandler, '#' -> CommentHandler)
+  }
+
+  /** Returns a sequence of test runners that have to be applied in the call site. */
+  def batchScriptedRunner(
+      testGroupAndNames: Seq[(String, String)],
+      prescripted: File => Unit,
+      sbtInstances: Int,
+      prop: RemoteSbtCreatorProp,
+      log: Logger
+  ): Seq[TestRunner] = {
+    // Test group and names may be file filters (like '*')
+    val groupAndNameDirs = {
+      for {
+        (group, name) <- testGroupAndNames
+        groupDir <- (resourceBaseDirectory * group).get
+        testDir <- (groupDir * name).get
+      } yield (groupDir, testDir)
+    }
+
+    type TestInfo = ((String, String), File)
+
+    val labelsAndDirs = groupAndNameDirs.filterNot(_._2.isFile).map {
+      case (groupDir, nameDir) =>
+        val groupName = groupDir.getName
+        val testName = nameDir.getName
+        val testDirectory = testResources.readOnlyResourceDirectory(groupName, testName)
+        (groupName, testName) -> testDirectory
+    }
+
+    if (labelsAndDirs.isEmpty) List()
+    else {
+      val totalSize = labelsAndDirs.size
+      val batchSize = totalSize / sbtInstances match {
+        case 0 => 1
+        case s => s
+      }
+
+      val runFromSourceBasedTestsUnfiltered = labelsAndDirs
+      val runFromSourceBasedTests = runFromSourceBasedTestsUnfiltered.filterNot(windowsExclude)
+
+      def logTests(size: Int, how: String) =
+        log.info(
+          f"Running $size / $totalSize (${size * 100d / totalSize}%3.2f%%) scripted tests with $how"
+        )
+      logTests(runFromSourceBasedTests.size, "RunFromSourceMain")
+
+      def createTestRunners(tests: Seq[TestInfo]): Seq[TestRunner] = {
+        tests
+          .sortBy(_._1)
+          .grouped(batchSize)
+          .map { batch => () =>
+            IO.withTemporaryDirectory {
+              runBatchedTests(batch, _, prescripted, prop, log)
+            }
+          }
+          .toList
+      }
+
+      createTestRunners(runFromSourceBasedTests)
+    }
+  }
+
+  private[this] val windowsExclude: (((String, String), File)) => Boolean =
+    if (scala.util.Properties.isWin) {
+      case (testName, _) =>
+        testName match {
+          case ("classloader-cache", "jni") => true // no native lib is built for windows
+          case ("classloader-cache", "snapshot") =>
+            true // the test overwrites a jar that is being used which is verboten in windows
+          // The test spark server is unable to bind to a local socket on Visual Studio 2019
+          case ("classloader-cache", "spark") => true
+          case ("nio", "make-clone")          => true // uses gcc which isn't set up on all systems
+          // symlinks don't work the same on windows. Symlink monitoring does work in many cases
+          // on windows but not to the same level as it does on osx and linux
+          case ("watch", "symlinks") => true
+          case _                     => false
+        }
+    }
+    else _ => false
+
+  /** Defines the batch execution of scripted tests.
+   *
+   * Scripted tests are run one after the other one recycling the handlers, under
+   * the assumption that handlers do not produce side effects that can change scripted
+   * tests' behaviours.
+   *
+   * In batch mode, the test runner performs these operations between executions:
+   *
+   * 1. Delete previous test files in the common test directory.
+   * 2. Copy over next test files to the common test directory.
+   * 3. Reload the sbt handler.
+   *
+   * @param groupedTests The labels and directories of the tests to run.
+   * @param tempTestDir The common test directory.
+   * @param preHook The hook to run before scripted execution.
+   * @param log The logger.
+   */
+  private def runBatchedTests(
+      groupedTests: Seq[((String, String), File)],
+      tempTestDir: File,
+      preHook: File => Unit,
+      prop: RemoteSbtCreatorProp,
+      log: Logger
+  ): Seq[Option[String]] = {
+
+    val runner = new BatchScriptRunner
+    val buffer = new BufferedLogger(new FullLogger(log))
+    val handlers = createScriptedHandlers(tempTestDir, buffer, prop)
+    val states = new BatchScriptRunner.States
+    val seqHandlers = handlers.values.toList
+    runner.initStates(states, seqHandlers)
+
+    def runBatchTests = {
+      groupedTests.map {
+        case ((group, name), originalDir) =>
+          val label = s"$group/$name"
+          log.info(s"Running $label")
+          // Copy test's contents and reload the sbt instance to pick them up
+          IO.copyDirectory(originalDir, tempTestDir)
+
+          val runTest = () => {
+            // Reload and initialize (to reload contents of .sbtrc files)
+            def sbtHandlerError = sys error "Missing sbt handler. Scripted is misconfigured."
+            val sbtHandler = handlers.getOrElse('>', sbtHandlerError)
+            val statement = Statement("reload;initialize", Nil, successExpected = true, line = -1)
+
+            // Run reload inside the hook to reuse error handling for pending tests
+            val wrapHook = (file: File) => {
+              preHook(file)
+              try runner.processStatement(sbtHandler, statement, states)
+              catch {
+                case t: Throwable =>
+                  val newMsg = "Reload for scripted batch execution failed."
+                  throw new TestException(statement, newMsg, t)
+              }
+            }
+
+            commonRunTest(label, tempTestDir, wrapHook, handlers, runner, states, buffer)
+          }
+
+          // Run the test and delete files (except global that holds local scala jars)
+          val result = runOrHandleDisabled(label, tempTestDir, runTest, buffer)
+          val view = sbt.nio.file.FileTreeView.default
+          val base = tempTestDir.getCanonicalFile.toGlob
+          val global = base / "global"
+          val globalLogging = base / ** / "global-logging"
+          def recursiveFilter(glob: Glob): PathFilter = (glob: PathFilter) || glob / **
+          val keep: PathFilter = recursiveFilter(global) || recursiveFilter(globalLogging)
+          val toDelete = view.list(base / **, !keep).map(_._1).sorted.reverse
+          toDelete.foreach { p =>
+            try Files.deleteIfExists(p)
+            catch { case _: IOException => }
+          }
+          result
+      }
+    }
+
+    try runBatchTests
+    finally {
+      runner.cleanUpHandlers(seqHandlers, states)
+      runner.close()
+    }
+  }
+
+  private def runOrHandleDisabled(
+      label: String,
+      testDirectory: File,
+      runTest: () => Option[String],
+      log: Logger
+  ): Option[String] = {
+    val existsDisabled = new File(testDirectory, "disabled").isFile
+    if (!existsDisabled) runTest()
+    else {
+      log.info(s"D $label [DISABLED]")
+      None
+    }
+  }
+
+  private val PendingLabel = "[PENDING]"
+
+  private def commonRunTest(
+      label: String,
+      testDirectory: File,
+      preScriptedHook: File => Unit,
+      handlers: Map[Char, StatementHandler],
+      runner: BatchScriptRunner,
+      states: BatchScriptRunner.States,
+      log: BufferedLogger
+  ): Option[String] = {
+    if (bufferLog) log.record()
+
+    val (file, pending) = {
+      val normal = (new File(testDirectory, ScriptFilename), false)
+      val normalScript = (new File(testDirectory, s"$ScriptFilename.script"), false)
+      val pending = (new File(testDirectory, PendingScriptFilename), true)
+      val pendingScript = (new File(testDirectory, s"$PendingScriptFilename.script"), true)
+
+      List(pending, pendingScript, normal, normalScript).find(_._1.isFile) match {
+        case Some(script) => script
+        case None         => throw new FileNotFoundException("no test scripts found")
+      }
+    }
+
+    val pendingMark: String = if (pending) PendingLabel else ""
+
+    def testFailed(t: Throwable): Option[String] = {
+      if (pending) log.clear() else log.stop()
+      log.error(s"x $label $pendingMark")
+      if (!NonFatal(t)) throw t // We make sure fatal errors are rethrown
+      if (t.isInstanceOf[TestException]) {
+        t.getCause match {
+          case null | _: SocketException => log.error(s" Cause of test exception: ${t.getMessage}")
+          case _                         => if (!pending) t.printStackTrace()
+        }
+        log.play()
+      }
+      if (pending) None else Some(label)
+    }
+
+    import scala.util.control.Exception.catching
+    catching(classOf[TestException]).withApply(testFailed).andFinally(log.clear).apply {
+      preScriptedHook(testDirectory)
+      val parser = new TestScriptParser(handlers)
+      val handlersAndStatements = parser.parse(file, stripQuotes = false)
+      runner.apply(handlersAndStatements, states)
+
+      // Handle successful tests
+      log.info(s"+ $label $pendingMark")
+      if (pending) {
+        log.clear()
+        log.error(" Pending test passed. Mark as passing to remove this failure.")
+        Some(label)
+      } else None
+    }
+  }
+}
+
+object ScriptedTests extends ScriptedRunner {
+
+  /** Represents the function that runs the scripted tests, both in single or batch mode. */
+  type TestRunner = () => Seq[Option[String]]
+
+  def main(args: Array[String]): Unit = {
+    val directory = new File(args(0))
+    val buffer = args(1).toBoolean
+    val sbtVersion = args(2)
+    val defScalaVersion = args(3)
+    //  val buildScalaVersions = args(4)
+    //val bootProperties = new File(args(5))
+    val tests = args.drop(6)
+    val logger = TestConsoleLogger()
+    val cp = System.getProperty("java.class.path", "").split(java.io.File.pathSeparator).map(file)
+    runInParallel(
+      directory,
+      buffer,
+      tests,
+      logger,
+      Array(),
+      new java.util.ArrayList[File],
+      defScalaVersion,
+      sbtVersion,
+      cp,
+      1
+    )
+  }
+
+}
+
+/** Runner for `scripted`. Not be confused with ScriptRunner. */
+class ScriptedRunner {
+
+  /**
+   * This is the entry point used by sbt-scripted 0.13.18.
+   * Removing this method will break sbt plugin cross building.
+   * See https://github.com/sbt/sbt/issues/3245
+   * See https://github.com/sbt/sbt/blob/v0.13.18/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala#L39
+   */
+  def run(
+      resourceBaseDirectory: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      launcherJar: File,
+      launchOpts: Array[String],
+  ): Unit = {
+    val logger = TestConsoleLogger()
+    run(
+      resourceBaseDirectory,
+      bufferLog,
+      tests,
+      logger,
+      launchOpts,
+      prescripted = new java.util.ArrayList[File],
+      LauncherBased(launcherJar),
+      1,
+      parallelExecution = false,
+    )
+  }
+
+  /**
+   * This is the entry point used by SbtPlugin in sbt 1.2.x, 1.3.x, 1.4.x etc.
+   * Removing this method will break scripted and sbt plugin cross building.
+   * See https://github.com/sbt/sbt/issues/3245
+   * See https://github.com/sbt/sbt/blob/v1.2.8/main/src/main/scala/sbt/ScriptedPlugin.scala#L109-L113
+   */
+  def run(
+      resourceBaseDirectory: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      launcherJar: File,
+      launchOpts: Array[String],
+      prescripted: java.util.List[File],
+  ): Unit = {
+    val logger = TestConsoleLogger()
+    run(
+      resourceBaseDirectory,
+      bufferLog,
+      tests,
+      logger,
+      launchOpts,
+      prescripted,
+      LauncherBased(launcherJar),
+      Int.MaxValue,
+      parallelExecution = false,
+    )
+  }
+
+  /**
+   * This is the entry point used by SbtPlugin in sbt 1.2.x, 1.3.x, 1.4.x etc.
+   * Removing this method will break scripted and sbt plugin cross building.
+   * See https://github.com/sbt/sbt/issues/3245
+   * See https://github.com/sbt/sbt/blob/v1.2.8/main/src/main/scala/sbt/ScriptedPlugin.scala#L109-L113
+   */
+  def runInParallel(
+      resourceBaseDirectory: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      launcherJar: File,
+      launchOpts: Array[String],
+      prescripted: java.util.List[File],
+      instance: Int,
+  ): Unit = {
+    val logger = TestConsoleLogger()
+    runInParallel(
+      resourceBaseDirectory,
+      bufferLog,
+      tests,
+      logger,
+      launchOpts,
+      prescripted,
+      LauncherBased(launcherJar),
+      instance,
+    )
+  }
+
+  // This is called by project/Scripted.scala
+  // Using java.util.List[File] to encode File => Unit
+  def runInParallel(
+      baseDir: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      logger: Logger,
+      launchOpts: Array[String],
+      prescripted: java.util.List[File],
+      scalaVersion: String,
+      sbtVersion: String,
+      classpath: Array[File],
+      instances: Int
+  ): Unit =
+    runInParallel(
+      baseDir,
+      bufferLog,
+      tests,
+      logger,
+      launchOpts,
+      prescripted,
+      RunFromSourceBased(scalaVersion, sbtVersion, classpath),
+      instances
+    )
+
+  private[sbt] def runInParallel(
+      baseDir: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      logger: Logger,
+      launchOpts: Array[String],
+      prescripted: java.util.List[File],
+      prop: RemoteSbtCreatorProp,
+      instances: Int
+  ) = run(baseDir, bufferLog, tests, logger, launchOpts, prescripted, prop, instances, true)
+
+  @nowarn
+  private[this] def run(
+      baseDir: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      logger: Logger,
+      launchOpts: Array[String],
+      prescripted: java.util.List[File],
+      prop: RemoteSbtCreatorProp,
+      instances: Int,
+      parallelExecution: Boolean,
+  ): Unit = {
+    val addTestFile = (f: File) => { prescripted.add(f); () }
+    val runner = new ScriptedTests(baseDir, bufferLog, launchOpts)
+    val sbtVersion =
+      prop match {
+        case LauncherBased(launcherJar) =>
+          launcherJar.getName.dropWhile(!_.isDigit).dropRight(".jar".length)
+        case RunFromSourceBased(_, sbtVersion, _) => sbtVersion
+      }
+    val accept = isTestCompatible(baseDir, sbtVersion) _
+    // The scripted tests mapped to the inputs that the user wrote after `scripted`.
+    val scriptedTests =
+      get(tests, baseDir, accept, logger).map(st => (st.group, st.name))
+    // Choosing Int.MaxValue will make the groupSize 1 in batchScriptedRunner
+    val groupCount = if (parallelExecution) instances else Int.MaxValue
+    val scriptedRunners =
+      runner.batchScriptedRunner(scriptedTests, addTestFile, groupCount, prop, logger)
+    if (parallelExecution && instances > 1) {
+      import sbt.internal.CompatParColls.Converters._
+      val parallelRunners = scriptedRunners.toArray.par
+      parallelRunners.tasksupport = new ForkJoinTaskSupport(new ForkJoinPool(instances))
+      runAll(parallelRunners)
+    } else {
+      runAll(scriptedRunners)
+    }
+  }
+  def runInParallel(
+      baseDir: File,
+      bufferLog: Boolean,
+      tests: Array[String],
+      launchOpts: Array[String],
+      prescripted: java.util.List[File],
+      sbtVersion: String,
+      scalaVersion: String,
+      classpath: Array[File],
+      instances: Int
+  ): Unit =
+    runInParallel(
+      baseDir,
+      bufferLog,
+      tests,
+      TestConsoleLogger(),
+      launchOpts,
+      prescripted,
+      sbtVersion,
+      scalaVersion,
+      classpath,
+      instances
+    )
+
+  private def reportErrors(errors: GenSeq[String]): Unit =
+    if (errors.nonEmpty) sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n")) else ()
+
+  def runAll(toRun: Seq[ScriptedTests.TestRunner]): Unit =
+    reportErrors(toRun.flatMap(test => test.apply().flatten))
+
+  def runAll(toRun: scala.collection.parallel.ParSeq[ScriptedTests.TestRunner]): Unit =
+    reportErrors(toRun.flatMap(test => test.apply().flatten).toList)
+
+  @deprecated("No longer used", "1.1.0")
+  def get(tests: Seq[String], baseDirectory: File, log: Logger): Seq[ScriptedTest] =
+    get(tests, baseDirectory, _ => true, log)
+
+  def get(
+      tests: Seq[String],
+      baseDirectory: File,
+      accept: ScriptedTest => Boolean,
+      log: Logger,
+  ): Seq[ScriptedTest] = {
+    val unsorted = if (tests.isEmpty) listTests(baseDirectory, accept, log) else parseTests(tests)
+    unsorted.sortBy(t => (t.group, t.name))
+  }
+
+  @deprecated("No longer used", "1.1.0")
+  def listTests(baseDirectory: File, log: Logger): Seq[ScriptedTest] =
+    listTests(baseDirectory, _ => true, log)
+
+  def listTests(
+      baseDirectory: File,
+      accept: ScriptedTest => Boolean,
+      log: Logger,
+  ): Seq[ScriptedTest] =
+    (new ListTests(baseDirectory, accept, log)).listTests
+
+  def parseTests(in: Seq[String]): Seq[ScriptedTest] =
+    for (testString <- in) yield {
+      val Array(group, name) = testString.split("/").map(_.trim)
+      ScriptedTest(group, name)
+    }
+
+  private def isTestCompatible(resourceBaseDirectory: File, sbtVersion: String)(
+      test: ScriptedTest
+  ): Boolean = {
+    import sbt.internal.librarymanagement.cross.CrossVersionUtil.binarySbtVersion
+    val buildProperties = new Properties()
+    val testDir = new File(new File(resourceBaseDirectory, test.group), test.name)
+    val buildPropertiesFile = new File(new File(testDir, "project"), "build.properties")
+
+    IO.load(buildProperties, buildPropertiesFile)
+
+    Option(buildProperties.getProperty("sbt.version")) match {
+      case Some(version) => binarySbtVersion(version) == binarySbtVersion(sbtVersion)
+      case None          => true
+    }
+  }
+
+}
+
+final case class ScriptedTest(group: String, name: String) {
+  override def toString = s"$group/$name"
+}
+
+private[sbt] final class ListTests(
+    baseDirectory: File,
+    accept: ScriptedTest => Boolean,
+    log: Logger,
+) {
+
+  def filter = DirectoryFilter -- HiddenFileFilter
+
+  def listTests: Seq[ScriptedTest] = {
+    IO.listFiles(baseDirectory, filter) flatMap { group =>
+      val groupName = group.getName
+      listTests(group).map(ScriptedTest(groupName, _))
+    }
+  }
+
+  private[this] def listTests(group: File): Set[String] = {
+    val groupName = group.getName
+    val allTests = IO.listFiles(group, filter)
+    if (allTests.isEmpty) {
+      log.warn(s"No tests in test group $groupName")
+      Set.empty
+    } else {
+      val (included, skipped) =
+        allTests.toList.partition(test => accept(ScriptedTest(groupName, test.getName)))
+      if (included.isEmpty)
+        log.warn(s"Test group $groupName skipped.")
+      else if (skipped.nonEmpty) {
+        log.warn(s"Tests skipped in group $groupName:")
+        skipped.foreach(testName => log.warn(s" ${testName.getName}"))
+      }
+      Set(included.map(_.getName): _*)
+    }
+  }
+}
+
+class PendingTestSuccessException(label: String) extends Exception {
+  override def getMessage: String =
+    s"The pending test $label succeeded. Mark this test as passing to remove this failure."
+}
+
+private[sbt] object TestConsoleLogger {
+  def apply() = new TestConsoleLogger()
+}
+
+// Remove dependencies to log4j to avoid mixup.
+private[sbt] class TestConsoleLogger extends AbstractLogger {
+  val out = ConsoleOut.systemOut
+  def trace(t: => Throwable): Unit = {
+    out.println(t.toString)
+    // out.flush()
+  }
+  def success(message: => String): Unit = {
+    out.println(message)
+    // out.flush()
+  }
+  def log(level: Level.Value, message: => String): Unit = {
+    out.println(s"[$level] $message")
+    // out.flush()
+  }
+  def control(event: sbt.util.ControlEvent.Value, message: => String): Unit = ()
+  def getLevel: sbt.util.Level.Value = Level.Info
+  def getTrace: Int = Int.MaxValue
+  def logAll(events: Seq[sbt.util.LogEvent]): Unit = ()
+  def setLevel(newLevel: sbt.util.Level.Value): Unit = ()
+  def setSuccessEnabled(flag: Boolean): Unit = ()
+  def setTrace(flag: Int): Unit = ()
+  def successEnabled: Boolean = true
+}
diff --git a/scripted/plugin/src/main/resources/sbt/sbt.autoplugins b/scripted/plugin/src/main/resources/sbt/sbt.autoplugins
deleted file mode 100644
index 0077b7635..000000000
--- a/scripted/plugin/src/main/resources/sbt/sbt.autoplugins
+++ /dev/null
@@ -1 +0,0 @@
-sbt.ScriptedPlugin
\ No newline at end of file
diff --git a/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala b/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala
deleted file mode 100644
index 5ccd43830..000000000
--- a/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala
+++ /dev/null
@@ -1,95 +0,0 @@
-/* sbt -- Simple Build Tool
- * Copyright 2011 Artyom Olshevskiy
- */
-package sbt
-
-import Def.Initialize
-import Keys._
-import sbt.internal.util.complete.{ Parser, DefaultParsers }
-import sbt.internal.inc.classpath.ClasspathUtilities
-import sbt.internal.inc.ModuleUtilities
-import java.lang.reflect.Method
-
-import sbt.syntax._
-
-object ScriptedPlugin extends AutoPlugin {
-  override def requires = plugins.JvmPlugin
-  override def trigger = allRequirements
-  object autoImport {
-    def scriptedConf = config("scripted-sbt") hide
-    def scriptedLaunchConf = config("scripted-sbt-launch") hide
-    val scriptedSbt = SettingKey[String]("scripted-sbt")
-    val sbtLauncher = TaskKey[File]("sbt-launcher")
-    val sbtTestDirectory = SettingKey[File]("sbt-test-directory")
-    val scriptedBufferLog = SettingKey[Boolean]("scripted-buffer-log")
-    val scriptedClasspath = TaskKey[PathFinder]("scripted-classpath")
-    val scriptedTests = TaskKey[AnyRef]("scripted-tests")
-    val scriptedRun = TaskKey[Method]("scripted-run")
-    val scriptedLaunchOpts = SettingKey[Seq[String]]("scripted-launch-opts", "options to pass to jvm launching scripted tasks")
-    val scriptedDependencies = TaskKey[Unit]("scripted-dependencies")
-    val scripted = InputKey[Unit]("scripted")
-  }
-  import autoImport._
-  override lazy val projectSettings = Seq(
-    ivyConfigurations ++= Seq(scriptedConf, scriptedLaunchConf),
-    scriptedSbt := sbtVersion.value,
-    sbtLauncher := getJars(scriptedLaunchConf).map(_.get.head).value,
-    sbtTestDirectory := sourceDirectory.value / "sbt-test",
-    libraryDependencies ++= Seq(
-      "org.scala-sbt" %% "scripted-sbt" % scriptedSbt.value % scriptedConf.toString,
-      "org.scala-sbt" % "sbt-launch" % scriptedSbt.value % scriptedLaunchConf.toString
-    ),
-    scriptedBufferLog := true,
-    scriptedClasspath := getJars(scriptedConf).value,
-    scriptedTests := scriptedTestsTask.value,
-    scriptedRun := scriptedRunTask.value,
-    scriptedDependencies := {
-      val analysis = (compile in Test).value
-      val pub = (publishLocal).value
-      Unit
-    },
-    scriptedLaunchOpts := Seq(),
-    scripted := scriptedTask.evaluated
-  )
-
-  def scriptedTestsTask: Initialize[Task[AnyRef]] = (scriptedClasspath, scalaInstance) map {
-    (classpath, scala) =>
-      val loader = ClasspathUtilities.toLoader(classpath, scala.loader)
-      ModuleUtilities.getObject("sbt.test.ScriptedTests", loader)
-  }
-
-  def scriptedRunTask: Initialize[Task[Method]] = (scriptedTests) map {
-    (m) =>
-      m.getClass.getMethod("run", classOf[File], classOf[Boolean], classOf[Array[String]], classOf[File], classOf[Array[String]])
-  }
-
-  private def scriptedParser(scriptedBase: File): Parser[Seq[String]] =
-    {
-      import DefaultParsers._
-      val pairs = (scriptedBase * AllPassFilter * AllPassFilter * "test").get map { (f: File) =>
-        val p = f.getParentFile
-        (p.getParentFile.getName, p.getName)
-      }
-      val pairMap = pairs.groupBy(_._1).mapValues(_.map(_._2).toSet)
-
-      val id = charClass(c => !c.isWhitespace && c != '/').+.string
-      val groupP = token(id.examples(pairMap.keySet)) <~ token('/')
-      def nameP(group: String) = token("*".id | id.examples(pairMap(group)))
-      val testID = for (group <- groupP; name <- nameP(group)) yield (group, name)
-      (token(Space) ~> matched(testID)).*
-    }
-
-  def scriptedTask: Initialize[InputTask[Unit]] = Def.inputTask {
-    val args = scriptedParser(sbtTestDirectory.value).parsed
-    scriptedDependencies.value
-    try {
-      scriptedRun.value.invoke(
-        scriptedTests.value, sbtTestDirectory.value, scriptedBufferLog.value: java.lang.Boolean,
-        args.toArray, sbtLauncher.value, scriptedLaunchOpts.value.toArray)
-    } catch { case e: java.lang.reflect.InvocationTargetException => throw e.getCause }
-  }
-
-  private[this] def getJars(config: Configuration): Initialize[Task[PathFinder]] = Def.task {
-    PathFinder(Classpaths.managedJars(config, classpathTypes.value, update.value).map(_.data))
-  }
-}
diff --git a/scripted/sbt/NOTICE b/scripted/sbt/NOTICE
deleted file mode 100644
index 05434b284..000000000
--- a/scripted/sbt/NOTICE
+++ /dev/null
@@ -1,3 +0,0 @@
-Simple Build Tool: Scripted Testing
-Copyright 2008, 2009, 2010  Mark Harrah
-Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
diff --git a/scripted/sbt/src/main/scala/sbt/test/SbtHandler.scala b/scripted/sbt/src/main/scala/sbt/test/SbtHandler.scala
deleted file mode 100644
index 4719b7ad2..000000000
--- a/scripted/sbt/src/main/scala/sbt/test/SbtHandler.scala
+++ /dev/null
@@ -1,83 +0,0 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009  Mark Harrah
- */
-package sbt
-package test
-
-import java.io.{ File, IOException }
-import xsbt.IPC
-
-import sbt.internal.scripted.{ StatementHandler, TestFailed }
-
-import sbt.util.Logger
-import sbt.util.Logger._
-
-import scala.sys.process.{ BasicIO, Process }
-
-final case class SbtInstance(process: Process, server: IPC.Server)
-
-final class SbtHandler(directory: File, launcher: File, log: Logger, launchOpts: Seq[String] = Seq()) extends StatementHandler {
-  type State = Option[SbtInstance]
-  def initialState = None
-
-  def apply(command: String, arguments: List[String], i: Option[SbtInstance]): Option[SbtInstance] = onSbtInstance(i) { (process, server) =>
-    send((command :: arguments.map(escape)).mkString(" "), server)
-    receive(command + " failed", server)
-  }
-  def onSbtInstance(i: Option[SbtInstance])(f: (Process, IPC.Server) => Unit): Option[SbtInstance] = i match {
-    case Some(ai @ SbtInstance(process, server)) if server.isClosed =>
-      finish(i)
-      onNewSbtInstance(f)
-    case Some(SbtInstance(process, server)) =>
-      f(process, server)
-      i
-    case None =>
-      onNewSbtInstance(f)
-  }
-  private[this] def onNewSbtInstance(f: (Process, IPC.Server) => Unit): Option[SbtInstance] =
-    {
-      val server = IPC.unmanagedServer
-      val p = try newRemote(server) catch { case e: Throwable => server.close(); throw e }
-      val ai = Some(SbtInstance(p, server))
-      try f(p, server) catch {
-        case e: Throwable =>
-          // TODO: closing is necessary only because StatementHandler uses exceptions for signaling errors
-          finish(ai); throw e
-      }
-      ai
-    }
-
-  def finish(state: Option[SbtInstance]) = state match {
-    case Some(SbtInstance(process, server)) =>
-      try {
-        send("exit", server)
-        process.exitValue()
-      } catch {
-        case e: IOException => process.destroy()
-      }
-    case None =>
-  }
-  def send(message: String, server: IPC.Server) = server.connection { _.send(message) }
-  def receive(errorMessage: String, server: IPC.Server) =
-    server.connection { ipc =>
-      val resultMessage = ipc.receive
-      if (!resultMessage.toBoolean) throw new TestFailed(errorMessage)
-    }
-  def newRemote(server: IPC.Server): Process =
-    {
-      val launcherJar = launcher.getAbsolutePath
-      val globalBase = "-Dsbt.global.base=" + (new File(directory, "global")).getAbsolutePath
-      val args = "java" :: (launchOpts.toList ++ (globalBase :: "-jar" :: launcherJar :: ("<" + server.port) :: Nil))
-      val io = BasicIO(false, log).withInput(_.close())
-      val p = Process(args, directory) run (io)
-      val thread = new Thread() { override def run() = { p.exitValue(); server.close() } }
-      thread.start()
-      try { receive("Remote sbt initialization failed", server) }
-      catch { case e: java.net.SocketException => throw new TestFailed("Remote sbt initialization failed") }
-      p
-    }
-  import java.util.regex.Pattern.{ quote => q }
-  // if the argument contains spaces, enclose it in quotes, quoting backslashes and quotes
-  def escape(argument: String) =
-    if (argument.contains(" ")) "\"" + argument.replaceAll(q("""\"""), """\\""").replaceAll(q("\""), "\\\"") + "\"" else argument
-}
diff --git a/scripted/sbt/src/main/scala/sbt/test/ScriptedTests.scala b/scripted/sbt/src/main/scala/sbt/test/ScriptedTests.scala
deleted file mode 100644
index 8b78e3f03..000000000
--- a/scripted/sbt/src/main/scala/sbt/test/ScriptedTests.scala
+++ /dev/null
@@ -1,223 +0,0 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009  Mark Harrah
- */
-
-package sbt
-package test
-
-import java.io.File
-
-import scala.util.control.NonFatal
-
-import sbt.internal.scripted.{ CommentHandler, FileCommands, ScriptRunner, TestScriptParser, TestException }
-import sbt.io.{ DirectoryFilter, HiddenFileFilter }
-import sbt.io.IO.wrapNull
-import sbt.internal.io.Resources
-
-import sbt.internal.util.{ BufferedLogger, ConsoleLogger, FullLogger }
-import sbt.util.{ AbstractLogger, Logger }
-
-final class ScriptedTests(resourceBaseDirectory: File, bufferLog: Boolean, launcher: File, launchOpts: Seq[String]) {
-  import ScriptedTests._
-  private val testResources = new Resources(resourceBaseDirectory)
-
-  val ScriptFilename = "test"
-  val PendingScriptFilename = "pending"
-
-  def scriptedTest(group: String, name: String, log: xsbti.Logger): Seq[() => Option[String]] =
-    scriptedTest(group, name, Logger.xlog2Log(log))
-  def scriptedTest(group: String, name: String, log: Logger): Seq[() => Option[String]] =
-    scriptedTest(group, name, emptyCallback, log)
-  def scriptedTest(group: String, name: String, prescripted: File => Unit, log: Logger): Seq[() => Option[String]] = {
-    import sbt.io.syntax._
-    for (groupDir <- (resourceBaseDirectory * group).get; nme <- (groupDir * name).get) yield {
-      val g = groupDir.getName
-      val n = nme.getName
-      val str = s"$g / $n"
-      () => {
-        println("Running " + str)
-        testResources.readWriteResourceDirectory(g, n) { testDirectory =>
-          val disabled = new File(testDirectory, "disabled").isFile
-          if (disabled) {
-            log.info("D " + str + " [DISABLED]")
-            None
-          } else {
-            try { scriptedTest(str, testDirectory, prescripted, log); None }
-            catch { case _: TestException | _: PendingTestSuccessException => Some(str) }
-          }
-        }
-      }
-    }
-  }
-
-  private def scriptedTest(label: String, testDirectory: File, prescripted: File => Unit, log: Logger): Unit =
-    {
-      val buffered = new BufferedLogger(new FullLogger(log))
-      if (bufferLog)
-        buffered.record()
-
-      def createParser() =
-        {
-          val fileHandler = new FileCommands(testDirectory)
-          val sbtHandler = new SbtHandler(testDirectory, launcher, buffered, launchOpts)
-          new TestScriptParser(Map('$' -> fileHandler, '>' -> sbtHandler, '#' -> CommentHandler))
-        }
-      val (file, pending) = {
-        val normal = new File(testDirectory, ScriptFilename)
-        val pending = new File(testDirectory, PendingScriptFilename)
-        if (pending.isFile) (pending, true) else (normal, false)
-      }
-      val pendingString = if (pending) " [PENDING]" else ""
-
-      def runTest() =
-        {
-          val run = new ScriptRunner
-          val parser = createParser()
-          run(parser.parse(file))
-        }
-      def testFailed(): Unit = {
-        if (pending) buffered.clear() else buffered.stop()
-        buffered.error("x " + label + pendingString)
-      }
-
-      try {
-        prescripted(testDirectory)
-        runTest()
-        buffered.info("+ " + label + pendingString)
-        if (pending) throw new PendingTestSuccessException(label)
-      } catch {
-        case e: TestException =>
-          testFailed()
-          e.getCause match {
-            case null | _: java.net.SocketException => buffered.error("   " + e.getMessage)
-            case _                                  => e.printStackTrace
-          }
-          if (!pending) throw e
-        case e: PendingTestSuccessException =>
-          testFailed()
-          buffered.error("  Mark as passing to remove this failure.")
-          throw e
-        case NonFatal(e) =>
-          testFailed()
-          if (!pending) throw e
-      } finally { buffered.clear() }
-    }
-}
-
-object ScriptedTests extends ScriptedRunner {
-  val emptyCallback: File => Unit = { _ => () }
-  def main(args: Array[String]): Unit = {
-    val directory = new File(args(0))
-    val buffer = args(1).toBoolean
-    //  val sbtVersion = args(2)
-    //  val defScalaVersion = args(3)
-    //  val buildScalaVersions = args(4)
-    val bootProperties = new File(args(5))
-    val tests = args.drop(6)
-    val logger = ConsoleLogger()
-    run(directory, buffer, tests, logger, bootProperties, Array(), emptyCallback)
-  }
-}
-
-class ScriptedRunner {
-  import ScriptedTests._
-
-  @deprecated("No longer used", "0.13.9")
-  def run(resourceBaseDirectory: File, bufferLog: Boolean, tests: Array[String], bootProperties: File,
-    launchOpts: Array[String]): Unit =
-    run(resourceBaseDirectory, bufferLog, tests, ConsoleLogger(), bootProperties, launchOpts, emptyCallback) //new FullLogger(Logger.xlog2Log(log)))
-
-  // This is called by project/Scripted.scala
-  // Using java.util.List[File] to encode File => Unit
-  def run(resourceBaseDirectory: File, bufferLog: Boolean, tests: Array[String], bootProperties: File,
-    launchOpts: Array[String], prescripted: java.util.List[File]): Unit =
-    run(resourceBaseDirectory, bufferLog, tests, ConsoleLogger(), bootProperties, launchOpts,
-      { f: File => prescripted.add(f); () }) //new FullLogger(Logger.xlog2Log(log)))
-
-  @deprecated("No longer used", "0.13.9")
-  def run(resourceBaseDirectory: File, bufferLog: Boolean, tests: Array[String], bootProperties: File,
-    launchOpts: Array[String], prescripted: File => Unit): Unit =
-    run(resourceBaseDirectory, bufferLog, tests, ConsoleLogger(), bootProperties, launchOpts, prescripted)
-
-  @deprecated("No longer used", "0.13.9")
-  def run(resourceBaseDirectory: File, bufferLog: Boolean, tests: Array[String], logger: AbstractLogger, bootProperties: File,
-    launchOpts: Array[String]): Unit =
-    run(resourceBaseDirectory, bufferLog, tests, logger, bootProperties, launchOpts, emptyCallback)
-
-  def run(resourceBaseDirectory: File, bufferLog: Boolean, tests: Array[String], logger: AbstractLogger, bootProperties: File,
-    launchOpts: Array[String], prescripted: File => Unit): Unit = {
-    val runner = new ScriptedTests(resourceBaseDirectory, bufferLog, bootProperties, launchOpts)
-    val allTests = get(tests, resourceBaseDirectory, logger) flatMap {
-      case ScriptedTest(group, name) =>
-        runner.scriptedTest(group, name, prescripted, logger)
-    }
-    runAll(allTests)
-  }
-  def runAll(tests: Seq[() => Option[String]]): Unit = {
-    val errors = for (test <- tests; err <- test()) yield err
-    if (errors.nonEmpty)
-      sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n"))
-  }
-  def get(tests: Seq[String], baseDirectory: File, log: Logger): Seq[ScriptedTest] =
-    if (tests.isEmpty) listTests(baseDirectory, log) else parseTests(tests)
-  def listTests(baseDirectory: File, log: Logger): Seq[ScriptedTest] =
-    (new ListTests(baseDirectory, _ => true, log)).listTests
-  def parseTests(in: Seq[String]): Seq[ScriptedTest] =
-    for (testString <- in) yield {
-      val Array(group, name) = testString.split("/").map(_.trim)
-      ScriptedTest(group, name)
-    }
-}
-
-final case class ScriptedTest(group: String, name: String) {
-  override def toString = group + "/" + name
-}
-private[test] object ListTests {
-  def list(directory: File, filter: java.io.FileFilter) = wrapNull(directory.listFiles(filter))
-}
-import ListTests._
-private[test] final class ListTests(baseDirectory: File, accept: ScriptedTest => Boolean, log: Logger) {
-  def filter = DirectoryFilter -- HiddenFileFilter
-  def listTests: Seq[ScriptedTest] =
-    {
-      list(baseDirectory, filter) flatMap { group =>
-        val groupName = group.getName
-        listTests(group).map(ScriptedTest(groupName, _))
-      }
-    }
-  private[this] def listTests(group: File): Set[String] =
-    {
-      val groupName = group.getName
-      val allTests = list(group, filter)
-      if (allTests.isEmpty) {
-        log.warn("No tests in test group " + groupName)
-        Set.empty
-      } else {
-        val (included, skipped) = allTests.toList.partition(test => accept(ScriptedTest(groupName, test.getName)))
-        if (included.isEmpty)
-          log.warn("Test group " + groupName + " skipped.")
-        else if (skipped.nonEmpty) {
-          log.warn("Tests skipped in group " + group.getName + ":")
-          skipped.foreach(testName => log.warn(" " + testName.getName))
-        }
-        Set(included.map(_.getName): _*)
-      }
-    }
-}
-
-object CompatibilityLevel extends Enumeration {
-  val Full, Basic, Minimal, Minimal27, Minimal28 = Value
-
-  def defaultVersions(level: Value) =
-    level match {
-      case Full      => "2.7.4 2.7.7 2.9.0.RC1 2.8.0 2.8.1"
-      case Basic     => "2.7.7 2.7.4 2.8.1 2.8.0"
-      case Minimal   => "2.7.7 2.8.1"
-      case Minimal27 => "2.7.7"
-      case Minimal28 => "2.8.1"
-    }
-}
-class PendingTestSuccessException(label: String) extends Exception {
-  override def getMessage: String =
-    s"The pending test $label succeeded. Mark this test as passing to remove this failure."
-}
diff --git a/server-test/src/server-test/buildserver/build.sbt b/server-test/src/server-test/buildserver/build.sbt
new file mode 100644
index 000000000..e1a151256
--- /dev/null
+++ b/server-test/src/server-test/buildserver/build.sbt
@@ -0,0 +1,18 @@
+ThisBuild / scalaVersion := "2.13.1"
+
+Global / serverLog / logLevel := Level.Debug
+
+lazy val runAndTest = project.in(file("run-and-test"))
+  .settings(
+    libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.8" % "test",
+  )
+  .dependsOn(util)
+
+lazy val reportError = project.in(file("report-error"))
+
+lazy val reportWarning = project.in(file("report-warning"))
+  .settings(
+    scalacOptions += "-deprecation"
+  )
+
+lazy val util = project
diff --git a/server-test/src/server-test/buildserver/report-error/src/main/scala/reporterror/Error.scala b/server-test/src/server-test/buildserver/report-error/src/main/scala/reporterror/Error.scala
new file mode 100644
index 000000000..496e48b8e
--- /dev/null
+++ b/server-test/src/server-test/buildserver/report-error/src/main/scala/reporterror/Error.scala
@@ -0,0 +1,5 @@
+package reportertests
+
+object Error {
+  val version: String = 5
+}
diff --git a/server-test/src/server-test/buildserver/report-warning/src/main/scala/reportwarning/Warning.scala b/server-test/src/server-test/buildserver/report-warning/src/main/scala/reportwarning/Warning.scala
new file mode 100644
index 000000000..6a9554a70
--- /dev/null
+++ b/server-test/src/server-test/buildserver/report-warning/src/main/scala/reportwarning/Warning.scala
@@ -0,0 +1,7 @@
+package reportertests
+
+object Warning {
+  def print() {
+    prtinln("bar")
+  }
+}
diff --git a/server-test/src/server-test/buildserver/run-and-test/src/main/scala/main/Main.scala b/server-test/src/server-test/buildserver/run-and-test/src/main/scala/main/Main.scala
new file mode 100644
index 000000000..8ccc2eb6c
--- /dev/null
+++ b/server-test/src/server-test/buildserver/run-and-test/src/main/scala/main/Main.scala
@@ -0,0 +1,7 @@
+package main
+
+object Main extends App {
+  lazy val message = "Hello World!"
+
+  println(message)
+}
diff --git a/server-test/src/server-test/buildserver/run-and-test/src/test/scala/tests/FailingTest.scala b/server-test/src/server-test/buildserver/run-and-test/src/test/scala/tests/FailingTest.scala
new file mode 100644
index 000000000..ee03bfbb4
--- /dev/null
+++ b/server-test/src/server-test/buildserver/run-and-test/src/test/scala/tests/FailingTest.scala
@@ -0,0 +1,9 @@
+package tests
+
+import org.scalatest.FreeSpec
+
+class FailingTest extends FreeSpec {
+  "it should fail" in {
+    throw new Exception("Test failed")
+  }
+}
\ No newline at end of file
diff --git a/server-test/src/server-test/buildserver/run-and-test/src/test/scala/tests/PassingTest.scala b/server-test/src/server-test/buildserver/run-and-test/src/test/scala/tests/PassingTest.scala
new file mode 100644
index 000000000..9dab63ca9
--- /dev/null
+++ b/server-test/src/server-test/buildserver/run-and-test/src/test/scala/tests/PassingTest.scala
@@ -0,0 +1,9 @@
+package tests
+
+import org.scalatest.FreeSpec
+
+class PassingTest extends FreeSpec {
+  "test message" in {
+    assert(main.Main.message == "Hello World!")
+  }
+}
\ No newline at end of file
diff --git a/server-test/src/server-test/client/build.sbt b/server-test/src/server-test/client/build.sbt
new file mode 100644
index 000000000..3225bd76d
--- /dev/null
+++ b/server-test/src/server-test/client/build.sbt
@@ -0,0 +1,7 @@
+TaskKey[Unit]("willSucceed") := println("success")
+
+TaskKey[Unit]("willFail") := { throw new Exception("failed") }
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.8" % "test"
+
+TaskKey[Unit]("fooBar") := { () }
diff --git a/server-test/src/server-test/client/src/main/scala/A.scala b/server-test/src/server-test/client/src/main/scala/A.scala
new file mode 100644
index 000000000..69c493db2
--- /dev/null
+++ b/server-test/src/server-test/client/src/main/scala/A.scala
@@ -0,0 +1 @@
+object A
diff --git a/server-test/src/server-test/client/src/test/scala/FooSpec.scala b/server-test/src/server-test/client/src/test/scala/FooSpec.scala
new file mode 100644
index 000000000..269be5624
--- /dev/null
+++ b/server-test/src/server-test/client/src/test/scala/FooSpec.scala
@@ -0,0 +1,3 @@
+package test.pkg
+
+class FooSpec extends org.scalatest.FlatSpec
diff --git a/server-test/src/server-test/completions/build.sbt b/server-test/src/server-test/completions/build.sbt
new file mode 100644
index 000000000..90de9d529
--- /dev/null
+++ b/server-test/src/server-test/completions/build.sbt
@@ -0,0 +1,4 @@
+
+val hello = taskKey[Unit]("Say hello")
+
+hello := {}
diff --git a/server-test/src/server-test/completions/target/streams/test/_global/_global/definedTestNames/data b/server-test/src/server-test/completions/target/streams/test/_global/_global/definedTestNames/data
new file mode 100644
index 000000000..5236a9ab6
--- /dev/null
+++ b/server-test/src/server-test/completions/target/streams/test/_global/_global/definedTestNames/data
@@ -0,0 +1 @@
+["org.sbt.ExampleSpec"]
\ No newline at end of file
diff --git a/server-test/src/server-test/events/Main.scala b/server-test/src/server-test/events/Main.scala
new file mode 100644
index 000000000..6030b2602
--- /dev/null
+++ b/server-test/src/server-test/events/Main.scala
@@ -0,0 +1,6 @@
+object Main extends App {
+
+  try this.synchronized(this.wait)
+  catch { case _: InterruptedException => }
+
+}
diff --git a/server-test/src/server-test/events/build.sbt b/server-test/src/server-test/events/build.sbt
new file mode 100644
index 000000000..b31ca73aa
--- /dev/null
+++ b/server-test/src/server-test/events/build.sbt
@@ -0,0 +1,4 @@
+
+commands += Command.command("hello") { state => ??? }
+
+Global / cancelable := true
diff --git a/server-test/src/server-test/handshake/build.sbt b/server-test/src/server-test/handshake/build.sbt
new file mode 100644
index 000000000..94869c925
--- /dev/null
+++ b/server-test/src/server-test/handshake/build.sbt
@@ -0,0 +1,20 @@
+import sbt.internal.server.{ ServerHandler, ServerIntent }
+
+ThisBuild / scalaVersion := "2.12.12"
+
+lazy val root = (project in file("."))
+  .settings(
+    Global / serverLog / logLevel := Level.Debug,
+    // custom handler
+    Global / serverHandlers += ServerHandler({ callback =>
+      import callback._
+      import sjsonnew.BasicJsonProtocol._
+      import sbt.internal.protocol.JsonRpcRequestMessage
+      ServerIntent.request {
+        case r: JsonRpcRequestMessage if r.method == "lunar/helo" =>
+          jsonRpcNotify("lunar/oleh", "")
+          ()
+      }
+    }),
+    name := "handshake",
+  )
diff --git a/server-test/src/server-test/response/build.sbt b/server-test/src/server-test/response/build.sbt
new file mode 100644
index 000000000..f75670640
--- /dev/null
+++ b/server-test/src/server-test/response/build.sbt
@@ -0,0 +1,73 @@
+import sbt.internal.server.{ ServerHandler, ServerIntent }
+
+ThisBuild / scalaVersion := "2.12.13"
+
+Global / serverLog / logLevel := Level.Debug
+// custom handler
+Global / serverHandlers += ServerHandler({ callback =>
+  import callback._
+  import sjsonnew.BasicJsonProtocol._
+  import sbt.internal.protocol.JsonRpcRequestMessage
+  ServerIntent(
+    onRequest = {
+      case r: JsonRpcRequestMessage if r.method == "foo/export" =>
+        appendExec(Exec("fooExport", Some(r.id), Some(CommandSource(callback.name))))
+        ()
+      case r: JsonRpcRequestMessage if r.method == "foo/fail" =>
+        appendExec(Exec("fooFail", Some(r.id), Some(CommandSource(callback.name))))
+        ()
+      case r: JsonRpcRequestMessage if r.method == "foo/customfail" =>
+        appendExec(Exec("fooCustomFail", Some(r.id), Some(CommandSource(callback.name))))
+        ()
+      case r: JsonRpcRequestMessage if r.method == "foo/notification" =>
+        appendExec(Exec("fooNotification", Some(r.id), Some(CommandSource(callback.name))))
+        ()
+      case r: JsonRpcRequestMessage if r.method == "foo/rootClasspath" =>
+        appendExec(Exec("fooClasspath", Some(r.id), Some(CommandSource(callback.name))))
+        ()
+      case r if r.method == "foo/respondTwice" =>
+        appendExec(Exec("fooClasspath", Some(r.id), Some(CommandSource(callback.name))))
+        jsonRpcRespond("concurrent response", Some(r.id))
+        ()
+      case r if r.method == "foo/resultAndError" =>
+        appendExec(Exec("fooCustomFail", Some(r.id), Some(CommandSource(callback.name))))
+        jsonRpcRespond("concurrent response", Some(r.id))
+        ()
+    },
+    onResponse = PartialFunction.empty,
+    onNotification = {
+      case r if r.method == "foo/customNotification" =>
+        jsonRpcRespond("notification result", None)
+        ()
+    }
+  )
+})
+
+lazy val fooClasspath = taskKey[Unit]("")
+
+lazy val root = (project in file("."))
+  .settings(
+    name := "response",
+    commands += Command.command("fooExport") { s0: State =>
+      val (s1, cp) = s0.unsafeRunTask(Compile / fullClasspath)
+      s0.respondEvent(cp.map(_.data))
+      s1
+    },
+    commands += Command.command("fooFail") { s0: State =>
+      sys.error("fail message")
+    },
+    commands += Command.command("fooCustomFail") { s0: State =>
+      import sbt.internal.protocol.JsonRpcResponseError
+      throw JsonRpcResponseError(500, "some error")
+    },
+    commands += Command.command("fooNotification") { s0: State =>
+      import CacheImplicits._
+      s0.notifyEvent("foo/something", "something")
+      s0
+    },
+    fooClasspath := {
+      val s = state.value
+      val cp = (Compile / fullClasspath).value
+      s.respondEvent(cp.map(_.data))
+    }
+  )
diff --git a/server-test/src/test/scala/sbt/ReadJson.scala b/server-test/src/test/scala/sbt/ReadJson.scala
new file mode 100644
index 000000000..6b2fd14a1
--- /dev/null
+++ b/server-test/src/test/scala/sbt/ReadJson.scala
@@ -0,0 +1,16 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+
+import java.util.concurrent.atomic.AtomicBoolean
+import java.io.InputStream
+
+object ReadJson {
+  def apply(in: InputStream, running: AtomicBoolean): String =
+    new String(sbt.internal.util.ReadJsonFromInputStream(in, running, None).toArray, "UTF-8")
+}
diff --git a/server-test/src/test/scala/testpkg/BuildServerTest.scala b/server-test/src/test/scala/testpkg/BuildServerTest.scala
new file mode 100644
index 000000000..e4c42c4fd
--- /dev/null
+++ b/server-test/src/test/scala/testpkg/BuildServerTest.scala
@@ -0,0 +1,224 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import scala.concurrent.duration._
+
+// starts svr using server-test/buildserver and perform custom server tests
+object BuildServerTest extends AbstractServerTest {
+  override val testDirectory: String = "buildserver"
+
+  test("build/initialize") { _ =>
+    initializeRequest()
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"id":"10""""
+    })
+  }
+
+  test("workspace/buildTargets") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "11", "method": "workspace/buildTargets", "params": {} }"""
+    )
+    assert(processing("workspace/buildTargets"))
+    assert {
+      svr.waitForString(10.seconds) { s =>
+        (s contains """"id":"11"""") &&
+        (s contains """"displayName":"util"""")
+      }
+    }
+  }
+
+  test("buildTarget/sources") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#util/Compile"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "12", "method": "buildTarget/sources", "params": {
+        |  "targets": [{ "uri": "$x" }]
+        |} }""".stripMargin
+    )
+    assert(processing("buildTarget/sources"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"12"""") &&
+      (s contains "util/src/main/scala")
+    })
+  }
+
+  test("buildTarget/compile") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#util/Compile"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "13", "method": "buildTarget/compile", "params": {
+         |  "targets": [{ "uri": "$x" }]
+         |} }""".stripMargin
+    )
+    assert(processing("buildTarget/compile"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"13"""") &&
+      (s contains """"statusCode":1""")
+    })
+  }
+
+  test("buildTarget/scalacOptions") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#util/Compile"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "14", "method": "buildTarget/scalacOptions", "params": {
+        |  "targets": [{ "uri": "$x" }]
+        |} }""".stripMargin
+    )
+    assert(processing("buildTarget/scalacOptions"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"14"""") &&
+      (s contains "scala-library-2.13.1.jar")
+    })
+  }
+
+  test("workspace/reload") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "15", "method": "workspace/reload"}"""
+    )
+    assert(processing("workspace/reload"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"15"""") &&
+      (s contains """"result":null""")
+    })
+  }
+
+  test("buildTarget/scalaMainClasses") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#runAndTest/Compile"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "16", "method": "buildTarget/scalaMainClasses", "params": {
+         |  "targets": [{ "uri": "$x" }]
+         |} }""".stripMargin
+    )
+    assert(processing("buildTarget/scalaMainClasses"))
+    assert(svr.waitForString(30.seconds) { s =>
+      (s contains """"id":"16"""") &&
+      (s contains """"class":"main.Main"""")
+    })
+  }
+
+  test("buildTarget/run") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#runAndTest/Compile"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "17", "method": "buildTarget/run", "params": {
+         |  "target": { "uri": "$x" },
+         |  "dataKind": "scala-main-class",
+         |  "data": { "class": "main.Main" }
+         |} }""".stripMargin
+    )
+    assert(processing("buildTarget/run"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains "build/logMessage") &&
+      (s contains """"message":"Hello World!"""")
+    })
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"17"""") &&
+      (s contains """"statusCode":1""")
+    })
+  }
+
+  test("buildTarget/scalaTestClasses") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#runAndTest/Test"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "18", "method": "buildTarget/scalaTestClasses", "params": {
+         |  "targets": [{ "uri": "$x" }]
+         |} }""".stripMargin
+    )
+    assert(processing("buildTarget/scalaTestClasses"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"18"""") &&
+      (s contains """"tests.FailingTest"""") &&
+      (s contains """"tests.PassingTest"""")
+    })
+  }
+
+  test("buildTarget/test: run all tests") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#runAndTest/Test"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "19", "method": "buildTarget/test", "params": {
+         |  "targets": [{ "uri": "$x" }]
+         |} }""".stripMargin
+    )
+    assert(processing("buildTarget/test"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"19"""") &&
+      (s contains """"statusCode":2""")
+    })
+  }
+
+  test("buildTarget/test: run one test class") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#runAndTest/Test"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "20", "method": "buildTarget/test", "params": {
+         |  "targets": [{ "uri": "$x" }],
+         |  "dataKind": "scala-test",
+         |  "data": {
+         |    "testClasses": [
+         |      {
+         |        "target": { "uri": "$x" },
+         |        "classes": ["tests.PassingTest"]
+         |      }
+         |    ]
+         |  }
+         |} }""".stripMargin
+    )
+    assert(processing("buildTarget/test"))
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains """"id":"20"""") &&
+      (s contains """"statusCode":1""")
+    })
+  }
+
+  test("buildTarget/compile: report error") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#reportError/Compile"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "21", "method": "buildTarget/compile", "params": {
+         |  "targets": [{ "uri": "$x" }]
+         |} }""".stripMargin
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains s""""buildTarget":{"uri":"$x"}""") &&
+      (s contains """"severity":1""") &&
+      (s contains """"reset":true""")
+    })
+  }
+
+  test("buildTarget/compile: report warning") { _ =>
+    val x = s"${svr.baseDirectory.getAbsoluteFile.toURI}#reportWarning/Compile"
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "22", "method": "buildTarget/compile", "params": {
+         |  "targets": [{ "uri": "$x" }]
+         |} }""".stripMargin
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains s""""buildTarget":{"uri":"$x"}""") &&
+      (s contains """"severity":2""") &&
+      (s contains """"reset":true""")
+    })
+  }
+
+  private def initializeRequest(): Unit = {
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "10", "method": "build/initialize",
+        |  "params": {
+        |    "displayName": "test client",
+        |    "version": "1.0.0",
+        |    "bspVersion": "2.0.0-M5",
+        |    "rootUri": "file://root/",
+        |    "capabilities": { "languageIds": ["scala"] }
+        |  }
+        |}""".stripMargin
+    )
+  }
+
+  private def processing(method: String, debug: Boolean = false): Boolean = {
+    svr.waitForString(10.seconds) { msg =>
+      if (debug) println(msg)
+      msg.contains("build/logMessage") &&
+      msg.contains(s""""message":"Processing $method"""")
+    }
+  }
+}
diff --git a/server-test/src/test/scala/testpkg/ClientTest.scala b/server-test/src/test/scala/testpkg/ClientTest.scala
new file mode 100644
index 000000000..e03bd8a11
--- /dev/null
+++ b/server-test/src/test/scala/testpkg/ClientTest.scala
@@ -0,0 +1,145 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import java.io.{ InputStream, OutputStream, PrintStream }
+import java.util.concurrent.{ LinkedBlockingQueue, TimeUnit, TimeoutException }
+import sbt.internal.client.NetworkClient
+import sbt.internal.util.Util
+import scala.collection.mutable
+
+object ClientTest extends AbstractServerTest {
+  override val testDirectory: String = "client"
+  object NullInputStream extends InputStream {
+    override def read(): Int = {
+      try this.synchronized(this.wait)
+      catch { case _: InterruptedException => }
+      -1
+    }
+  }
+  val NullPrintStream = new PrintStream(_ => {}, false)
+  class CachingPrintStream extends { val cos = new CachingOutputStream }
+  with PrintStream(cos, true) {
+    def lines = cos.lines
+  }
+  class CachingOutputStream extends OutputStream {
+    private val byteBuffer = new mutable.ArrayBuffer[Byte]
+    override def write(i: Int) = Util.ignoreResult(byteBuffer += i.toByte)
+    def lines = new String(byteBuffer.toArray, "UTF-8").linesIterator.toSeq
+  }
+  class FixedInputStream(keys: Char*) extends InputStream {
+    var i = 0
+    override def read(): Int = {
+      if (i < keys.length) {
+        val res = keys(i).toInt
+        i += 1
+        res
+      } else -1
+    }
+  }
+  private[this] def background[R](f: => R): R = {
+    val result = new LinkedBlockingQueue[R]
+    val thread = new Thread("client-bg-thread") {
+      setDaemon(true)
+      start()
+      override def run(): Unit = result.put(f)
+    }
+    result.poll(1, TimeUnit.MINUTES) match {
+      case null =>
+        thread.interrupt()
+        thread.join(5000)
+        throw new TimeoutException
+      case r => r
+    }
+  }
+  private def client(args: String*): Int = {
+    background(
+      NetworkClient.client(
+        testPath.toFile,
+        args.toArray,
+        NullInputStream,
+        NullPrintStream,
+        NullPrintStream,
+        false
+      )
+    )
+  }
+  // This ensures that the completion command will send a tab that triggers
+  // sbt to call definedTestNames or discoveredMainClasses if there hasn't
+  // been a necessary compilation
+  def tabs = new FixedInputStream('\t', '\t')
+  private def complete(completionString: String): Seq[String] = {
+    val cps = new CachingPrintStream
+    background(
+      NetworkClient.complete(
+        testPath.toFile,
+        Array(s"--completions=sbtn $completionString"),
+        false,
+        tabs,
+        cps
+      )
+    )
+    cps.lines
+  }
+  test("exit success") { c =>
+    assert(client("willSucceed") == 0)
+  }
+  test("exit failure") { _ =>
+    assert(client("willFail") == 1)
+  }
+  test("two commands") { _ =>
+    assert(client("compile;willSucceed") == 0)
+  }
+  test("two commands with failing second") { _ =>
+    assert(client("compile;willFail") == 1)
+  }
+  test("two commands with leading failure") { _ =>
+    assert(client("willFail;willSucceed") == 1)
+  }
+  test("three commands") { _ =>
+    assert(client("compile;clean;willSucceed") == 0)
+  }
+  test("three commands with middle failure") { _ =>
+    assert(client("compile;willFail;willSucceed") == 1)
+  }
+  test("compi completions") { _ =>
+    val expected = Vector(
+      "compile",
+      "compile:",
+      "compileAnalysisFile",
+      "compileAnalysisFilename",
+      "compileAnalysisTargetRoot",
+      "compileEarly",
+      "compileIncSetup",
+      "compileIncremental",
+      "compileJava",
+      "compileOutputs",
+      "compileProgress",
+      "compileScalaBackend",
+      "compileSplit",
+      "compilers",
+    )
+
+    assert(complete("compi") == expected)
+  }
+  test("testOnly completions") { _ =>
+    val testOnlyExpected = Vector(
+      "testOnly",
+      "testOnly/",
+      "testOnly::",
+      "testOnly;",
+    )
+    assert(complete("testOnly") == testOnlyExpected)
+
+    val testOnlyOptionsExpected = Vector("--", ";", "test.pkg.FooSpec")
+    assert(complete("testOnly ") == testOnlyOptionsExpected)
+  }
+  test("quote with semi") { _ =>
+    assert(complete("\"compile; fooB") == Vector("compile; fooBar"))
+  }
+}
diff --git a/server-test/src/test/scala/testpkg/EventsTest.scala b/server-test/src/test/scala/testpkg/EventsTest.scala
new file mode 100644
index 000000000..aebde3f95
--- /dev/null
+++ b/server-test/src/test/scala/testpkg/EventsTest.scala
@@ -0,0 +1,92 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import scala.concurrent.duration._
+import java.util.concurrent.atomic.AtomicInteger
+
+// starts svr using server-test/events and perform event related tests
+object EventsTest extends AbstractServerTest {
+  override val testDirectory: String = "events"
+  val currentID = new AtomicInteger(0)
+
+  test("report task failures in case of exceptions") { _ =>
+    val id = currentID.getAndIncrement()
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": $id, "method": "sbt/exec", "params": { "commandLine": "hello" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      (s contains s""""id":$id""") && (s contains """"error":""")
+    })
+  }
+
+  test("return error if cancelling non-matched task id") { _ =>
+    val id = currentID.getAndIncrement()
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id":$id, "method": "sbt/exec", "params": { "commandLine": "run" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains "Waiting for"
+    })
+    val cancelID = currentID.getAndIncrement()
+    val invalidID = currentID.getAndIncrement()
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id":$cancelID, "method": "sbt/cancelRequest", "params": { "id": "$invalidID" } }"""
+    )
+    assert(svr.waitForString(20.seconds) { s =>
+      (s contains """"error":{"code":-32800""")
+    })
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id":${currentID.getAndIncrement}, "method": "sbt/cancelRequest", "params": { "id": "$id" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"result":{"status":"Task cancelled""""
+    })
+  }
+
+  test("cancel on-going task with numeric id") { _ =>
+    val id = currentID.getAndIncrement()
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id":$id, "method": "sbt/exec", "params": { "commandLine": "run" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains "Compiled events"
+    })
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains "Waiting for"
+    })
+    val cancelID = currentID.getAndIncrement()
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id":$cancelID, "method": "sbt/cancelRequest", "params": { "id": "$id" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"result":{"status":"Task cancelled""""
+    })
+  }
+
+  test("cancel on-going task with string id") { _ =>
+    import sbt.Exec
+    val id = Exec.newExecId
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "$id", "method": "sbt/exec", "params": { "commandLine": "run" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains "Compiled events"
+    })
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains "Waiting for"
+    })
+    val cancelID = Exec.newExecId
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": "$cancelID", "method": "sbt/cancelRequest", "params": { "id": "$id" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"result":{"status":"Task cancelled""""
+    })
+  }
+}
diff --git a/server-test/src/test/scala/testpkg/HandshakeTest.scala b/server-test/src/test/scala/testpkg/HandshakeTest.scala
new file mode 100644
index 000000000..da5fea172
--- /dev/null
+++ b/server-test/src/test/scala/testpkg/HandshakeTest.scala
@@ -0,0 +1,33 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import scala.concurrent.duration._
+
+// starts svr using server-test/handshake and perform basic tests
+object HandshakeTest extends AbstractServerTest {
+  override val testDirectory: String = "handshake"
+
+  test("handshake") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "3", "method": "sbt/setting", "params": { "setting": "root/name" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"id":"3""""
+    })
+  }
+
+  test("return number id when number id is sent") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": 3, "method": "sbt/setting", "params": { "setting": "root/name" } }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"id":3"""
+    })
+  }
+}
diff --git a/server-test/src/test/scala/testpkg/ResponseTest.scala b/server-test/src/test/scala/testpkg/ResponseTest.scala
new file mode 100644
index 000000000..23d0f2e16
--- /dev/null
+++ b/server-test/src/test/scala/testpkg/ResponseTest.scala
@@ -0,0 +1,117 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import scala.concurrent.duration._
+
+// starts svr using server-test/response and perform custom server tests
+object ResponseTest extends AbstractServerTest {
+  override val testDirectory: String = "response"
+
+  test("response from a command") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "10", "method": "foo/export", "params": {} }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      if (!s.contains("systemOut")) println(s)
+      (s contains """"id":"10"""") &&
+      (s contains "scala-library.jar")
+    })
+  }
+
+  test("response from a task") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "11", "method": "foo/rootClasspath", "params": {} }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      if (!s.contains("systemOut")) println(s)
+      (s contains """"id":"11"""") &&
+      (s contains "scala-library.jar")
+    })
+  }
+
+  test("a command failure") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "12", "method": "foo/fail", "params": {} }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      if (!s.contains("systemOut")) println(s)
+      (s contains """"error":{"code":-33000,"message":"fail message"""")
+    })
+  }
+
+  test("a command failure with custom code") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "13", "method": "foo/customfail", "params": {} }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      if (!s.contains("systemOut")) println(s)
+      (s contains """"error":{"code":500,"message":"some error"""")
+    })
+  }
+
+  test("a command with a notification") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "14", "method": "foo/notification", "params": {} }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      if (!s.contains("systemOut")) println(s)
+      (s contains """{"jsonrpc":"2.0","method":"foo/something","params":"something"}""")
+    })
+  }
+
+  test("respond concurrently from a task and the handler") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "15", "method": "foo/respondTwice", "params": {} }"""
+    )
+    assert {
+      svr.waitForString(10.seconds) { s =>
+        if (!s.contains("systemOut")) println(s)
+        s contains "\"id\":\"15\""
+      }
+    }
+    assert {
+      // the second response should never be sent
+      svr.neverReceive(500.milliseconds) { s =>
+        if (!s.contains("systemOut")) println(s)
+        s contains "\"id\":\"15\""
+      }
+    }
+  }
+
+  test("concurrent result and error") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "id": "16", "method": "foo/resultAndError", "params": {} }"""
+    )
+    assert {
+      svr.waitForString(10.seconds) { s =>
+        if (!s.contains("systemOut")) println(s)
+        s contains "\"id\":\"16\""
+      }
+    }
+    assert {
+      // the second response (result or error) should never be sent
+      svr.neverReceive(500.milliseconds) { s =>
+        if (!s.contains("systemOut")) println(s)
+        s contains "\"id\":\"16\""
+      }
+    }
+  }
+
+  test("response to a notification should not be sent") { _ =>
+    svr.sendJsonRpc(
+      """{ "jsonrpc": "2.0", "method": "foo/customNotification", "params": {} }"""
+    )
+    assert {
+      svr.neverReceive(500.milliseconds) { s =>
+        if (!s.contains("systemOut")) println(s)
+        s contains "\"result\":\"notification result\""
+      }
+    }
+  }
+}
diff --git a/server-test/src/test/scala/testpkg/ServerCompletionsTest.scala b/server-test/src/test/scala/testpkg/ServerCompletionsTest.scala
new file mode 100644
index 000000000..30701f58d
--- /dev/null
+++ b/server-test/src/test/scala/testpkg/ServerCompletionsTest.scala
@@ -0,0 +1,46 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import scala.concurrent.duration._
+
+// starts svr using server-test/completions and perform sbt/completion tests
+object ServerCompletionsTest extends AbstractServerTest {
+  override val testDirectory: String = "completions"
+
+  test("return basic completions on request") { _ =>
+    val completionStr = """{ "query": "" }"""
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": 15, "method": "sbt/completion", "params": $completionStr }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      println(s)
+      s contains """"result":{"items":["""
+    })
+  }
+
+  test("return completion for custom tasks") { _ =>
+    val completionStr = """{ "query": "hell" }"""
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": 16, "method": "sbt/completion", "params": $completionStr }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"result":{"items":["hello"]"""
+    })
+  }
+
+  test("return completions for user classes") { _ =>
+    val completionStr = """{ "query": "testOnly org." }"""
+    svr.sendJsonRpc(
+      s"""{ "jsonrpc": "2.0", "id": 17, "method": "sbt/completion", "params": $completionStr }"""
+    )
+    assert(svr.waitForString(10.seconds) { s =>
+      s contains """"result":{"items":["testOnly org.sbt.ExampleSpec"]"""
+    })
+  }
+}
diff --git a/server-test/src/test/scala/testpkg/TestServer.scala b/server-test/src/test/scala/testpkg/TestServer.scala
new file mode 100644
index 000000000..b2c6a2f62
--- /dev/null
+++ b/server-test/src/test/scala/testpkg/TestServer.scala
@@ -0,0 +1,308 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package testpkg
+
+import java.io.{ File, IOException }
+import java.net.Socket
+import java.nio.file.{ Files, Path }
+import java.util.concurrent.{ LinkedBlockingQueue, TimeUnit }
+import java.util.concurrent.atomic.AtomicBoolean
+
+import verify._
+import sbt.{ ForkOptions, OutputStrategy, RunFromSourceMain }
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.protocol.ClientSocket
+
+import scala.annotation.tailrec
+import scala.concurrent._
+import scala.concurrent.duration._
+import scala.util.{ Success, Try }
+
+trait AbstractServerTest extends TestSuite[Unit] {
+  private var temp: File = _
+  var svr: TestServer = _
+  def testDirectory: String
+  def testPath: Path = temp.toPath.resolve(testDirectory)
+
+  private val targetDir: File = {
+    val p0 = new File("..").getAbsoluteFile.getCanonicalFile / "target"
+    val p1 = new File("target").getAbsoluteFile
+    if (p0.exists) p0
+    else p1
+  }
+
+  override def setupSuite(): Unit = {
+    val base = Files.createTempDirectory(
+      Files.createDirectories(targetDir.toPath.resolve("test-server")),
+      "server-test"
+    )
+    temp = base.toFile
+    val classpath = TestProperties.classpath.split(File.pathSeparator).map(new File(_))
+    val sbtVersion = TestProperties.version
+    val scalaVersion = TestProperties.scalaVersion
+    svr = TestServer.get(testDirectory, scalaVersion, sbtVersion, classpath, temp)
+  }
+  override def tearDownSuite(): Unit = {
+    svr.bye()
+    svr = null
+    IO.delete(temp)
+  }
+  override def setup(): Unit = ()
+  override def tearDown(env: Unit): Unit = ()
+}
+
+object TestServer {
+  // forking affects this
+  private val serverTestBase: File = {
+    val p0 = new File(".").getAbsoluteFile / "server-test" / "src" / "server-test"
+    val p1 = new File(".").getAbsoluteFile / "src" / "server-test"
+    if (p0.exists) p0
+    else p1
+  }
+
+  def get(
+      testBuild: String,
+      scalaVersion: String,
+      sbtVersion: String,
+      classpath: Seq[File],
+      temp: File
+  ): TestServer = {
+    println(s"Starting test server $testBuild")
+    IO.copyDirectory(serverTestBase / testBuild, temp / testBuild)
+
+    // Each test server instance will be executed in a Thread pool separated from the tests
+    val testServer = TestServer(temp / testBuild, scalaVersion, sbtVersion, classpath)
+    // checking last log message after initialization
+    // if something goes wrong here the communication streams are corrupted, restarting
+    val init =
+      Try {
+        testServer.waitForString(10.seconds) { s =>
+          println(s)
+          s contains """"capabilities":{""""
+        }
+      }
+    init.get
+    testServer
+  }
+
+  def withTestServer(
+      testBuild: String
+  )(f: TestServer => Future[Unit]): Future[Unit] = {
+    println(s"Starting test")
+    IO.withTemporaryDirectory { temp =>
+      IO.copyDirectory(serverTestBase / testBuild, temp / testBuild)
+      withTestServer(testBuild, temp / testBuild)(f)
+    }
+  }
+
+  def withTestServer(testBuild: String, baseDirectory: File)(
+      f: TestServer => Future[Unit]
+  ): Future[Unit] = {
+    val classpath = sys.props.get("sbt.server.classpath") match {
+      case Some(s: String) => s.split(java.io.File.pathSeparator).map(file)
+      case _               => throw new IllegalStateException("No server classpath was specified.")
+    }
+    val sbtVersion = sys.props.get("sbt.server.version") match {
+      case Some(v: String) => v
+      case _               => throw new IllegalStateException("No server version was specified.")
+    }
+    val scalaVersion = sys.props.get("sbt.server.scala.version") match {
+      case Some(v: String) => v
+      case _               => throw new IllegalStateException("No server scala version was specified.")
+    }
+    // Each test server instance will be executed in a Thread pool separated from the tests
+    val testServer = TestServer(baseDirectory, scalaVersion, sbtVersion, classpath)
+    // checking last log message after initialization
+    // if something goes wrong here the communication streams are corrupted, restarting
+    val init =
+      Try {
+        testServer.waitForString(10.seconds) { s =>
+          if (s.nonEmpty) println(s)
+          s contains """"capabilities":{""""
+        }
+      }
+
+    init match {
+      case Success(_) =>
+        try {
+          f(testServer)
+        } finally {
+          try {
+            testServer.bye()
+          } finally {}
+        }
+      case _ =>
+        try {
+          testServer.bye()
+        } finally {}
+        hostLog("Server started but not connected properly... restarting...")
+        withTestServer(testBuild)(f)
+    }
+  }
+
+  def hostLog(s: String): Unit = {
+    println(s"""[${scala.Console.MAGENTA}build-1${scala.Console.RESET}] $s""")
+  }
+}
+
+case class TestServer(
+    baseDirectory: File,
+    scalaVersion: String,
+    sbtVersion: String,
+    classpath: Seq[File]
+) {
+  import TestServer.hostLog
+
+  hostLog("fork to a new sbt instance")
+  val forkOptions =
+    ForkOptions()
+      .withOutputStrategy(OutputStrategy.StdoutOutput)
+      .withRunJVMOptions(Vector("-Djline.terminal=none", "-Dsbt.io.virtual=false"))
+  val process =
+    RunFromSourceMain.fork(forkOptions, baseDirectory, scalaVersion, sbtVersion, classpath)
+
+  lazy val portfile = baseDirectory / "project" / "target" / "active.json"
+
+  def portfileIsEmpty(): Boolean =
+    try IO.read(portfile).isEmpty
+    catch { case _: IOException => true }
+  def waitForPortfile(duration: FiniteDuration): Unit = {
+    val deadline = duration.fromNow
+    var nextLog = 10.seconds.fromNow
+    while (portfileIsEmpty && !deadline.isOverdue && process.isAlive) {
+      if (nextLog.isOverdue) {
+        hostLog("waiting for the server...")
+        nextLog = 10.seconds.fromNow
+      }
+      Thread.sleep(10) // Don't spam the portfile
+    }
+    if (deadline.isOverdue) sys.error(s"Timeout. $portfile is not found.")
+    if (!process.isAlive) sys.error(s"Server unexpectedly terminated.")
+  }
+  private val waitDuration: FiniteDuration = 1.minute
+  hostLog(s"wait $waitDuration until the server is ready to respond")
+  waitForPortfile(waitDuration)
+
+  @tailrec
+  private def connect(attempt: Int): Socket = {
+    val res = try Some(ClientSocket.socket(portfile)._1)
+    catch { case _: IOException if attempt < 10 => None }
+    res match {
+      case Some(s) => s
+      case _ =>
+        Thread.sleep(100)
+        connect(attempt + 1)
+    }
+  }
+  // make connection to the socket described in the portfile
+  val sk = connect(0)
+  val out = sk.getOutputStream
+  val in = sk.getInputStream
+  private val lines = new LinkedBlockingQueue[String]
+  val running = new AtomicBoolean(true)
+  val readThread =
+    new Thread(() => {
+      while (running.get) {
+        try lines.put(sbt.ReadJson(in, running))
+        catch { case _: Exception => running.set(false) }
+      }
+    }, "sbt-server-test-read-thread") {
+      setDaemon(true)
+      start()
+    }
+
+  // initiate handshake
+  sendJsonRpc(
+    s"""{ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "initializationOptions": { "skipAnalysis": true } } }"""
+  )
+
+  def test(f: TestServer => Future[Assertion]): Future[Assertion] = {
+    f(this)
+  }
+
+  def bye(): Unit =
+    try {
+      running.set(false)
+      hostLog("sending exit")
+      sendJsonRpc(
+        """{ "jsonrpc": "2.0", "id": 9, "method": "sbt/exec", "params": { "commandLine": "shutdown" } }"""
+      )
+      val deadline = 5.seconds.fromNow
+      while (!deadline.isOverdue && process.isAlive) {
+        Thread.sleep(10)
+      }
+      // We gave the server a chance to exit but it didn't within a reasonable time frame.
+      if (deadline.isOverdue && process.isAlive) {
+        process.destroy()
+        val newDeadline = 10.seconds.fromNow
+        while (!newDeadline.isOverdue && process.isAlive) {
+          Thread.sleep(10)
+        }
+      }
+      if (process.isAlive) throw new IllegalStateException(s"process $process failed to exit")
+    } finally {
+      readThread.interrupt()
+      /*
+       * The UnixDomainSocket input stream cannot be closed while a thread is
+       * reading from it (even if the UnixDomainSocket itself is closed):
+       * https://github.com/sbt/ipcsocket/blob/f02d29092f9f0c57e5c4b276a31fa16975ddf66e/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java#L111-L118
+       * This makes it impossible to interrupt the readThread until after the
+       * server process has exited which closes the ServerSocket which does
+       * cause the input stream to be closed. We could change the behavior of
+       * ipcsocket, but that seems risky without knowing exactly why the behavior
+       * exists. For now, ensure that we are able to interrupt and join the
+       * read thread and throw an exception if not.
+       */
+      readThread.join(5000)
+      if (readThread.isAlive) throw new IllegalStateException(s"Unable to join read thread")
+    }
+
+  def sendJsonRpc(message: String): Unit = {
+    writeLine(s"""Content-Length: ${message.size + 2}""")
+    writeLine("")
+    writeLine(message)
+  }
+
+  private def writeLine(s: String): Unit = {
+    def writeEndLine(): Unit = {
+      val retByte: Byte = '\r'.toByte
+      val delimiter: Byte = '\n'.toByte
+      out.write(retByte.toInt)
+      out.write(delimiter.toInt)
+      out.flush
+    }
+
+    if (s != "") {
+      out.write(s.getBytes("UTF-8"))
+    }
+    writeEndLine
+  }
+
+  final def waitForString(duration: FiniteDuration)(f: String => Boolean): Boolean = {
+    val deadline = duration.fromNow
+    @tailrec def impl(): Boolean =
+      lines.poll(deadline.timeLeft.toMillis, TimeUnit.MILLISECONDS) match {
+        case null => false
+        case s    => if (!f(s) && !deadline.isOverdue) impl() else !deadline.isOverdue()
+      }
+    impl()
+  }
+
+  final def neverReceive(duration: FiniteDuration)(f: String => Boolean): Boolean = {
+    val deadline = duration.fromNow
+    @tailrec
+    def impl(): Boolean =
+      lines.poll(deadline.timeLeft.toMillis, TimeUnit.MILLISECONDS) match {
+        case null => true
+        case s    => if (!f(s)) impl() else false
+      }
+    impl()
+  }
+
+}
diff --git a/server.md b/server.md
new file mode 100644
index 000000000..5afbb6f4f
--- /dev/null
+++ b/server.md
@@ -0,0 +1,34 @@
+
+$ cat ~/.sbt/1.0/server/0845deda85cb41abdb9f/token.json
+
+### initialize
+
+```json
+{ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "initializationOptions": { "token": "************" } } }
+```
+
+### sbt/exec
+
+```json
+{ "jsonrpc": "2.0", "id": 1, "method": "sbt/exec", "params": { "commandLine": "compile" } }
+```
+
+### sbt/setting
+
+```json
+{ "jsonrpc": "2.0", "id": 1, "method": "sbt/setting", "params": { "setting": "root/name" } }
+```
+
+Here's an example of a bad query:
+
+```json
+{ "jsonrpc": "2.0", "id": 1, "method": "sbt/setting", "params": { "setting": "name" } }
+```
+
+
+```
+Content-Length: 104
+Content-Type: application/vscode-jsonrpc; charset=utf-8
+
+{"jsonrpc":"2.0","id":"1","error":{"code":-32602,"message":"Not a valid project ID: name\nname\n    ^"}}
+```
diff --git a/src/main/conscript/scalas/launchconfig b/src/main/conscript/scalas/launchconfig
index 0d0d5664c..f972decaf 100644
--- a/src/main/conscript/scalas/launchconfig
+++ b/src/main/conscript/scalas/launchconfig
@@ -4,7 +4,7 @@
 [app]
   org: ${sbt.organization-org.scala-sbt}
   name: sbt
-  version: ${sbt.version-read(sbt.version)[0.13.9]}
+  version: ${sbt.version-read(sbt.version)[1.3.0]}
   class: sbt.ScriptMain
   components: xsbti,extra
   cross-versioned: ${sbt.cross.versioned-false}
@@ -12,12 +12,17 @@
 
 [repositories]
   local
+  local-preloaded-ivy: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext]
+  local-preloaded: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}
   maven-central
+  sbt-maven-releases: https://repo.scala-sbt.org/scalasbt/maven-releases/, bootOnly
+  sbt-maven-snapshots: https://repo.scala-sbt.org/scalasbt/maven-snapshots/, bootOnly
   typesafe-ivy-releases: https://repo.typesafe.com/typesafe/ivy-releases/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
   sbt-ivy-snapshots: https://repo.scala-sbt.org/scalasbt/ivy-snapshots/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
 
 [boot]
   directory: ${sbt.boot.directory-${sbt.global.base-${user.home}/.sbt}/boot/}
+  lock: ${sbt.boot.lock-true}
 
 [ivy]
   ivy-home: ${sbt.ivy.home-${user.home}/.ivy2/}
diff --git a/src/main/conscript/screpl/launchconfig b/src/main/conscript/screpl/launchconfig
index afa5eb125..cb9f15e6c 100644
--- a/src/main/conscript/screpl/launchconfig
+++ b/src/main/conscript/screpl/launchconfig
@@ -4,7 +4,7 @@
 [app]
   org: ${sbt.organization-org.scala-sbt}
   name: sbt
-  version: ${sbt.version-read(sbt.version)[0.13.9]}
+  version: ${sbt.version-read(sbt.version)[1.3.0]}
   class: sbt.ConsoleMain
   components: xsbti,extra
   cross-versioned: ${sbt.cross.versioned-false}
@@ -12,12 +12,17 @@
 
 [repositories]
   local
+  local-preloaded-ivy: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext]
+  local-preloaded: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}
   maven-central
+  sbt-maven-releases: https://repo.scala-sbt.org/scalasbt/maven-releases/, bootOnly
+  sbt-maven-snapshots: https://repo.scala-sbt.org/scalasbt/maven-snapshots/, bootOnly
   typesafe-ivy-releases: https://repo.typesafe.com/typesafe/ivy-releases/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
   sbt-ivy-snapshots: https://repo.scala-sbt.org/scalasbt/ivy-snapshots/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
 
 [boot]
   directory: ${sbt.boot.directory-${sbt.global.base-${user.home}/.sbt}/boot/}
+  lock: ${sbt.boot.lock-true}
 
 [ivy]
   ivy-home: ${sbt.ivy.home-${user.home}/.ivy2/}
diff --git a/src/main/conscript/xsbt/launchconfig b/src/main/conscript/xsbt/launchconfig
index 033dc550b..854c9bfc2 100644
--- a/src/main/conscript/xsbt/launchconfig
+++ b/src/main/conscript/xsbt/launchconfig
@@ -4,7 +4,7 @@
 [app]
   org: ${sbt.organization-org.scala-sbt}
   name: sbt
-  version: ${sbt.version-read(sbt.version)[0.13.9]}
+  version: ${sbt.version-read(sbt.version)[1.3.0]}
   class: sbt.xMain
   components: xsbti,extra
   cross-versioned: ${sbt.cross.versioned-false}
@@ -12,12 +12,17 @@
 
 [repositories]
   local
+  local-preloaded-ivy: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext]
+  local-preloaded: file:///${sbt.preloaded-${sbt.global.base-${user.home}/.sbt}/preloaded/}
   maven-central
+  sbt-maven-releases: https://repo.scala-sbt.org/scalasbt/maven-releases/, bootOnly
+  sbt-maven-snapshots: https://repo.scala-sbt.org/scalasbt/maven-snapshots/, bootOnly
   typesafe-ivy-releases: https://repo.typesafe.com/typesafe/ivy-releases/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
   sbt-ivy-snapshots: https://repo.scala-sbt.org/scalasbt/ivy-snapshots/, [organization]/[module]/[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
 
 [boot]
   directory: ${sbt.boot.directory-${sbt.global.base-${user.home}/.sbt}/boot/}
+  lock: ${sbt.boot.lock-true}
 
 [ivy]
   ivy-home: ${sbt.ivy.home-${user.home}/.ivy2/}
diff --git a/tasks-standard/NOTICE b/tasks-standard/NOTICE
index 5761647e7..3f12e2eda 100644
--- a/tasks-standard/NOTICE
+++ b/tasks-standard/NOTICE
@@ -1,3 +1,4 @@
-Simple Build Tool: Standard Tasks Component
-Copyright 2009  Mark Harrah
-Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
+sbt: Standard Tasks Component
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under BSD-3-Clause license (see LICENSE)
diff --git a/tasks-standard/src/main/scala/sbt/Action.scala b/tasks-standard/src/main/scala/sbt/Action.scala
index 166cb5f9a..56cd2214e 100644
--- a/tasks-standard/src/main/scala/sbt/Action.scala
+++ b/tasks-standard/src/main/scala/sbt/Action.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import sbt.internal.util.Types._
@@ -10,7 +14,7 @@ import ConcurrentRestrictions.{ Tag, TagMap, tagsKey }
 // Action, Task, and Info are intentionally invariant in their type parameter.
 //  Various natural transformations used, such as PMap, require invariant type constructors for correctness
 
-/** Defines a task compuation*/
+/** Defines a task computation*/
 sealed trait Action[T] {
   // TODO: remove after deprecated InputTask constructors are removed
   private[sbt] def mapTask(f: Task ~> Task): Action[T]
@@ -21,18 +25,21 @@ sealed trait Action[T] {
  * If `inline` is true, `f` will be evaluated on the scheduler thread without the overhead of normal scheduling when possible.
  * This is intended as an optimization for already evaluated values or very short pure computations.
  */
-final case class Pure[T](f: () => T, inline: Boolean) extends Action[T] {
+final case class Pure[T](f: () => T, `inline`: Boolean) extends Action[T] {
   private[sbt] def mapTask(f: Task ~> Task) = this
 }
 
 /** Applies a function to the result of evaluating a heterogeneous list of other tasks.*/
-final case class Mapped[T, K[L[x]]](in: K[Task], f: K[Result] => T, alist: AList[K]) extends Action[T] {
+final case class Mapped[T, K[L[x]]](in: K[Task], f: K[Result] => T, alist: AList[K])
+    extends Action[T] {
   private[sbt] def mapTask(g: Task ~> Task) = Mapped[T, K](alist.transform(in, g), f, alist)
 }
 
 /** Computes another task to evaluate based on results from evaluating other tasks.*/
-final case class FlatMapped[T, K[L[x]]](in: K[Task], f: K[Result] => Task[T], alist: AList[K]) extends Action[T] {
-  private[sbt] def mapTask(g: Task ~> Task) = FlatMapped[T, K](alist.transform(in, g), g.fn[T] compose f, alist)
+final case class FlatMapped[T, K[L[x]]](in: K[Task], f: K[Result] => Task[T], alist: AList[K])
+    extends Action[T] {
+  private[sbt] def mapTask(g: Task ~> Task) =
+    FlatMapped[T, K](alist.transform(in, g), g.fn[T] compose f, alist)
 }
 
 /** A computation `in` that requires other tasks `deps` to be evaluated first.*/
@@ -44,8 +51,35 @@ final case class DependsOn[T](in: Task[T], deps: Seq[Task[_]]) extends Action[T]
  * A computation that operates on the results of a homogeneous list of other tasks.
  * It can either return another task to be evaluated or the final value.
  */
-final case class Join[T, U](in: Seq[Task[U]], f: Seq[Result[U]] => Either[Task[T], T]) extends Action[T] {
-  private[sbt] def mapTask(g: Task ~> Task) = Join[T, U](in.map(g.fn[U]), sr => f(sr).left.map(g.fn[T]))
+final case class Join[T, U](in: Seq[Task[U]], f: Seq[Result[U]] => Either[Task[T], T])
+    extends Action[T] {
+  private[sbt] def mapTask(g: Task ~> Task) =
+    Join[T, U](in.map(g.fn[U]), sr => f(sr).left.map(g.fn[T]))
+}
+
+/**
+ * A computation that conditionally falls back to a second transformation.
+ * This can be used to encode `if` conditions.
+ */
+final case class Selected[A, B](fab: Task[Either[A, B]], fin: Task[A => B]) extends Action[B] {
+  private def ml = AList.single[Either[A, B]]
+  type K[L[x]] = L[Either[A, B]]
+
+  private[sbt] def mapTask(g: Task ~> Task) =
+    Selected[A, B](g(fab), g(fin))
+
+  /**
+   * Encode this computation as a flatMap.
+   */
+  private[sbt] def asFlatMapped: FlatMapped[B, K] = {
+    val f: Either[A, B] => Task[B] = {
+      case Right(b) => std.TaskExtra.task(b)
+      case Left(a)  => std.TaskExtra.singleInputTask(fin).map(_(a))
+    }
+    FlatMapped[B, K](fab, {
+      f compose std.TaskExtra.successM
+    }, ml)
+  }
 }
 
 /** Combines metadata `info` and a computation `work` to define a task. */
@@ -53,10 +87,15 @@ final case class Task[T](info: Info[T], work: Action[T]) {
   override def toString = info.name getOrElse ("Task(" + info + ")")
   override def hashCode = info.hashCode
 
-  private[sbt] def mapTask(g: Task ~> Task): Task[T] = g(Task(info, work.mapTask(g)))
   def tag(tags: Tag*): Task[T] = tagw(tags.map(t => (t, 1)): _*)
-  def tagw(tags: (Tag, Int)*): Task[T] = copy(info = info.set(tagsKey, info.get(tagsKey).getOrElse(Map.empty) ++ tags))
-  def tags: TagMap = info get tagsKey getOrElse Map.empty
+  def tagw(tags: (Tag, Int)*): Task[T] = {
+    val tgs: TagMap = info.get(tagsKey).getOrElse(TagMap.empty)
+    val value = tags.foldLeft(tgs)((acc, tag) => acc + tag)
+    val nextInfo = info.set(tagsKey, value)
+    copy(info = nextInfo)
+  }
+
+  def tags: TagMap = info get tagsKey getOrElse TagMap.empty
 }
 
 /**
@@ -64,14 +103,17 @@ final case class Task[T](info: Info[T], work: Action[T]) {
  * @param attributes Arbitrary user-defined key/value pairs describing this task
  * @param post a transformation that takes the result of evaluating this task and produces user-defined key/value pairs.
  */
-final case class Info[T](attributes: AttributeMap = AttributeMap.empty, post: T => AttributeMap = const(AttributeMap.empty)) {
+final case class Info[T](
+    attributes: AttributeMap = AttributeMap.empty,
+    post: T => AttributeMap = Info.defaultAttributeMap
+) {
   import Info._
   def name = attributes.get(Name)
   def description = attributes.get(Description)
   def setName(n: String) = set(Name, n)
   def setDescription(d: String) = set(Description, d)
   def set[A](key: AttributeKey[A], value: A) = copy(attributes = this.attributes.put(key, value))
-  def get[A](key: AttributeKey[A]) = attributes.get(key)
+  def get[A](key: AttributeKey[A]): Option[A] = attributes.get(key)
   def postTransform(f: (T, AttributeMap) => AttributeMap) = copy(post = (t: T) => f(t, post(t)))
 
   override def toString = if (attributes.isEmpty) "_" else attributes.toString
@@ -79,4 +121,5 @@ final case class Info[T](attributes: AttributeMap = AttributeMap.empty, post: T
 object Info {
   val Name = AttributeKey[String]("name")
   val Description = AttributeKey[String]("description")
+  val defaultAttributeMap = const(AttributeMap.empty)
 }
diff --git a/tasks-standard/src/main/scala/sbt/std/Streams.scala b/tasks-standard/src/main/scala/sbt/std/Streams.scala
index a9e3689d6..da487fdd3 100644
--- a/tasks-standard/src/main/scala/sbt/std/Streams.scala
+++ b/tasks-standard/src/main/scala/sbt/std/Streams.scala
@@ -1,17 +1,22 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package std
 
-import java.io.{ BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, Closeable, File, 
-  FileInputStream, FileOutputStream, IOException, InputStreamReader, OutputStreamWriter, PrintWriter }
+import java.io.{ File => _, _ }
+import java.util.concurrent.ConcurrentHashMap
 
 import sbt.internal.io.DeferredWriter
+import sbt.internal.util.ManagedLogger
+import sbt.internal.util.Util.nil
 import sbt.io.IO
 import sbt.io.syntax._
-
-import sbt.util.Logger
+import sbt.util._
 
 // no longer specific to Tasks, so 'TaskStreams' should be renamed
 /**
@@ -20,12 +25,16 @@ import sbt.util.Logger
  * For example, logging for test:compile is by default sent to the "out" stream in the test:compile context.
  */
 sealed trait TaskStreams[Key] {
+
   /** The default stream ID, used when an ID is not provided. */
   def default = outID
 
   def outID = "out"
   def errorID = "err"
 
+  def getInput(key: Key, sid: String = default): Input
+  def getOutput(sid: String = default): Output
+
   /**
    * Provides a reader to read text from the stream `sid` for `key`.
    * It is the caller's responsibility to coordinate writing to the stream.
@@ -41,7 +50,8 @@ sealed trait TaskStreams[Key] {
   def readBinary(a: Key, sid: String = default): BufferedInputStream
 
   final def readText(a: Key, sid: Option[String]): BufferedReader = readText(a, getID(sid))
-  final def readBinary(a: Key, sid: Option[String]): BufferedInputStream = readBinary(a, getID(sid))
+  final def readBinary(a: Key, sid: Option[String]): BufferedInputStream =
+    readBinary(a, getID(sid))
 
   def key: Key
 
@@ -54,12 +64,14 @@ sealed trait TaskStreams[Key] {
   /** A cache directory that is unique to the context of this streams instance.*/
   def cacheDirectory: File
 
+  def cacheStoreFactory: CacheStoreFactory
+
   // default logger
   /** Obtains the default logger. */
-  final lazy val log: Logger = log(default)
+  final lazy val log: ManagedLogger = log(default)
 
   /** Creates a Logger that logs to stream with ID `sid`.*/
-  def log(sid: String): Logger
+  def log(sid: String): ManagedLogger
 
   private[this] def getID(s: Option[String]) = s getOrElse default
 }
@@ -71,16 +83,23 @@ sealed trait ManagedStreams[Key] extends TaskStreams[Key] {
 
 trait Streams[Key] {
   def apply(a: Key): ManagedStreams[Key]
-  def use[T](key: Key)(f: TaskStreams[Key] => T): T =
-    {
-      val s = apply(key)
-      s.open()
-      try { f(s) } finally { s.close() }
+  def use[T](key: Key)(f: TaskStreams[Key] => T): T = {
+    val s = apply(key)
+    s.open()
+    try {
+      f(s)
+    } finally {
+      s.close()
     }
+  }
 }
 trait CloseableStreams[Key] extends Streams[Key] with java.io.Closeable
 object Streams {
-  private[this] val closeQuietly = (c: Closeable) => try { c.close() } catch { case _: IOException => () }
+  private[this] val closeQuietly = (c: Closeable) =>
+    try {
+      c.close()
+    } catch { case _: IOException => () }
+  private[this] val streamLocks = new ConcurrentHashMap[File, AnyRef]()
 
   def closeable[Key](delegate: Streams[Key]): CloseableStreams[Key] = new CloseableStreams[Key] {
     private[this] val streams = new collection.mutable.HashMap[Key, ManagedStreams[Key]]
@@ -100,20 +119,70 @@ object Streams {
       synchronized { streams.values.foreach(_.close()); streams.clear() }
   }
 
-  def apply[Key](taskDirectory: Key => File, name: Key => String, mkLogger: (Key, PrintWriter) => Logger): Streams[Key] = new Streams[Key] {
+  @deprecated("Use constructor without converter", "1.4")
+  def apply[Key, J: sjsonnew.IsoString](
+      taskDirectory: Key => File,
+      name: Key => String,
+      mkLogger: (Key, PrintWriter) => ManagedLogger,
+      converter: sjsonnew.SupportConverter[J],
+  ): Streams[Key] = apply[Key](taskDirectory, name, mkLogger)
+
+  @deprecated("Use constructor without converter", "1.4")
+  private[sbt] def apply[Key, J: sjsonnew.IsoString](
+      taskDirectory: Key => File,
+      name: Key => String,
+      mkLogger: (Key, PrintWriter) => ManagedLogger,
+      converter: sjsonnew.SupportConverter[J],
+      mkFactory: (File, sjsonnew.SupportConverter[J]) => CacheStoreFactory
+  ): Streams[Key] = apply[Key](taskDirectory, name, mkLogger, mkFactory(_, converter))
+
+  def apply[Key](
+      taskDirectory: Key => File,
+      name: Key => String,
+      mkLogger: (Key, PrintWriter) => ManagedLogger,
+  ): Streams[Key] =
+    apply(
+      taskDirectory,
+      name,
+      mkLogger,
+      file => new DirectoryStoreFactory(file)
+    )
+  private[sbt] def apply[Key](
+      taskDirectory: Key => File,
+      name: Key => String,
+      mkLogger: (Key, PrintWriter) => ManagedLogger,
+      mkFactory: File => CacheStoreFactory
+  ): Streams[Key] = new Streams[Key] {
 
     def apply(a: Key): ManagedStreams[Key] = new ManagedStreams[Key] {
-      private[this] var opened: List[Closeable] = Nil
+      private[this] var opened: List[Closeable] = nil
       private[this] var closed = false
 
+      def getInput(a: Key, sid: String = default): Input =
+        make(a, sid)(f => new FileInput(f))
+
+      def getOutput(sid: String = default): Output =
+        make(a, sid)(f => new FileOutput(f))
+
       def readText(a: Key, sid: String = default): BufferedReader =
-        make(a, sid)(f => new BufferedReader(new InputStreamReader(new FileInputStream(f), IO.defaultCharset)))
+        make(a, sid)(
+          f => new BufferedReader(new InputStreamReader(new FileInputStream(f), IO.defaultCharset))
+        )
 
       def readBinary(a: Key, sid: String = default): BufferedInputStream =
         make(a, sid)(f => new BufferedInputStream(new FileInputStream(f)))
 
       def text(sid: String = default): PrintWriter =
-        make(a, sid)(f => new PrintWriter(new DeferredWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f), IO.defaultCharset)))))
+        make(a, sid)(
+          f =>
+            new PrintWriter(
+              new DeferredWriter(
+                new BufferedWriter(
+                  new OutputStreamWriter(new FileOutputStream(f), IO.defaultCharset)
+                )
+              )
+            )
+        )
 
       def binary(sid: String = default): BufferedOutputStream =
         make(a, sid)(f => new BufferedOutputStream(new FileOutputStream(f)))
@@ -124,14 +193,27 @@ object Streams {
         dir
       }
 
-      def log(sid: String): Logger = mkLogger(a, text(sid))
+      lazy val cacheStoreFactory: CacheStoreFactory = mkFactory(cacheDirectory)
+
+      def log(sid: String): ManagedLogger = mkLogger(a, text(sid))
 
       def make[T <: Closeable](a: Key, sid: String)(f: File => T): T = synchronized {
         checkOpen()
         val file = taskDirectory(a) / sid
-        IO.touch(file, false)
+        val parent = file.getParentFile
+        val newLock = new AnyRef
+        val lock = streamLocks.putIfAbsent(parent, newLock) match {
+          case null => newLock
+          case l    => l
+        }
+        try lock.synchronized {
+          if (!file.exists) IO.touch(file, setModified = false)
+        } finally {
+          streamLocks.remove(parent)
+          ()
+        }
         val t = f(file)
-        opened ::= t
+        opened ::= (t: Closeable)
         t
       }
 
diff --git a/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala b/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala
index cf5aa7c34..4483b9eec 100644
--- a/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala
+++ b/tasks-standard/src/main/scala/sbt/std/TaskExtra.scala
@@ -1,12 +1,16 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package std
 
 import scala.sys.process.{ BasicIO, ProcessIO, ProcessBuilder }
 
-import sbt.internal.util.AList
+import sbt.internal.util.{ AList, AttributeMap }
 import sbt.internal.util.Types._
 import java.io.{ BufferedInputStream, BufferedReader, File, InputStream }
 import sbt.io.IO
@@ -33,16 +37,28 @@ sealed trait SingleInTask[S] {
   def failure: Task[Incomplete]
   def result: Task[Result[S]]
 
-  @deprecated("Use the `result` method to create a task that returns the full Result of this task.  Then, call `map` on the new task.", "0.13.0")
+  @deprecated(
+    "Use the `result` method to create a task that returns the full Result of this task.  Then, call `map` on the new task.",
+    "0.13.0"
+  )
   def mapR[T](f: Result[S] => T): Task[T]
 
-  @deprecated("Use the `failure` method to create a task that returns Incomplete when this task fails and then call `flatMap` on the new task.", "0.13.0")
+  @deprecated(
+    "Use the `failure` method to create a task that returns Incomplete when this task fails and then call `flatMap` on the new task.",
+    "0.13.0"
+  )
   def flatFailure[T](f: Incomplete => Task[T]): Task[T]
 
-  @deprecated("Use the `failure` method to create a task that returns Incomplete when this task fails and then call `mapFailure` on the new task.", "0.13.0")
+  @deprecated(
+    "Use the `failure` method to create a task that returns Incomplete when this task fails and then call `mapFailure` on the new task.",
+    "0.13.0"
+  )
   def mapFailure[T](f: Incomplete => T): Task[T]
 
-  @deprecated("Use the `result` method to create a task that returns the full Result of this task.  Then, call `flatMap` on the new task.", "0.13.0")
+  @deprecated(
+    "Use the `result` method to create a task that returns the full Result of this task.  Then, call `flatMap` on the new task.",
+    "0.13.0"
+  )
   def flatMapR[T](f: Result[S] => Task[T]): Task[T]
 }
 sealed trait TaskInfo[S] {
@@ -78,7 +94,18 @@ sealed trait ProcessPipe {
   def pipe(sid: String)(p: ProcessBuilder): Task[Int]
 }
 
-trait TaskExtra {
+trait TaskExtra0 {
+  final implicit def joinAnyTasks(in: Seq[Task[_]]): JoinTask[Any, Seq] =
+    joinTasks0[Any](existToAny(in))
+  private[sbt] def joinTasks0[S](in: Seq[Task[S]]): JoinTask[S, Seq] = new JoinTask[S, Seq] {
+    def join: Task[Seq[S]] =
+      Task[Seq[S]](Info(), new Join(in, (s: Seq[Result[S]]) => Right(TaskExtra.all(s))))
+    def reduced(f: (S, S) => S): Task[S] = TaskExtra.reduced(in.toIndexedSeq, f)
+  }
+  private[sbt] def existToAny(in: Seq[Task[_]]): Seq[Task[Any]] = in.asInstanceOf[Seq[Task[Any]]]
+}
+
+trait TaskExtra extends TaskExtra0 {
   final def nop: Task[Unit] = constant(())
   final def constant[T](t: T): Task[T] = task(t)
 
@@ -86,32 +113,40 @@ trait TaskExtra {
   final implicit def toTask[T](f: () => T): Task[T] = Task(Info(), new Pure(f, false))
   final def inlineTask[T](value: T): Task[T] = Task(Info(), new Pure(() => value, true))
 
-  final implicit def upcastTask[A >: B, B](t: Task[B]): Task[A] = t map { x => x: A }
+  final implicit def upcastTask[A >: B, B](t: Task[B]): Task[A] = t map { x =>
+    x: A
+  }
   final implicit def toTasks[S](in: Seq[() => S]): Seq[Task[S]] = in.map(toTask)
   final implicit def iterableTask[S](in: Seq[S]): ForkTask[S, Seq] = new ForkTask[S, Seq] {
     def fork[T](f: S => T): Seq[Task[T]] = in.map(x => task(f(x)))
     def tasks: Seq[Task[S]] = fork(idFun)
   }
 
-  import TaskExtra.{ allM, anyFailM, existToAny, failM, successM }
+  import TaskExtra.{ allM, anyFailM, failM, successM }
 
-  final implicit def joinAnyTasks(in: Seq[Task[_]]): JoinTask[Any, Seq] = joinTasks[Any](existToAny(in))
   final implicit def joinTasks[S](in: Seq[Task[S]]): JoinTask[S, Seq] = new JoinTask[S, Seq] {
-    def join: Task[Seq[S]] = Task[Seq[S]](Info(), new Join(in, (s: Seq[Result[S]]) => Right(TaskExtra.all(s))))
+    def join: Task[Seq[S]] =
+      Task[Seq[S]](Info(), new Join(in, (s: Seq[Result[S]]) => Right(TaskExtra.all(s))))
     def reduced(f: (S, S) => S): Task[S] = TaskExtra.reduced(in.toIndexedSeq, f)
   }
 
-  final implicit def multT2Task[A, B](in: (Task[A], Task[B])) = multInputTask[({ type l[L[x]] = (L[A], L[B]) })#l](in)(AList.tuple2[A, B])
+  final implicit def multT2Task[A, B](in: (Task[A], Task[B])) =
+    multInputTask[λ[L[x] => (L[A], L[B])]](in)(AList.tuple2[A, B])
 
-  final implicit def multInputTask[K[L[X]]](tasks: K[Task])(implicit a: AList[K]): MultiInTask[K] = new MultiInTask[K] {
-    def flatMapR[T](f: K[Result] => Task[T]): Task[T] = Task(Info(), new FlatMapped[T, K](tasks, f, a))
-    def flatMap[T](f: K[Id] => Task[T]): Task[T] = Task(Info(), new FlatMapped[T, K](tasks, f compose allM, a))
-    def flatFailure[T](f: Seq[Incomplete] => Task[T]): Task[T] = Task(Info(), new FlatMapped[T, K](tasks, f compose anyFailM, a))
+  final implicit def multInputTask[K[L[X]]](tasks: K[Task])(implicit a: AList[K]): MultiInTask[K] =
+    new MultiInTask[K] {
+      def flatMapR[T](f: K[Result] => Task[T]): Task[T] =
+        Task(Info(), new FlatMapped[T, K](tasks, f, a))
+      def flatMap[T](f: K[Id] => Task[T]): Task[T] =
+        Task(Info(), new FlatMapped[T, K](tasks, f compose allM, a))
+      def flatFailure[T](f: Seq[Incomplete] => Task[T]): Task[T] =
+        Task(Info(), new FlatMapped[T, K](tasks, f compose anyFailM, a))
 
-    def mapR[T](f: K[Result] => T): Task[T] = Task(Info(), new Mapped[T, K](tasks, f, a))
-    def map[T](f: K[Id] => T): Task[T] = Task(Info(), new Mapped[T, K](tasks, f compose allM, a))
-    def mapFailure[T](f: Seq[Incomplete] => T): Task[T] = Task(Info(), new Mapped[T, K](tasks, f compose anyFailM, a))
-  }
+      def mapR[T](f: K[Result] => T): Task[T] = Task(Info(), new Mapped[T, K](tasks, f, a))
+      def map[T](f: K[Id] => T): Task[T] = Task(Info(), new Mapped[T, K](tasks, f compose allM, a))
+      def mapFailure[T](f: Seq[Incomplete] => T): Task[T] =
+        Task(Info(), new Mapped[T, K](tasks, f compose anyFailM, a))
+    }
 
   final implicit def singleInputTask[S](in: Task[S]): SingleInTask[S] = new SingleInTask[S] {
     type K[L[x]] = L[S]
@@ -120,9 +155,12 @@ trait TaskExtra {
     def failure: Task[Incomplete] = mapFailure(idFun)
     def result: Task[Result[S]] = mapR(idFun)
 
-    def flatMapR[T](f: Result[S] => Task[T]): Task[T] = Task(Info(), new FlatMapped[T, K](in, f, ml))
-    def mapR[T](f: Result[S] => T): Task[T] = Task(Info(), new Mapped[T, K](in, f, ml))
-    def dependsOn(tasks: Task[_]*): Task[S] = Task(Info(), new DependsOn(in, tasks))
+    private def newInfo[A]: Info[A] = TaskExtra.newInfo(in.info)
+
+    def flatMapR[T](f: Result[S] => Task[T]): Task[T] =
+      Task(newInfo, new FlatMapped[T, K](in, f, ml))
+    def mapR[T](f: Result[S] => T): Task[T] = Task(newInfo, new Mapped[T, K](in, f, ml))
+    def dependsOn(tasks: Task[_]*): Task[S] = Task(newInfo, new DependsOn(in, tasks))
 
     def flatMap[T](f: S => Task[T]): Task[T] = flatMapR(f compose successM)
     def flatFailure[T](f: Incomplete => Task[T]): Task[T] = flatMapR(f compose failM)
@@ -131,8 +169,17 @@ trait TaskExtra {
     def mapFailure[T](f: Incomplete => T): Task[T] = mapR(f compose failM)
 
     def andFinally(fin: => Unit): Task[S] = mapR(x => Result.tryValue[S]({ fin; x }))
-    def doFinally(t: Task[Unit]): Task[S] = flatMapR(x => t.result.map { tx => Result.tryValues[S](tx :: Nil, x) })
-    def ||[T >: S](alt: Task[T]): Task[T] = flatMapR { case Value(v) => task(v); case Inc(i) => alt }
+    def doFinally(t: Task[Unit]): Task[S] =
+      flatMapR(
+        x =>
+          t.result.map { tx =>
+            Result.tryValues[S](tx :: Nil, x)
+          }
+      )
+    def ||[T >: S](alt: Task[T]): Task[T] = flatMapR {
+      case Value(v) => task(v: T)
+      case Inc(_)   => alt
+    }
     def &&[T](alt: Task[T]): Task[T] = flatMap(_ => alt)
   }
 
@@ -141,92 +188,114 @@ trait TaskExtra {
     def named(s: String): Task[S] = in.copy(info = in.info.setName(s))
   }
 
-  final implicit def pipeToProcess[Key](t: Task[_])(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): ProcessPipe = new ProcessPipe {
-    def #|(p: ProcessBuilder): Task[Int] = pipe0(None, p)
-    def pipe(sid: String)(p: ProcessBuilder): Task[Int] = pipe0(Some(sid), p)
-    private def pipe0(sid: Option[String], p: ProcessBuilder): Task[Int] =
-      for (s <- streams) yield {
-        val in = s.readBinary(key(t), sid)
-        val pio = TaskExtra.processIO(s).withInput(out => { BasicIO.transferFully(in, out); out.close() })
-        (p run pio).exitValue
-      }
-  }
+  final implicit def pipeToProcess[Key](
+      t: Task[_]
+  )(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): ProcessPipe =
+    new ProcessPipe {
+      def #|(p: ProcessBuilder): Task[Int] = pipe0(None, p)
+      def pipe(sid: String)(p: ProcessBuilder): Task[Int] = pipe0(Some(sid), p)
+      private def pipe0(sid: Option[String], p: ProcessBuilder): Task[Int] =
+        for (s <- streams) yield {
+          val in = s.readBinary(key(t), sid)
+          val pio = TaskExtra
+            .processIO(s)
+            .withInput(out => { BasicIO.transferFully(in, out); out.close() })
+          (p run pio).exitValue
+        }
+    }
 
-  final implicit def binaryPipeTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): BinaryPipe = new BinaryPipe {
-    def binary[T](f: BufferedInputStream => T): Task[T] = pipe0(None, f)
-    def binary[T](sid: String)(f: BufferedInputStream => T): Task[T] = pipe0(Some(sid), f)
+  final implicit def binaryPipeTask[Key](
+      in: Task[_]
+  )(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): BinaryPipe =
+    new BinaryPipe {
+      def binary[T](f: BufferedInputStream => T): Task[T] = pipe0(None, f)
+      def binary[T](sid: String)(f: BufferedInputStream => T): Task[T] = pipe0(Some(sid), f)
 
-    def #>(f: File): Task[Unit] = pipe0(None, toFile(f))
-    def #>(sid: String, f: File): Task[Unit] = pipe0(Some(sid), toFile(f))
+      def #>(f: File): Task[Unit] = pipe0(None, toFile(f))
+      def #>(sid: String, f: File): Task[Unit] = pipe0(Some(sid), toFile(f))
 
-    private def pipe0[T](sid: Option[String], f: BufferedInputStream => T): Task[T] =
-      streams map { s => f(s.readBinary(key(in), sid)) }
+      private def pipe0[T](sid: Option[String], f: BufferedInputStream => T): Task[T] =
+        streams map { s =>
+          f(s.readBinary(key(in), sid))
+        }
 
-    private def toFile(f: File) = (in: InputStream) => IO.transfer(in, f)
-  }
-  final implicit def textPipeTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): TextPipe = new TextPipe {
+      private def toFile(f: File) = (in: InputStream) => IO.transfer(in, f)
+    }
+  final implicit def textPipeTask[Key](
+      in: Task[_]
+  )(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): TextPipe = new TextPipe {
     def text[T](f: BufferedReader => T): Task[T] = pipe0(None, f)
     def text[T](sid: String)(f: BufferedReader => T): Task[T] = pipe0(Some(sid), f)
 
     private def pipe0[T](sid: Option[String], f: BufferedReader => T): Task[T] =
-      streams map { s => f(s.readText(key(in), sid)) }
+      streams map { s =>
+        f(s.readText(key(in), sid))
+      }
   }
-  final implicit def linesTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): TaskLines = new TaskLines {
+  final implicit def linesTask[Key](
+      in: Task[_]
+  )(implicit streams: Task[TaskStreams[Key]], key: Task[_] => Key): TaskLines = new TaskLines {
     def lines: Task[List[String]] = lines0(None)
     def lines(sid: String): Task[List[String]] = lines0(Some(sid))
 
     private def lines0[T](sid: Option[String]): Task[List[String]] =
-      streams map { s => IO.readLines(s.readText(key(in), sid)) }
-  }
-  implicit def processToTask(p: ProcessBuilder)(implicit streams: Task[TaskStreams[_]]): Task[Int] = streams map { s =>
-    val pio = TaskExtra.processIO(s)
-    (p run pio).exitValue
+      streams map { s =>
+        IO.readLines(s.readText(key(in), sid))
+      }
   }
+  implicit def processToTask(p: ProcessBuilder)(implicit streams: Task[TaskStreams[_]]): Task[Int] =
+    streams map { s =>
+      val pio = TaskExtra.processIO(s)
+      (p run pio).exitValue
+    }
 }
 object TaskExtra extends TaskExtra {
-  def processIO(s: TaskStreams[_]): ProcessIO =
-    {
-      def transfer(id: String) = (in: InputStream) => BasicIO.transferFully(in, s.binary(id))
-      new ProcessIO(_.close(), transfer(s.outID), transfer(s.errorID))
-    }
+  def processIO(s: TaskStreams[_]): ProcessIO = {
+    def transfer(id: String) = (in: InputStream) => BasicIO.transferFully(in, s.binary(id))
+    new ProcessIO(_.close(), transfer(s.outID), transfer(s.errorID))
+  }
   def reduced[S](i: IndexedSeq[Task[S]], f: (S, S) => S): Task[S] =
     i match {
       case Seq()     => sys.error("Cannot reduce empty sequence")
       case Seq(x)    => x
       case Seq(x, y) => reducePair(x, y, f)
-      case z =>
+      case _ =>
         val (a, b) = i.splitAt(i.size / 2)
         reducePair(reduced(a, f), reduced(b, f), f)
     }
 
   def reducePair[S](a: Task[S], b: Task[S], f: (S, S) => S): Task[S] =
-    multInputTask[({ type l[L[x]] = (L[S], L[S]) })#l]((a, b))(AList.tuple2[S, S]) map f.tupled
+    multInputTask[λ[L[x] => (L[S], L[S])]]((a, b))(AList.tuple2[S, S]) map f.tupled
 
-  def anyFailM[K[L[x]]](implicit a: AList[K]): K[Result] => Seq[Incomplete] = in =>
-    {
-      val incs = failuresM(a)(in)
-      if (incs.isEmpty) expectedFailure else incs
-    }
-  def failM[T]: Result[T] => Incomplete = { case Inc(i) => i; case x => expectedFailure }
+  def anyFailM[K[L[x]]](implicit a: AList[K]): K[Result] => Seq[Incomplete] = in => {
+    val incs = failuresM(a)(in)
+    if (incs.isEmpty) expectedFailure else incs
+  }
+  def failM[T]: Result[T] => Incomplete = { case Inc(i) => i; case _ => expectedFailure }
 
   def expectedFailure = throw Incomplete(None, message = Some("Expected dependency to fail."))
 
   def successM[T]: Result[T] => T = { case Inc(i) => throw i; case Value(t) => t }
-  def allM[K[L[x]]](implicit a: AList[K]): K[Result] => K[Id] = in =>
-    {
-      val incs = failuresM(a)(in)
-      if (incs.isEmpty) a.transform(in, Result.tryValue) else throw incompleteDeps(incs)
-    }
-  def failuresM[K[L[x]]](implicit a: AList[K]): K[Result] => Seq[Incomplete] = x => failures[Any](a.toList(x))
+  def allM[K[L[x]]](implicit a: AList[K]): K[Result] => K[Id] = in => {
+    val incs = failuresM(a)(in)
+    if (incs.isEmpty) a.transform(in, Result.tryValue) else throw incompleteDeps(incs)
+  }
+  def failuresM[K[L[x]]](implicit a: AList[K]): K[Result] => Seq[Incomplete] =
+    x => failures[Any](a.toList(x))
 
-  def all[D](in: Seq[Result[D]]): Seq[D] =
-    {
-      val incs = failures(in)
-      if (incs.isEmpty) in.map(Result.tryValue.fn[D]) else throw incompleteDeps(incs)
-    }
+  def all[D](in: Seq[Result[D]]): Seq[D] = {
+    val incs = failures(in)
+    if (incs.isEmpty) in.map(Result.tryValue.fn[D]) else throw incompleteDeps(incs)
+  }
   def failures[A](results: Seq[Result[A]]): Seq[Incomplete] = results.collect { case Inc(i) => i }
 
   def incompleteDeps(incs: Seq[Incomplete]): Incomplete = Incomplete(None, causes = incs)
 
-  private[sbt] def existToAny(in: Seq[Task[_]]): Seq[Task[Any]] = in.asInstanceOf[Seq[Task[Any]]]
+  def select[A, B](fab: Task[Either[A, B]], f: Task[A => B]): Task[B] =
+    Task(newInfo(fab.info), new Selected[A, B](fab, f))
+
+  // The "taskDefinitionKey" is used, at least, by the ".previous" functionality.
+  // But apparently it *cannot* survive a task map/flatMap/etc. See actions/depends-on.
+  private[sbt] def newInfo[A](info: Info[_]): Info[A] =
+    Info[A](AttributeMap(info.attributes.entries.filter(_.key.label != "taskDefinitionKey")))
 }
diff --git a/tasks-standard/src/main/scala/sbt/std/System.scala b/tasks-standard/src/main/scala/sbt/std/Transform.scala
similarity index 55%
rename from tasks-standard/src/main/scala/sbt/std/System.scala
rename to tasks-standard/src/main/scala/sbt/std/Transform.scala
index 69ea15ac0..f2259f3b3 100644
--- a/tasks-standard/src/main/scala/sbt/std/System.scala
+++ b/tasks-standard/src/main/scala/sbt/std/Transform.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 package std
 
@@ -9,28 +13,31 @@ import sbt.internal.util.{ ~>, AList, DelegatingPMap, RMap }
 import TaskExtra.{ all, existToAny }
 
 object Transform {
-  def fromDummy[T](original: Task[T])(action: => T): Task[T] = Task(original.info, Pure(action _, false))
+  def fromDummy[T](original: Task[T])(action: => T): Task[T] =
+    Task(original.info, Pure(action _, false))
   def fromDummyStrict[T](original: Task[T], value: T): Task[T] = fromDummy(original)(value)
 
-  implicit def to_~>|[K[_], V[_]](map: RMap[K, V]): K ~>| V = new (K ~>| V) { def apply[T](k: K[T]): Option[V[T]] = map.get(k) }
+  implicit def to_~>|[K[_], V[_]](map: RMap[K, V]): K ~>| V = new (K ~>| V) {
+    def apply[T](k: K[T]): Option[V[T]] = map.get(k)
+  }
 
   final case class DummyTaskMap(mappings: List[TaskAndValue[_]]) {
-    def ::[T](tav: (Task[T], T)): DummyTaskMap = DummyTaskMap(new TaskAndValue(tav._1, tav._2) :: mappings)
+    def ::[T](tav: (Task[T], T)): DummyTaskMap =
+      DummyTaskMap(new TaskAndValue(tav._1, tav._2) :: mappings)
   }
   final class TaskAndValue[T](val task: Task[T], val value: T)
-  def dummyMap(dummyMap: DummyTaskMap): Task ~>| Task =
-    {
-      val pmap = new DelegatingPMap[Task, Task](new collection.mutable.ListMap)
-      def add[T](dummy: TaskAndValue[T]): Unit = { pmap(dummy.task) = fromDummyStrict(dummy.task, dummy.value) }
-      dummyMap.mappings.foreach(x => add(x))
-      pmap
+  def dummyMap(dummyMap: DummyTaskMap): Task ~>| Task = {
+    val pmap = new DelegatingPMap[Task, Task](new collection.mutable.ListMap)
+    def add[T](dummy: TaskAndValue[T]): Unit = {
+      pmap(dummy.task) = fromDummyStrict(dummy.task, dummy.value)
     }
+    dummyMap.mappings.foreach(x => add(x))
+    pmap
+  }
 
   /** Applies `map`, returning the result if defined or returning the input unchanged otherwise.*/
   implicit def getOrId(map: Task ~>| Task): Task ~> Task =
-    new (Task ~> Task) {
-      def apply[T](in: Task[T]): Task[T] = map(in).getOrElse(in)
-    }
+    λ[Task ~> Task](in => map(in).getOrElse(in))
 
   def apply(dummies: DummyTaskMap) = taskToNode(getOrId(dummyMap(dummies)))
 
@@ -39,19 +46,22 @@ object Transform {
       case Pure(eval, _)       => uniform(Nil)(_ => Right(eval()))
       case m: Mapped[t, k]     => toNode[t, k](m.in)(right ∙ m.f)(m.alist)
       case m: FlatMapped[t, k] => toNode[t, k](m.in)(left ∙ m.f)(m.alist)
-      case DependsOn(in, deps) => uniform(existToAny(deps))(const(Left(in)) ∙ all)
+      case s: Selected[_, t]   => val m = s.asFlatMapped; toNode(m.in)(left ∙ m.f)(m.alist)
+      case DependsOn(in, deps) => uniform(existToAny(deps))(const(Left(in)) compose all)
       case Join(in, f)         => uniform(in)(f)
     }
-    def inline[T](t: Task[T]) = t.work match {
+    def inline[T](t: Task[T]): Option[() => T] = t.work match {
       case Pure(eval, true) => Some(eval)
       case _                => None
     }
   }
 
   def uniform[T, D](tasks: Seq[Task[D]])(f: Seq[Result[D]] => Either[Task[T], T]): Node[Task, T] =
-    toNode[T, ({ type l[L[x]] = List[L[D]] })#l](tasks.toList)(f)(AList.seq[D])
+    toNode[T, λ[L[x] => List[L[D]]]](tasks.toList)(f)(AList.seq[D])
 
-  def toNode[T, k[L[x]]](inputs: k[Task])(f: k[Result] => Either[Task[T], T])(implicit a: AList[k]): Node[Task, T] = new Node[Task, T] {
+  def toNode[T, k[L[x]]](
+      inputs: k[Task]
+  )(f: k[Result] => Either[Task[T], T])(implicit a: AList[k]): Node[Task, T] = new Node[Task, T] {
     type K[L[x]] = k[L]
     val in = inputs
     val alist = a
diff --git a/tasks-standard/src/test/scala/Execute.scala b/tasks-standard/src/test/scala/Execute.scala
index e72c54f2a..c61dc9c6b 100644
--- a/tasks-standard/src/test/scala/Execute.scala
+++ b/tasks-standard/src/test/scala/Execute.scala
@@ -1,12 +1,15 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009, 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import org.scalacheck._
 import Prop._
 import TaskGen._
-import Task._
 
 object ExecuteSpec extends Properties("Execute") {
   val iGen = Arbitrary.arbInt.arbitrary
@@ -23,27 +26,27 @@ object ExecuteSpec extends Properties("Execute") {
 		}
 	}*/
 
-  property("evaluates simple mapped task") = forAll(iGen, MaxTasksGen, MaxWorkersGen) { (i: Int, times: Int, workers: Int) =>
-    ("Workers: " + workers) |: ("Value: " + i) |: ("Times: " + times) |:
-      {
+  property("evaluates simple mapped task") = forAll(iGen, MaxTasksGen, MaxWorkersGen) {
+    (i: Int, times: Int, workers: Int) =>
+      ("Workers: " + workers) |: ("Value: " + i) |: ("Times: " + times) |: {
         def result = tryRun(task(i).map(_ * times), false, workers)
         checkResult(result, i * times)
       }
   }
-  property("evaluates chained mapped task") = forAllNoShrink(iGen, MaxTasksGen, MaxWorkersGen) { (i: Int, times: Int, workers: Int) =>
-    ("Workers: " + workers) |: ("Value: " + i) |: ("Times: " + times) |:
-      {
+  property("evaluates chained mapped task") = forAllNoShrink(iGen, MaxTasksGen, MaxWorkersGen) {
+    (i: Int, times: Int, workers: Int) =>
+      ("Workers: " + workers) |: ("Value: " + i) |: ("Times: " + times) |: {
         val initial = task(0) map (identity[Int])
-        def t = (initial /: (0 until times))((t, ignore) => t.map(_ + i))
+        def t = (0 until times).foldLeft(initial)((t, ignore) => t.map(_ + i))
         checkResult(tryRun(t, false, workers), i * times)
       }
   }
 
-  property("evaluates simple bind") = forAll(iGen, MaxTasksGen, MaxWorkersGen) { (i: Int, times: Int, workers: Int) =>
-    ("Workers: " + workers) |: ("Value: " + i) |: ("Times: " + times) |:
-      {
+  property("evaluates simple bind") = forAll(iGen, MaxTasksGen, MaxWorkersGen) {
+    (i: Int, times: Int, workers: Int) =>
+      ("Workers: " + workers) |: ("Value: " + i) |: ("Times: " + times) |: {
         def result = tryRun(task(i).flatMap(x => task(x * times)), false, workers)
         checkResult(result, i * times)
       }
   }
-}
\ No newline at end of file
+}
diff --git a/tasks-standard/src/test/scala/TaskGen.scala b/tasks-standard/src/test/scala/TaskGen.scala
index 895752891..92d8b29d8 100644
--- a/tasks-standard/src/test/scala/TaskGen.scala
+++ b/tasks-standard/src/test/scala/TaskGen.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import org.scalacheck._
@@ -17,16 +21,23 @@ object TaskGen extends std.TaskExtra {
   val MaxJoinGen = choose(0, MaxJoin)
   val TaskListGen = MaxTasksGen.flatMap(size => Gen.listOfN(size, Arbitrary.arbInt.arbitrary))
 
-  def run[T](root: Task[T], checkCycles: Boolean, maxWorkers: Int): Result[T] =
-    {
-      val (service, shutdown) = CompletionService[Task[_], Completed](maxWorkers)
-      val dummies = std.Transform.DummyTaskMap(Nil)
-      val x = new Execute[Task](Execute.config(checkCycles), Execute.noTriggers, ExecuteProgress.empty[Task])(std.Transform(dummies))
-      try { x.run(root)(service) } finally { shutdown() }
+  def run[T](root: Task[T], checkCycles: Boolean, maxWorkers: Int): Result[T] = {
+    val (service, shutdown) = CompletionService[Task[_], Completed](maxWorkers)
+    val dummies = std.Transform.DummyTaskMap(Nil)
+    val x = new Execute[Task](
+      Execute.config(checkCycles),
+      Execute.noTriggers,
+      ExecuteProgress.empty[Task]
+    )(std.Transform(dummies))
+    try {
+      x.run(root)(service)
+    } finally {
+      shutdown()
     }
+  }
   def tryRun[T](root: Task[T], checkCycles: Boolean, maxWorkers: Int): T =
     run(root, checkCycles, maxWorkers) match {
       case Value(v) => v
       case Inc(i)   => throw i
     }
-}
\ No newline at end of file
+}
diff --git a/tasks-standard/src/test/scala/TaskRunnerCircular.scala b/tasks-standard/src/test/scala/TaskRunnerCircular.scala
index 1499a8feb..532d45173 100644
--- a/tasks-standard/src/test/scala/TaskRunnerCircular.scala
+++ b/tasks-standard/src/test/scala/TaskRunnerCircular.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import org.scalacheck._
@@ -5,33 +12,43 @@ import Prop._
 import TaskGen._
 
 object TaskRunnerCircularTest extends Properties("TaskRunner Circular") {
-  property("Catches circular references") = forAll(MaxTasksGen, MaxWorkersGen) { checkCircularReferences _ }
-  property("Allows references to completed tasks") = forAllNoShrink(MaxTasksGen, MaxWorkersGen) { allowedReference _ }
-  final def allowedReference(intermediate: Int, workers: Int) =
-    {
-      val top = task(intermediate).named("top")
-      def iterate(tk: Task[Int]): Task[Int] =
-        tk flatMap { t =>
-          if (t <= 0)
-            top
-          else
-            iterate(task(t - 1).named((t - 1).toString))
-        }
-      try { checkResult(tryRun(iterate(top), true, workers), intermediate) }
-      catch { case i: Incomplete if cyclic(i) => ("Unexpected cyclic exception: " + i) |: false }
+  property("Catches circular references") = forAll(MaxTasksGen, MaxWorkersGen) {
+    checkCircularReferences _
+  }
+  property("Allows references to completed tasks") = forAllNoShrink(MaxTasksGen, MaxWorkersGen) {
+    allowedReference _
+  }
+  final def allowedReference(intermediate: Int, workers: Int) = {
+    val top = task(intermediate).named("top")
+    def iterate(tk: Task[Int]): Task[Int] =
+      tk flatMap { t =>
+        if (t <= 0)
+          top
+        else
+          iterate(task(t - 1).named((t - 1).toString))
+      }
+    try {
+      checkResult(tryRun(iterate(top), true, workers), intermediate)
+    } catch {
+      case i: Incomplete if cyclic(i) => ("Unexpected cyclic exception: " + i) |: false
     }
-  final def checkCircularReferences(intermediate: Int, workers: Int) =
-    {
-      lazy val top = iterate(task(intermediate).named("bottom"), intermediate)
-      def iterate(tk: Task[Int], i: Int): Task[Int] =
-        tk flatMap { t =>
-          if (t <= 0)
-            top
-          else
-            iterate(task(t - 1).named((t - 1).toString), i - 1)
-        }
-      try { tryRun(top, true, workers); false }
-      catch { case i: Incomplete => cyclic(i) }
-    }
-  def cyclic(i: Incomplete) = Incomplete.allExceptions(i).exists(_.isInstanceOf[Execute[({ type A[_] <: AnyRef})#A]#CyclicException[_]])
+  }
+  final def checkCircularReferences(intermediate: Int, workers: Int) = {
+    lazy val top = iterate(task(intermediate).named("bottom"), intermediate)
+    def iterate(tk: Task[Int], i: Int): Task[Int] =
+      tk flatMap { t =>
+        if (t <= 0)
+          top
+        else
+          iterate(task(t - 1).named((t - 1).toString), i - 1)
+      }
+    try {
+      tryRun(top, true, workers); false
+    } catch { case i: Incomplete => cyclic(i) }
+  }
+
+  def cyclic(i: Incomplete) =
+    Incomplete
+      .allExceptions(i)
+      .exists(_.isInstanceOf[Execute[({ type A[_] <: AnyRef })#A @unchecked]#CyclicException[_]])
 }
diff --git a/tasks-standard/src/test/scala/TaskRunnerFork.scala b/tasks-standard/src/test/scala/TaskRunnerFork.scala
index ad95e742b..3551a0914 100644
--- a/tasks-standard/src/test/scala/TaskRunnerFork.scala
+++ b/tasks-standard/src/test/scala/TaskRunnerFork.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 import sbt._
 
 import org.scalacheck._
@@ -6,10 +13,11 @@ import TaskGen._
 import math.abs
 
 object TaskRunnerForkTest extends Properties("TaskRunner Fork") {
-  property("fork m tasks and wait for all to complete") = forAll(MaxTasksGen, MaxWorkersGen) { (m: Int, workers: Int) =>
-    val values = (0 until m).toList
-    checkResult(tryRun(values.fork(f => ()).join.map(_.toList), false, workers), values)
-    true
+  property("fork m tasks and wait for all to complete") = forAll(MaxTasksGen, MaxWorkersGen) {
+    (m: Int, workers: Int) =>
+      val values = (0 until m).toList
+      checkResult(tryRun(values.fork(f => ()).join.map(_.toList), false, workers), values)
+      true
   }
   property("Fork and reduce 2") = forAll(MaxTasksGen, MaxWorkersGen) { (m: Int, workers: Int) =>
     (m > 1) ==> {
@@ -17,13 +25,15 @@ object TaskRunnerForkTest extends Properties("TaskRunner Fork") {
       checkResult(tryRun(task, false, workers), 5 * (m + 1) * m)
     }
   }
-  property("Double join") = forAll(MaxJoinGen, MaxJoinGen, MaxWorkersGen) { (a: Int, b: Int, workers: Int) =>
-    runDoubleJoin(abs(a), abs(b), workers)
-    true
+  property("Double join") = forAll(MaxJoinGen, MaxJoinGen, MaxWorkersGen) {
+    (a: Int, b: Int, workers: Int) =>
+      runDoubleJoin(abs(a), abs(b), workers)
+      true
   }
   def runDoubleJoin(a: Int, b: Int, workers: Int): Unit = {
-    def inner(i: Int) = List.range(0, b).map(j => task(j).named(j.toString)).join
-    tryRun(List.range(0, a).map(inner).join, false, workers)
+    def inner = List.range(0, b).map(j => task(j).named(j.toString)).join
+    tryRun(List.range(0, a).map(_ => inner).join, false, workers)
+    ()
   }
   property("fork and reduce") = forAll(TaskListGen, MaxWorkersGen) { (m: List[Int], workers: Int) =>
     m.nonEmpty ==> {
diff --git a/tasks-standard/src/test/scala/TaskSerial.scala b/tasks-standard/src/test/scala/TaskSerial.scala
index d31cf0d21..a7bf8cbff 100644
--- a/tasks-standard/src/test/scala/TaskSerial.scala
+++ b/tasks-standard/src/test/scala/TaskSerial.scala
@@ -1,15 +1,22 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 package std
 
 import sbt.internal.util.Types._
 import TaskExtra._
 import TaskTest.tryRun
-import TaskGen.{ MaxWorkers, MaxWorkersGen }
+import TaskGen.MaxWorkers
 
 import org.scalacheck._
 import Prop.forAll
 import Transform.taskToNode
-import ConcurrentRestrictions.{ All, completionService, limitTotal, tagged => tagged0, TagMap, unrestricted }
+import ConcurrentRestrictions.{ completionService, limitTotal, tagged => tagged0, TagMap }
 
 import java.util.concurrent.{ CountDownLatch, TimeUnit }
 
@@ -41,22 +48,26 @@ object TaskSerial extends Properties("task serial") {
         checkArbitrary(size, limitTotal[Task[_]](halfSize), size <= halfSize)
     all :| ("Size: " + size) :| ("Half size: " + halfSize)
   }
-  */
+   */
 
-  def checkArbitrary(size: Int, restrictions: ConcurrentRestrictions[Task[_]], shouldSucceed: Boolean) =
-    {
-      val latch = task { new CountDownLatch(size) }
-      def mktask = latch map { l =>
-        l.countDown()
-        l.await(Timeout, TimeUnit.MILLISECONDS)
-      }
-      val tasks = (0 until size).map(_ => mktask).toList.join.map { results =>
-        val success = results.forall(idFun[Boolean])
-        assert(success == shouldSucceed, if (shouldSucceed) unschedulableMsg else scheduledMsg)
-      }
-      checkResult(evalRestricted(tasks)(restrictions), ())
+  def checkArbitrary(
+      size: Int,
+      restrictions: ConcurrentRestrictions[Task[_]],
+      shouldSucceed: Boolean
+  ) = {
+    val latch = task { new CountDownLatch(size) }
+    def mktask = latch map { l =>
+      l.countDown()
+      l.await(Timeout, TimeUnit.MILLISECONDS)
     }
-  def unschedulableMsg = "Some tasks were unschedulable: verify this is an actual failure by extending the timeout to several seconds."
+    val tasks = (0 until size).map(_ => mktask).toList.join.map { results =>
+      val success = results.forall(idFun[Boolean])
+      assert(success == shouldSucceed, if (shouldSucceed) unschedulableMsg else scheduledMsg)
+    }
+    checkResult(evalRestricted(tasks)(restrictions), ())
+  }
+  def unschedulableMsg =
+    "Some tasks were unschedulable: verify this is an actual failure by extending the timeout to several seconds."
   def scheduledMsg = "All tasks were unexpectedly scheduled."
 
   def tagged(f: TagMap => Boolean) = tagged0[Task[_]](_.tags, f)
@@ -65,14 +76,30 @@ object TaskSerial extends Properties("task serial") {
 }
 
 object TaskTest {
-  def run[T](root: Task[T], checkCycles: Boolean, restrictions: ConcurrentRestrictions[Task[_]]): Result[T] =
-    {
-      val (service, shutdown) = completionService[Task[_], Completed](restrictions, (x: String) => System.err.println(x))
+  def run[T](
+      root: Task[T],
+      checkCycles: Boolean,
+      restrictions: ConcurrentRestrictions[Task[_]]
+  ): Result[T] = {
+    val (service, shutdown) =
+      completionService[Task[_], Completed](restrictions, (x: String) => System.err.println(x))
 
-      val x = new Execute[Task](Execute.config(checkCycles), Execute.noTriggers, ExecuteProgress.empty[Task])(taskToNode(idK[Task]))
-      try { x.run(root)(service) } finally { shutdown() }
+    val x = new Execute[Task](
+      Execute.config(checkCycles),
+      Execute.noTriggers,
+      ExecuteProgress.empty[Task]
+    )(taskToNode(idK[Task]))
+    try {
+      x.run(root)(service)
+    } finally {
+      shutdown()
     }
-  def tryRun[T](root: Task[T], checkCycles: Boolean, restrictions: ConcurrentRestrictions[Task[_]]): T =
+  }
+  def tryRun[T](
+      root: Task[T],
+      checkCycles: Boolean,
+      restrictions: ConcurrentRestrictions[Task[_]]
+  ): T =
     run(root, checkCycles, restrictions) match {
       case Value(v) => v
       case Inc(i)   => throw i
diff --git a/tasks-standard/src/test/scala/Test.scala b/tasks-standard/src/test/scala/Test.scala
index a4800d413..72daac5bc 100644
--- a/tasks-standard/src/test/scala/Test.scala
+++ b/tasks-standard/src/test/scala/Test.scala
@@ -1,20 +1,26 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import sbt.internal.util.AList
 
 object Test extends std.TaskExtra {
-  def t2[A, B](a: Task[A], b: Task[B]) = multInputTask[({ type l[L[x]] = (L[A], L[B]) })#l]((a, b))(AList.tuple2)
-  def t3[A, B, C](a: Task[A], b: Task[B], c: Task[C]) = multInputTask[({ type l[L[x]] = (L[A], L[B], L[C]) })#l]((a, b, c))(AList.tuple3)
+  def t2[A, B](a: Task[A], b: Task[B]) =
+    multInputTask[λ[L[x] => (L[A], L[B])]]((a, b))(AList.tuple2)
+  def t3[A, B, C](a: Task[A], b: Task[B], c: Task[C]) =
+    multInputTask[λ[L[x] => (L[A], L[B], L[C])]]((a, b, c))(AList.tuple3)
 
   val a = task(3)
   val b = task[Boolean](sys.error("test"))
   val b2 = task(true)
   val c = task("asdf")
 
-  val h1 = t3(a, b, c).map { case (aa, bb, cc) => aa + " " + bb + " " + cc }
+  val h1 = t3(a, b, c).map { case (aa, bb, cc)  => aa + " " + bb + " " + cc }
   val h2 = t3(a, b2, c).map { case (aa, bb, cc) => aa + " " + bb + " " + cc }
 
   type Values = (Result[Int], Result[Boolean], Result[String])
@@ -28,16 +34,18 @@ object Test extends std.TaskExtra {
   val d2 = t3(a, b2, c) mapR f
   val f2: Values => Task[Any] = {
     case (Value(aa), Value(bb), Value(cc)) => task(aa + " " + bb + " " + cc)
-    case x                                 => d3
+    case _                                 => d3
   }
   lazy val d = t3(a, b, c) flatMapR f2
   val f3: Values => Task[Any] = {
     case (Value(aa), Value(bb), Value(cc)) => task(aa + " " + bb + " " + cc)
-    case x                                 => d2
+    case _                                 => d2
   }
   lazy val d3 = t3(a, b, c) flatMapR f3
 
-  def d4(i: Int): Task[Int] = nop flatMap { _ => val x = math.random; if (x < 0.01) task(i); else d4(i + 1) }
+  def d4(i: Int): Task[Int] = nop flatMap { _ =>
+    val x = math.random; if (x < 0.01) task(i); else d4(i + 1)
+  }
 
   def go(): Unit = {
     def run[T](root: Task[T]) =
diff --git a/tasks-standard/src/test/scala/TestRunnerCall.scala b/tasks-standard/src/test/scala/TestRunnerCall.scala
index 2ac9b574d..754c38bb8 100644
--- a/tasks-standard/src/test/scala/TestRunnerCall.scala
+++ b/tasks-standard/src/test/scala/TestRunnerCall.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 import sbt._
 
 import org.scalacheck._
@@ -8,35 +15,31 @@ object TaskRunnerCallTest extends Properties("TaskRunner Call") {
   property("calculates fibonacci") = forAll(MaxTasksGen, MaxWorkersGen) { (i: Int, workers: Int) =>
     (i > 0) ==> {
       val f = fibDirect(i)
-      ("Workers: " + workers) |: ("i: " + i) |: ("fib(i): " + f) |:
-        {
-          def result = tryRun(fibTask(i), false, workers)
-          checkResult(result, f)
-        }
+      ("Workers: " + workers) |: ("i: " + i) |: ("fib(i): " + f) |: {
+        def result = tryRun(fibTask(i), false, workers)
+        checkResult(result, f)
+      }
     }
   }
-  final def fibTask(i: Int) =
-    {
-      require(i > 0)
-      lazy val next: (Int, Int, Int) => Task[Int] =
-        (index, x1, x2) =>
-          {
-            if (index == i)
-              task(x2)
-            else
-              iterate((index + 1, x2, x1 + x2))
-          }
-      def iterate(iteration: (Int, Int, Int)) = task(iteration) flatMap next.tupled
-      iterate((1, 0, 1))
-    }
-  final def fibDirect(i: Int): Int =
-    {
-      require(i > 0)
-      def build(index: Int, x1: Int, x2: Int): Int =
+  final def fibTask(i: Int) = {
+    require(i > 0)
+    lazy val next: (Int, Int, Int) => Task[Int] =
+      (index, x1, x2) => {
         if (index == i)
-          x2
+          task(x2)
         else
-          build(index + 1, x2, x1 + x2)
-      build(1, 0, 1)
-    }
+          iterate((index + 1, x2, x1 + x2))
+      }
+    def iterate(iteration: (Int, Int, Int)) = task(iteration) flatMap next.tupled
+    iterate((1, 0, 1))
+  }
+  final def fibDirect(i: Int): Int = {
+    require(i > 0)
+    def build(index: Int, x1: Int, x2: Int): Int =
+      if (index == i)
+        x2
+      else
+        build(index + 1, x2, x1 + x2)
+    build(1, 0, 1)
+  }
 }
diff --git a/tasks-standard/src/test/scala/TestRunnerSort.scala b/tasks-standard/src/test/scala/TestRunnerSort.scala
index 82fddcc58..e7c6dcbed 100644
--- a/tasks-standard/src/test/scala/TestRunnerSort.scala
+++ b/tasks-standard/src/test/scala/TestRunnerSort.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009, 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import org.scalacheck._
@@ -12,34 +16,31 @@ object TaskRunnerSortTest extends Properties("TaskRunnerSort") {
     val a = list.toArray
     val sorted = a.toArray
     java.util.Arrays.sort(sorted)
-    ("Workers: " + workers) |: ("Array: " + a.toList) |:
-      {
-        def result = tryRun(sort(a.toSeq), false, if (workers > 0) workers else 1)
-        checkResult(result.toList, sorted.toList)
-      }
+    ("Workers: " + workers) |: ("Array: " + a.toList) |: {
+      def result = tryRun(sort(a.toSeq), false, if (workers > 0) workers else 1)
+      checkResult(result.toList, sorted.toList)
+    }
   }
-  final def sortDirect(a: Seq[Int]): Seq[Int] =
-    {
-      if (a.length < 2)
-        a
-      else {
+  final def sortDirect(a: Seq[Int]): Seq[Int] = {
+    if (a.length < 2)
+      a
+    else {
+      val pivot = a(0)
+      val (lt, gte) = a.view.drop(1).partition(_ < pivot)
+      sortDirect(lt.toSeq) ++ List(pivot) ++ sortDirect(gte.toSeq)
+    }
+  }
+  final def sort(a: Seq[Int]): Task[Seq[Int]] = {
+    if (a.length < 200)
+      task(sortDirect(a))
+    else {
+      task(a) flatMap { a =>
         val pivot = a(0)
         val (lt, gte) = a.view.drop(1).partition(_ < pivot)
-        sortDirect(lt) ++ List(pivot) ++ sortDirect(gte)
-      }
-    }
-  final def sort(a: Seq[Int]): Task[Seq[Int]] =
-    {
-      if (a.length < 200)
-        task(sortDirect(a))
-      else {
-        task(a) flatMap { a =>
-          val pivot = a(0)
-          val (lt, gte) = a.view.drop(1).partition(_ < pivot)
-          Test.t2(sort(lt), sort(gte)) map {
-            case (l, g) => l ++ List(pivot) ++ g
-          }
+        sbt.Test.t2(sort(lt.toSeq), sort(gte.toSeq)) map {
+          case (l, g) => l ++ List(pivot) ++ g
         }
       }
     }
+  }
 }
diff --git a/tasks-standard/src/test/scala/checkResult.scala b/tasks-standard/src/test/scala/checkResult.scala
index b8c4fe701..4eb13075d 100644
--- a/tasks-standard/src/test/scala/checkResult.scala
+++ b/tasks-standard/src/test/scala/checkResult.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import scala.util.control.NonFatal
@@ -8,19 +12,18 @@ import scala.util.control.NonFatal
 import org.scalacheck.Prop._
 
 object checkResult {
-  def apply[T](run: => T, expected: T) =
-    {
-      ("Expected: " + expected) |:
-        (try {
-          val actual = run
-          ("Actual: " + actual) |: (actual == expected)
-        } catch {
-          case i: Incomplete =>
-            println(i)
-            "One or more tasks failed" |: false
-          case NonFatal(e) =>
-            e.printStackTrace()
-            "Error in framework" |: false
-        })
-    }
+  def apply[T](run: => T, expected: T) = {
+    ("Expected: " + expected) |:
+      (try {
+        val actual = run
+        ("Actual: " + actual) |: (actual == expected)
+      } catch {
+        case i: Incomplete =>
+          println(i)
+          "One or more tasks failed" |: false
+        case NonFatal(e) =>
+          e.printStackTrace()
+          "Error in framework" |: false
+      })
+  }
 }
diff --git a/tasks/NOTICE b/tasks/NOTICE
index 640aae060..e3f56a307 100644
--- a/tasks/NOTICE
+++ b/tasks/NOTICE
@@ -1,3 +1,4 @@
-Simple Build Tool: Task Engine Component
-Copyright 2009, 2010  Mark Harrah
-Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
+sbt: Task Engine Component
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah
+Licensed under BSD-3-Clause license (see LICENSE)
diff --git a/tasks/src/main/scala/sbt/CompletionService.scala b/tasks/src/main/scala/sbt/CompletionService.scala
index 5eab07bc1..f9586a5da 100644
--- a/tasks/src/main/scala/sbt/CompletionService.scala
+++ b/tasks/src/main/scala/sbt/CompletionService.scala
@@ -1,43 +1,94 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 trait CompletionService[A, R] {
+
+  /**
+   * Submits a work node A with work that returns R.
+   * In Execute this is used for tasks returning sbt.Completed.
+   */
   def submit(node: A, work: () => R): Unit
+
+  /**
+   * Retrieves and removes the result from the next completed task,
+   * waiting if none are yet present.
+   * In Execute this is used for tasks returning sbt.Completed.
+   */
   def take(): R
 }
 
-import java.util.concurrent.{ Callable, CompletionService => JCompletionService, Executor, Executors, ExecutorCompletionService }
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.{
+  Callable,
+  Executor,
+  ExecutorCompletionService,
+  Executors,
+  Future => JFuture,
+  RejectedExecutionException,
+  CompletionService => JCompletionService
+}
 
 object CompletionService {
-  def apply[A, T](poolSize: Int): (CompletionService[A, T], () => Unit) =
-    {
-      val pool = Executors.newFixedThreadPool(poolSize)
-      (apply[A, T](pool), () => pool.shutdownNow())
-    }
+  val poolID = new AtomicInteger(1)
+  def apply[A, T](poolSize: Int): (CompletionService[A, T], () => Unit) = {
+    val i = new AtomicInteger(1)
+    val id = poolID.getAndIncrement()
+    val pool = Executors.newFixedThreadPool(
+      poolSize,
+      (r: Runnable) => new Thread(r, s"sbt-completion-thread-$id-${i.getAndIncrement}")
+    )
+    (apply[A, T](pool), () => { pool.shutdownNow(); () })
+  }
   def apply[A, T](x: Executor): CompletionService[A, T] =
     apply(new ExecutorCompletionService[T](x))
   def apply[A, T](completion: JCompletionService[T]): CompletionService[A, T] =
     new CompletionService[A, T] {
-      def submit(node: A, work: () => T) = CompletionService.submit(work, completion)
+      def submit(node: A, work: () => T) = { CompletionService.submit(work, completion); () }
       def take() = completion.take().get()
     }
-  def submit[T](work: () => T, completion: JCompletionService[T]): () => T =
-    {
-      val future = completion.submit { new Callable[T] { def call = work() } }
-      () => future.get()
+  def submit[T](work: () => T, completion: JCompletionService[T]): () => T = {
+    val future = submitFuture[T](work, completion)
+    () => future.get
+  }
+  private[sbt] def submitFuture[A](work: () => A, completion: JCompletionService[A]): JFuture[A] = {
+    val future = try completion.submit {
+      new Callable[A] {
+        def call =
+          try {
+            work()
+          } catch {
+            case _: InterruptedException =>
+              throw Incomplete(None, message = Some("cancelled"))
+          }
+      }
+    } catch {
+      case _: RejectedExecutionException =>
+        throw Incomplete(None, message = Some("cancelled"))
     }
-  def manage[A, T](service: CompletionService[A, T])(setup: A => Unit, cleanup: A => Unit): CompletionService[A, T] =
-    wrap(service) { (node, work) =>
-      () =>
-        setup(node)
-        try { work() }
-        finally { cleanup(node) }
+    future
+  }
+  def manage[A, T](
+      service: CompletionService[A, T]
+  )(setup: A => Unit, cleanup: A => Unit): CompletionService[A, T] =
+    wrap(service) { (node, work) => () =>
+      setup(node)
+      try {
+        work()
+      } finally {
+        cleanup(node)
+      }
     }
-  def wrap[A, T](service: CompletionService[A, T])(w: (A, () => T) => (() => T)): CompletionService[A, T] =
+  def wrap[A, T](
+      service: CompletionService[A, T]
+  )(w: (A, () => T) => (() => T)): CompletionService[A, T] =
     new CompletionService[A, T] {
       def submit(node: A, work: () => T) = service.submit(node, w(node, work))
       def take() = service.take()
     }
-}
\ No newline at end of file
+}
diff --git a/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala b/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
index ab89e1772..f57b2f02e 100644
--- a/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
+++ b/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
@@ -1,6 +1,18 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
+import java.util.concurrent.atomic.AtomicInteger
+
 import sbt.internal.util.AttributeKey
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.{ Future => JFuture, RejectedExecutionException }
+import scala.collection.mutable
 
 /**
  * Describes restrictions on concurrent execution for a set of tasks.
@@ -8,6 +20,7 @@ import sbt.internal.util.AttributeKey
  * @tparam A the type of a task
  */
 trait ConcurrentRestrictions[A] {
+
   /** Internal state type used to describe a set of tasks. */
   type G
 
@@ -33,11 +46,27 @@ trait ConcurrentRestrictions[A] {
   def valid(g: G): Boolean
 }
 
+private[sbt] sealed trait CancelSentiels {
+  def cancelSentinels(): Unit
+}
+
 import java.util.{ LinkedList, Queue }
 import java.util.concurrent.{ Executor, Executors, ExecutorCompletionService }
 import annotation.tailrec
 
 object ConcurrentRestrictions {
+  private[this] val completionServices = new java.util.WeakHashMap[CompletionService[_, _], Boolean]
+  import scala.collection.JavaConverters._
+  def cancelAll() = completionServices.keySet.asScala.toVector.foreach {
+    case a: AutoCloseable => a.close()
+    case _                =>
+  }
+
+  private[sbt] def cancelAllSentinels() = completionServices.keySet.asScala.toVector.foreach {
+    case a: CancelSentiels => a.cancelSentinels()
+    case _                 =>
+  }
+
   /**
    * A ConcurrentRestrictions instance that places no restrictions on concurrently executing tasks.
    * @param zero the constant placeholder used for t
@@ -51,22 +80,22 @@ object ConcurrentRestrictions {
       def valid(g: G) = true
     }
 
-  def limitTotal[A](i: Int): ConcurrentRestrictions[A] =
-    {
-      assert(i >= 1, "Maximum must be at least 1 (was " + i + ")")
-      new ConcurrentRestrictions[A] {
-        type G = Int
-        def empty = 0
-        def add(g: Int, a: A) = g + 1
-        def remove(g: Int, a: A) = g - 1
-        def valid(g: Int) = g <= i
-      }
+  def limitTotal[A](i: Int): ConcurrentRestrictions[A] = {
+    assert(i >= 1, "Maximum must be at least 1 (was " + i + ")")
+    new ConcurrentRestrictions[A] {
+      type G = Int
+      def empty = 0
+      def add(g: Int, a: A) = g + 1
+      def remove(g: Int, a: A) = g - 1
+      def valid(g: Int) = g <= i
     }
+  }
 
   /** A key object used for associating information with a task.*/
   final case class Tag(name: String)
 
-  val tagsKey = AttributeKey[TagMap]("tags", "Attributes restricting concurrent execution of tasks.")
+  val tagsKey =
+    AttributeKey[TagMap]("tags", "Attributes restricting concurrent execution of tasks.")
 
   /** A standard tag describing the number of tasks that do not otherwise have any tags.*/
   val Untagged = Tag("untagged")
@@ -75,6 +104,7 @@ object ConcurrentRestrictions {
   val All = Tag("all")
 
   type TagMap = Map[Tag, Int]
+  val TagMap = Map.empty[Tag, Int]
 
   /**
    * Implements concurrency restrictions on tasks based on Tags.
@@ -91,103 +121,195 @@ object ConcurrentRestrictions {
       def valid(g: TagMap) = validF(g)
     }
 
-  private[this] def merge[A](m: TagMap, a: A, get: A => TagMap)(f: (Int, Int) => Int): TagMap =
-    {
-      val aTags = get(a)
-      val base = merge(m, aTags)(f)
-      val un = if (aTags.isEmpty) update(base, Untagged, 1)(f) else base
-      update(un, All, 1)(f)
-    }
+  private[this] def merge[A](m: TagMap, a: A, get: A => TagMap)(f: (Int, Int) => Int): TagMap = {
+    val aTags = get(a)
+    val base = merge(m, aTags)(f)
+    val un = if (aTags.isEmpty) update(base, Untagged, 1)(f) else base
+    update(un, All, 1)(f)
+  }
 
-  private[this] def update[A, B](m: Map[A, B], a: A, b: B)(f: (B, B) => B): Map[A, B] =
-    {
-      val newb =
-        (m get a) match {
-          case Some(bv) => f(bv, b)
-          case None     => b
-        }
-      m.updated(a, newb)
-    }
+  private[this] def update[A, B](m: Map[A, B], a: A, b: B)(f: (B, B) => B): Map[A, B] = {
+    val newb =
+      (m get a) match {
+        case Some(bv) => f(bv, b)
+        case None     => b
+      }
+    m.updated(a, newb)
+  }
   private[this] def merge[A, B](m: Map[A, B], n: Map[A, B])(f: (B, B) => B): Map[A, B] =
-    (m /: n) { case (acc, (a, b)) => update(acc, a, b)(f) }
+    n.foldLeft(m) { case (acc, (a, b)) => update(acc, a, b)(f) }
+
+  private[this] val poolID = new AtomicInteger(1)
 
   /**
    * Constructs a CompletionService suitable for backing task execution based on the provided restrictions on concurrent task execution.
    * @return a pair, with _1 being the CompletionService and _2 a function to shutdown the service.
    * @tparam A the task type
-   * @tparam G describes a set of tasks
    * @tparam R the type of data that will be computed by the CompletionService.
    */
-  def completionService[A, R](tags: ConcurrentRestrictions[A], warn: String => Unit): (CompletionService[A, R], () => Unit) =
-    {
-      val pool = Executors.newCachedThreadPool()
-      (completionService[A, R](pool, tags, warn), () => pool.shutdownNow())
+  def completionService[A, R](
+      tags: ConcurrentRestrictions[A],
+      warn: String => Unit
+  ): (CompletionService[A, R], () => Unit) = {
+    val id = poolID.getAndIncrement
+    val i = new AtomicInteger(1)
+    val pool = Executors.newCachedThreadPool { r =>
+      new Thread(r, s"sbt-completion-service-pool-$id-${i.getAndIncrement()}")
     }
+    val service = completionService[A, R](pool, tags, warn)
+    (service, () => { pool.shutdownNow(); () })
+  }
+
+  def completionService[A, R](
+      tags: ConcurrentRestrictions[A],
+      warn: String => Unit,
+      isSentinel: A => Boolean
+  ): (CompletionService[A, R], () => Unit) = {
+    val pool = Executors.newCachedThreadPool()
+    val service = completionService[A, R](pool, tags, warn, isSentinel)
+    (service, () => {
+      pool.shutdownNow()
+      ()
+    })
+  }
+
+  def cancellableCompletionService[A, R](
+      tags: ConcurrentRestrictions[A],
+      warn: String => Unit,
+      isSentinel: A => Boolean
+  ): (CompletionService[A, R], Boolean => Unit) = {
+    val pool = Executors.newCachedThreadPool()
+    val service = completionService[A, R](pool, tags, warn, isSentinel)
+    (service, force => {
+      if (force) service.close()
+      pool.shutdownNow()
+      ()
+    })
+  }
+
+  def completionService[A, R](
+      backing: Executor,
+      tags: ConcurrentRestrictions[A],
+      warn: String => Unit
+  ): CompletionService[A, R] with AutoCloseable = {
+    completionService[A, R](backing, tags, warn, (_: A) => false)
+  }
 
   /**
    * Constructs a CompletionService suitable for backing task execution based on the provided restrictions on concurrent task execution
    * and using the provided Executor to manage execution on threads.
    */
-  def completionService[A, R](backing: Executor, tags: ConcurrentRestrictions[A], warn: String => Unit): CompletionService[A, R] =
-    {
-      /** Represents submitted work for a task.*/
-      final class Enqueue(val node: A, val work: () => R)
+  def completionService[A, R](
+      backing: Executor,
+      tags: ConcurrentRestrictions[A],
+      warn: String => Unit,
+      isSentinel: A => Boolean,
+  ): CompletionService[A, R] with CancelSentiels with AutoCloseable = {
 
-      new CompletionService[A, R] {
-        /** Backing service used to manage execution on threads once all constraints are satisfied. */
-        private[this] val jservice = new ExecutorCompletionService[R](backing)
-        /** The description of the currently running tasks, used by `tags` to manage restrictions.*/
-        private[this] var tagState = tags.empty
-        /** The number of running tasks. */
-        private[this] var running = 0
-        /** Tasks that cannot be run yet because they cannot execute concurrently with the currently running tasks.*/
-        private[this] val pending = new LinkedList[Enqueue]
+    // Represents submitted work for a task.
+    final class Enqueue(val node: A, val work: () => R)
 
-        def submit(node: A, work: () => R): Unit = synchronized {
+    new CompletionService[A, R] with CancelSentiels with AutoCloseable {
+      completionServices.put(this, true)
+      private[this] val closed = new AtomicBoolean(false)
+      override def close(): Unit = if (closed.compareAndSet(false, true)) {
+        completionServices.remove(this)
+        ()
+      }
+
+      /** Backing service used to manage execution on threads once all constraints are satisfied. */
+      private[this] val jservice = new ExecutorCompletionService[R](backing)
+
+      /** The description of the currently running tasks, used by `tags` to manage restrictions.*/
+      private[this] var tagState = tags.empty
+
+      /** The number of running tasks. */
+      private[this] var running = 0
+
+      /** Tasks that cannot be run yet because they cannot execute concurrently with the currently running tasks.*/
+      private[this] val pending = new LinkedList[Enqueue]
+
+      private[this] val sentinels: mutable.ListBuffer[JFuture[_]] = mutable.ListBuffer.empty
+
+      def cancelSentinels(): Unit = {
+        sentinels.toList foreach { s =>
+          s.cancel(true)
+        }
+        sentinels.clear
+      }
+
+      def submit(node: A, work: () => R): Unit = synchronized {
+        if (closed.get) throw new RejectedExecutionException
+        else if (isSentinel(node)) {
+          // skip all checks for sentinels
+          sentinels += CompletionService.submitFuture(work, jservice)
+        } else {
           val newState = tags.add(tagState, node)
           // if the new task is allowed to run concurrently with the currently running tasks,
           //   submit it to be run by the backing j.u.c.CompletionService
           if (tags valid newState) {
             tagState = newState
             submitValid(node, work)
+            ()
           } else {
             if (running == 0) errorAddingToIdle()
             pending.add(new Enqueue(node, work))
+            ()
           }
         }
-        private[this] def submitValid(node: A, work: () => R) =
-          {
-            running += 1
-            val wrappedWork = () => try work() finally cleanup(node)
-            CompletionService.submit(wrappedWork, jservice)
-          }
-        private[this] def cleanup(node: A): Unit = synchronized {
-          running -= 1
-          tagState = tags.remove(tagState, node)
-          if (!tags.valid(tagState)) warn("Invalid restriction: removing a completed node from a valid system must result in a valid system.")
-          submitValid(new LinkedList)
+        ()
+      }
+      private[this] def submitValid(node: A, work: () => R): Unit = {
+        running += 1
+        val wrappedWork = () =>
+          try work()
+          finally cleanup(node)
+        CompletionService.submitFuture(wrappedWork, jservice)
+        ()
+      }
+      private[this] def cleanup(node: A): Unit = synchronized {
+        running -= 1
+        tagState = tags.remove(tagState, node)
+        if (!tags.valid(tagState)) {
+          warn(
+            "Invalid restriction: removing a completed node from a valid system must result in a valid system."
+          )
+          ()
         }
-        private[this] def errorAddingToIdle() = warn("Invalid restriction: adding a node to an idle system must be allowed.")
+        submitValid(new LinkedList)
+      }
+      private[this] def errorAddingToIdle() =
+        warn("Invalid restriction: adding a node to an idle system must be allowed.")
 
-        /** Submits pending tasks that are now allowed to executed. */
-        @tailrec private[this] def submitValid(tried: Queue[Enqueue]): Unit =
-          if (pending.isEmpty) {
-            if (!tried.isEmpty) {
-              if (running == 0) errorAddingToIdle()
-              pending.addAll(tried)
-            }
+      /** Submits pending tasks that are now allowed to executed. */
+      @tailrec private[this] def submitValid(tried: Queue[Enqueue]): Unit =
+        if (pending.isEmpty) {
+          if (!tried.isEmpty) {
+            if (running == 0) errorAddingToIdle()
+            pending.addAll(tried)
+            ()
+          }
+        } else {
+          val next = pending.remove()
+          val newState = tags.add(tagState, next.node)
+          if (tags.valid(newState)) {
+            tagState = newState
+            submitValid(next.node, next.work)
+            ()
           } else {
-            val next = pending.remove()
-            val newState = tags.add(tagState, next.node)
-            if (tags.valid(newState)) {
-              tagState = newState
-              submitValid(next.node, next.work)
-            } else
-              tried.add(next)
-            submitValid(tried)
+            tried.add(next)
+            ()
           }
+          submitValid(tried)
+        }
 
-        def take(): R = jservice.take().get()
+      def take(): R = {
+        if (closed.get)
+          throw new RejectedExecutionException(
+            "Tried to get values for a closed completion service"
+          )
+        jservice.take().get()
       }
     }
+  }
 }
diff --git a/tasks/src/main/scala/sbt/Execute.scala b/tasks/src/main/scala/sbt/Execute.scala
index 8f03ee557..de2100154 100644
--- a/tasks/src/main/scala/sbt/Execute.scala
+++ b/tasks/src/main/scala/sbt/Execute.scala
@@ -1,11 +1,18 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
+import java.util.concurrent.ExecutionException
+
 import sbt.internal.util.ErrorHandling.wideConvert
-import sbt.internal.util.{ DelegatingPMap, PMap, RMap, IDSet, ~> }
+import sbt.internal.util.{ DelegatingPMap, IDSet, PMap, RMap, ~> }
 import sbt.internal.util.Types._
+import sbt.internal.util.Util.nilSeq
 import Execute._
 
 import scala.annotation.tailrec
@@ -14,65 +21,84 @@ import scala.collection.JavaConverters._
 import mutable.Map
 
 private[sbt] object Execute {
-  def idMap[A, B]: Map[A, B] = (new java.util.IdentityHashMap[A, B]).asScala
-  def pMap[A[_], B[_]]: PMap[A, B] = new DelegatingPMap[A, B](idMap)
+  def idMap[A1, A2]: Map[A1, A2] = (new java.util.IdentityHashMap[A1, A2]).asScala
+  def pMap[F1[_], F2[_]]: PMap[F1, F2] = new DelegatingPMap[F1, F2](idMap)
   private[sbt] def completed(p: => Unit): Completed = new Completed {
     def process(): Unit = p
   }
-  def noTriggers[A[_]] = new Triggers[A](Map.empty, Map.empty, idFun)
+  def noTriggers[F[_]] = new Triggers[F](Map.empty, Map.empty, idFun)
 
-  def config(checkCycles: Boolean, overwriteNode: Incomplete => Boolean = const(false)): Config = new Config(checkCycles, overwriteNode)
-  final class Config private[sbt] (val checkCycles: Boolean, val overwriteNode: Incomplete => Boolean)
+  def config(checkCycles: Boolean, overwriteNode: Incomplete => Boolean = const(false)): Config =
+    new Config(checkCycles, overwriteNode)
+  final class Config private[sbt] (
+      val checkCycles: Boolean,
+      val overwriteNode: Incomplete => Boolean
+  )
 
-  final val checkPreAndPostConditions = sys.props.get("sbt.execute.extrachecks").exists(java.lang.Boolean.parseBoolean)
+  final val checkPreAndPostConditions =
+    sys.props.get("sbt.execute.extrachecks").exists(java.lang.Boolean.parseBoolean)
 }
 sealed trait Completed {
   def process(): Unit
 }
-private[sbt] trait NodeView[A[_]] {
-  def apply[T](a: A[T]): Node[A, T]
-  def inline[T](a: A[T]): Option[() => T]
+private[sbt] trait NodeView[F[_]] {
+  def apply[A](a: F[A]): Node[F, A]
+  def inline[A](a: F[A]): Option[() => A]
 }
-final class Triggers[A[_]](val runBefore: collection.Map[A[_], Seq[A[_]]], val injectFor: collection.Map[A[_], Seq[A[_]]], val onComplete: RMap[A, Result] => RMap[A, Result])
+final class Triggers[F[_]](
+    val runBefore: collection.Map[F[_], Seq[F[_]]],
+    val injectFor: collection.Map[F[_], Seq[F[_]]],
+    val onComplete: RMap[F, Result] => RMap[F, Result]
+)
 
-private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Triggers[A], progress: ExecuteProgress[A])(implicit view: NodeView[A]) {
-  type Strategy = CompletionService[A[_], Completed]
+private[sbt] final class Execute[F[_] <: AnyRef](
+    config: Config,
+    triggers: Triggers[F],
+    progress: ExecuteProgress[F]
+)(implicit view: NodeView[F]) {
+  type Strategy = CompletionService[F[_], Completed]
 
-  private[this] val forward = idMap[A[_], IDSet[A[_]]]
-  private[this] val reverse = idMap[A[_], Iterable[A[_]]]
-  private[this] val callers = pMap[A, Compose[IDSet, A]#Apply]
-  private[this] val state = idMap[A[_], State]
-  private[this] val viewCache = pMap[A, ({ type l[t] = Node[A, t] })#l]
-  private[this] val results = pMap[A, Result]
+  private[this] val forward = idMap[F[_], IDSet[F[_]]]
+  private[this] val reverse = idMap[F[_], Iterable[F[_]]]
+  private[this] val callers = pMap[F, Compose[IDSet, F]#Apply]
+  private[this] val state = idMap[F[_], State]
+  private[this] val viewCache = pMap[F, Node[F, *]]
+  private[this] val results = pMap[F, Result]
 
-  private[this] val getResult: A ~> Result = new (A ~> Result) {
-    def apply[T](a: A[T]): Result[T] = view.inline(a) match {
-      case Some(v) => Value(v())
-      case None    => results(a)
-    }
-  }
-  private[this] var progressState: progress.S = progress.initial
-
-  private[this]type State = State.Value
+  private[this] val getResult: F ~> Result = λ[F ~> Result](
+    a =>
+      view.inline(a) match {
+        case Some(v) => Value(v())
+        case None    => results(a)
+      }
+  )
+  private[this] type State = State.Value
   private[this] object State extends Enumeration {
     val Pending, Running, Calling, Done = Value
   }
   import State.{ Pending, Running, Calling, Done }
 
-  def dump: String = "State: " + state.toString + "\n\nResults: " + results + "\n\nCalls: " + callers + "\n\n"
+  val init = progress.initial()
 
-  def run[T](root: A[T])(implicit strategy: Strategy): Result[T] = try { runKeep(root)(strategy)(root) } catch { case i: Incomplete => Inc(i) }
-  def runKeep[T](root: A[T])(implicit strategy: Strategy): RMap[A, Result] =
-    {
-      assert(state.isEmpty, "Execute already running/ran.")
+  def dump: String =
+    "State: " + state.toString + "\n\nResults: " + results + "\n\nCalls: " + callers + "\n\n"
 
-      addNew(root)
-      processAll()
-      assert(results contains root, "No result for root node.")
-      val finalResults = triggers.onComplete(results)
-      progressState = progress.allCompleted(progressState, finalResults)
-      finalResults
-    }
+  def run[A](root: F[A])(implicit strategy: Strategy): Result[A] =
+    try {
+      runKeep(root)(strategy)(root)
+    } catch { case i: Incomplete => Inc(i) }
+
+  def runKeep[A](root: F[A])(implicit strategy: Strategy): RMap[F, Result] = {
+    assert(state.isEmpty, "Execute already running/ran.")
+
+    addNew(root)
+    processAll()
+    assert(results contains root, "No result for root node.")
+    val finalResults = triggers.onComplete(results)
+    progress.afterAllCompleted(finalResults)
+    progress.stop()
+    finalResults
+  }
 
   def processAll()(implicit strategy: Strategy): Unit = {
     @tailrec def next(): Unit = {
@@ -80,11 +106,22 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
         assert(reverse.nonEmpty, "Nothing to process.")
         if (!state.values.exists(_ == Running)) {
           snapshotCycleCheck()
-          assert(false, "Internal task engine error: nothing running.  This usually indicates a cycle in tasks.\n  Calling tasks (internal task engine state):\n" + dumpCalling)
+          assert(
+            false,
+            "Internal task engine error: nothing running.  This usually indicates a cycle in tasks.\n  Calling tasks (internal task engine state):\n" + dumpCalling
+          )
         }
       }
 
-      (strategy.take()).process()
+      try {
+        strategy.take().process()
+      } catch {
+        case e: ExecutionException =>
+          e.getCause match {
+            case oom: OutOfMemoryError => throw oom
+            case _                     => throw e
+          }
+      }
       if (reverse.nonEmpty) next()
     }
     next()
@@ -96,7 +133,7 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
   }
   def dumpCalling: String = state.filter(_._2 == Calling).mkString("\n\t")
 
-  def call[T](node: A[T], target: A[T])(implicit strategy: Strategy): Unit = {
+  def call[A](node: F[A], target: F[A])(implicit strategy: Strategy): Unit = {
     if (config.checkCycles) cycleCheck(node, target)
     pre {
       assert(running(node))
@@ -122,7 +159,7 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
     }
   }
 
-  def retire[T](node: A[T], result: Result[T])(implicit strategy: Strategy): Unit = {
+  def retire[A](node: F[A], result: Result[A])(implicit strategy: Strategy): Unit = {
     pre {
       assert(running(node) | calling(node))
       readyInv(node)
@@ -130,10 +167,16 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
 
     results(node) = result
     state(node) = Done
-    progressState = progress.completed(progressState, node, result)
-    remove(reverse, node) foreach { dep => notifyDone(node, dep) }
-    callers.remove(node).toList.flatten.foreach { c => retire(c, callerResult(c, result)) }
-    triggeredBy(node) foreach { t => addChecked(t) }
+    progress.afterCompleted(node, result)
+    remove(reverse.asInstanceOf[Map[F[A], Iterable[F[_]]]], node) foreach { dep =>
+      notifyDone(node, dep)
+    }
+    callers.remove(node).toList.flatten.foreach { c =>
+      retire(c, callerResult(c, result))
+    }
+    triggeredBy(node) foreach { t =>
+      addChecked(t)
+    }
 
     post {
       assert(done(node))
@@ -144,42 +187,49 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
       assert(triggeredBy(node) forall added)
     }
   }
-  def callerResult[T](node: A[T], result: Result[T]): Result[T] =
+  def callerResult[A](node: F[A], result: Result[A]): Result[A] =
     result match {
-      case _: Value[T] => result
+      case _: Value[A] => result
       case Inc(i)      => Inc(Incomplete(Some(node), tpe = i.tpe, causes = i :: Nil))
     }
 
-  def notifyDone(node: A[_], dependent: A[_])(implicit strategy: Strategy): Unit = {
+  def notifyDone(node: F[_], dependent: F[_])(implicit strategy: Strategy): Unit = {
     val f = forward(dependent)
     f -= node
     if (f.isEmpty) {
-      remove(forward, dependent)
+      remove[F[_], IDSet[F[_]]](forward, dependent)
       ready(dependent)
     }
   }
+
   /**
    * Ensures the given node has been added to the system.
    * Once added, a node is pending until its inputs and dependencies have completed.
    * Its computation is then evaluated and made available for nodes that have it as an input.
    */
-  def addChecked[T](node: A[T])(implicit strategy: Strategy): Unit = {
+  def addChecked[A](node: F[A])(implicit strategy: Strategy): Unit = {
     if (!added(node)) addNew(node)
 
     post { addedInv(node) }
   }
+
   /**
    * Adds a node that has not yet been registered with the system.
    * If all of the node's dependencies have finished, the node's computation is scheduled to run.
    * The node's dependencies will be added (transitively) if they are not already registered.
    */
-  def addNew[T](node: A[T])(implicit strategy: Strategy): Unit = {
+  def addNew[A](node: F[A])(implicit strategy: Strategy): Unit = {
     pre { newPre(node) }
 
     val v = register(node)
     val deps = dependencies(v) ++ runBefore(node)
-    val active = IDSet[A[_]](deps filter notDone)
-    progressState = progress.registered(progressState, node, deps, active.toList /** active is mutable, so take a snapshot */ )
+    val active = IDSet[F[_]](deps filter notDone)
+    progress.afterRegistered(
+      node,
+      deps,
+      active.toList
+      /* active is mutable, so take a snapshot */
+    )
 
     if (active.isEmpty)
       ready(node)
@@ -198,8 +248,9 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
       if (pending(node)) pendingInv(node)
     }
   }
+
   /** Called when a pending 'node' becomes runnable.  All of its dependencies must be done.  This schedules the node's computation with 'strategy'.*/
-  def ready[T](node: A[T])(implicit strategy: Strategy): Unit = {
+  def ready[A](node: F[A])(implicit strategy: Strategy): Unit = {
     pre {
       assert(pending(node))
       readyInv(node)
@@ -207,7 +258,7 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
     }
 
     state(node) = Running
-    progressState = progress.ready(progressState, node)
+    progress.afterReady(node)
     submit(node)
 
     post {
@@ -216,83 +267,92 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
       assert(running(node))
     }
   }
+
   /** Enters the given node into the system. */
-  def register[T](node: A[T]): Node[A, T] =
-    {
-      state(node) = Pending
-      reverse(node) = Seq()
-      viewCache.getOrUpdate(node, view(node))
-    }
+  def register[A](node: F[A]): Node[F, A] = {
+    state(node) = Pending
+    reverse(node) = Seq()
+    viewCache.getOrUpdate(node, view(node))
+  }
+
   /** Send the work for this node to the provided Strategy. */
-  def submit[T](node: A[T])(implicit strategy: Strategy): Unit = {
+  def submit[A](node: F[A])(implicit strategy: Strategy): Unit = {
     val v = viewCache(node)
     val rs = v.alist.transform(v.in, getResult)
     strategy.submit(node, () => work(node, v.work(rs)))
   }
+
   /**
    * Evaluates the computation 'f' for 'node'.
    * This returns a Completed instance, which contains the post-processing to perform after the result is retrieved from the Strategy.
    */
-  def work[T](node: A[T], f: => Either[A[T], T])(implicit strategy: Strategy): Completed =
-    {
-      progress.workStarting(node)
-      val rawResult = wideConvert(f).left.map {
-        case i: Incomplete => if (config.overwriteNode(i)) i.copy(node = Some(node)) else i
-        case e             => Incomplete(Some(node), Incomplete.Error, directCause = Some(e))
-      }
-      val result = rewrap(rawResult)
-      progress.workFinished(node, result)
-      completed {
-        result match {
-          case Right(v)     => retire(node, v)
-          case Left(target) => call(node, target)
-        }
+  def work[A](node: F[A], f: => Either[F[A], A])(implicit strategy: Strategy): Completed = {
+    progress.beforeWork(node)
+    val rawResult = wideConvert(f).left.map {
+      case i: Incomplete => if (config.overwriteNode(i)) i.copy(node = Some(node)) else i
+      case e             => Incomplete(Some(node), Incomplete.Error, directCause = Some(e))
+    }
+    val result = rewrap(rawResult)
+    progress.afterWork(node, result)
+    completed {
+      result match {
+        case Right(v)     => retire(node, v)
+        case Left(target) => call(node, target)
       }
     }
-  private[this] def rewrap[T](rawResult: Either[Incomplete, Either[A[T], T]]): Either[A[T], Result[T]] =
+  }
+  private[this] def rewrap[A](
+      rawResult: Either[Incomplete, Either[F[A], A]]
+  ): Either[F[A], Result[A]] =
     rawResult match {
       case Left(i)             => Right(Inc(i))
       case Right(Right(v))     => Right(Value(v))
       case Right(Left(target)) => Left(target)
     }
 
-  def remove[K, V](map: Map[K, V], k: K): V = map.remove(k).getOrElse(sys.error("Key '" + k + "' not in map :\n" + map))
+  def remove[K, V](map: Map[K, V], k: K): V =
+    map.remove(k).getOrElse(sys.error("Key '" + k + "' not in map :\n" + map))
 
-  def addReverse(node: A[_], dependent: A[_]): Unit = reverse(node) ++= Seq(dependent)
-  def addCaller[T](caller: A[T], target: A[T]): Unit = callers.getOrUpdate(target, IDSet.create[A[T]]) += caller
+  def addReverse(node: F[_], dependent: F[_]): Unit = reverse(node) ++= Seq(dependent)
+  def addCaller[A](caller: F[A], target: F[A]): Unit =
+    callers.getOrUpdate(target, IDSet.create[F[A]]) += caller
 
-  def dependencies(node: A[_]): Iterable[A[_]] = dependencies(viewCache(node))
-  def dependencies(v: Node[A, _]): Iterable[A[_]] = v.alist.toList(v.in).filter(dep => view.inline(dep).isEmpty)
+  def dependencies(node: F[_]): Iterable[F[_]] = dependencies(viewCache(node))
+  def dependencies(v: Node[F, _]): Iterable[F[_]] =
+    v.alist.toList(v.in).filter(dep => view.inline(dep).isEmpty)
 
-  def runBefore(node: A[_]): Seq[A[_]] = getSeq(triggers.runBefore, node)
-  def triggeredBy(node: A[_]): Seq[A[_]] = getSeq(triggers.injectFor, node)
-  def getSeq(map: collection.Map[A[_], Seq[A[_]]], node: A[_]): Seq[A[_]] = map.getOrElse(node, Nil)
+  def runBefore(node: F[_]): Seq[F[_]] = getSeq(triggers.runBefore, node)
+  def triggeredBy(node: F[_]): Seq[F[_]] = getSeq(triggers.injectFor, node)
+  def getSeq(map: collection.Map[F[_], Seq[F[_]]], node: F[_]): Seq[F[_]] =
+    map.getOrElse(node, nilSeq[F[_]])
 
   // Contracts
 
-  def addedInv(node: A[_]): Unit = topologicalSort(node) foreach addedCheck
-  def addedCheck(node: A[_]): Unit = {
+  def addedInv(node: F[_]): Unit = topologicalSort(node) foreach addedCheck
+  def addedCheck(node: F[_]): Unit = {
     assert(added(node), "Not added: " + node)
     assert(viewCache contains node, "Not in view cache: " + node)
     dependencyCheck(node)
   }
-  def dependencyCheck(node: A[_]): Unit = {
+  def dependencyCheck(node: F[_]): Unit = {
     dependencies(node) foreach { dep =>
-      def onOpt[T](o: Option[T])(f: T => Boolean) = o match { case None => false; case Some(x) => f(x) }
+      def onOpt[A](o: Option[A])(f: A => Boolean) = o match {
+        case None => false; case Some(x) => f(x)
+      }
       def checkForward = onOpt(forward.get(node)) { _ contains dep }
       def checkReverse = onOpt(reverse.get(dep)) { _.exists(_ == node) }
       assert(done(dep) ^ (checkForward && checkReverse))
     }
   }
-  def pendingInv(node: A[_]): Unit = {
+  def pendingInv(node: F[_]): Unit = {
     assert(atState(node, Pending))
     assert((dependencies(node) ++ runBefore(node)) exists notDone)
   }
-  def runningInv(node: A[_]): Unit = {
+  def runningInv(node: F[_]): Unit = {
     assert(dependencies(node) forall done)
     assert(!(forward contains node))
   }
-  def newPre(node: A[_]): Unit = {
+  def newPre(node: F[_]): Unit = {
     isNew(node)
     assert(!(reverse contains node))
     assert(!(forward contains node))
@@ -301,18 +361,19 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
     assert(!(results contains node))
   }
 
-  def topologicalSort(node: A[_]): Seq[A[_]] =
-    {
-      val seen = IDSet.create[A[_]]
-      def visit(n: A[_]): List[A[_]] =
-        (seen process n)(List[A[_]]()) {
-          node :: (List[A[_]]() /: dependencies(n)) { (ss, dep) => visit(dep) ::: ss }
+  def topologicalSort(node: F[_]): Seq[F[_]] = {
+    val seen = IDSet.create[F[_]]
+    def visit(n: F[_]): List[F[_]] =
+      (seen process n)(List[F[_]]()) {
+        node :: dependencies(n).foldLeft(List[F[_]]()) { (ss, dep) =>
+          visit(dep) ::: ss
         }
+      }
 
-      visit(node).reverse
-    }
+    visit(node).reverse
+  }
 
-  def readyInv(node: A[_]): Unit = {
+  def readyInv(node: F[_]): Unit = {
     assert(dependencies(node) forall done)
     assert(!(forward contains node))
   }
@@ -320,29 +381,40 @@ private[sbt] final class Execute[A[_] <: AnyRef](config: Config, triggers: Trigg
   // cyclic reference checking
 
   def snapshotCycleCheck(): Unit =
-    for ((called: A[c], callers) <- callers.toSeq; caller <- callers)
-      cycleCheck(caller.asInstanceOf[A[c]], called)
+    callers.toSeq foreach {
+      case (called: F[c], callers) =>
+        for (caller <- callers) cycleCheck(caller.asInstanceOf[F[c]], called)
+      case _ => ()
+    }
 
-  def cycleCheck[T](node: A[T], target: A[T]): Unit = {
+  def cycleCheck[A](node: F[A], target: F[A]): Unit = {
     if (node eq target) cyclic(node, target, "Cannot call self")
-    val all = IDSet.create[A[T]]
-    def allCallers(n: A[T]): Unit = (all process n)(()) { callers.get(n).toList.flatten.foreach(allCallers) }
+    val all = IDSet.create[F[A]]
+    def allCallers(n: F[A]): Unit = (all process n)(()) {
+      callers.get(n).toList.flatten.foreach(allCallers)
+    }
     allCallers(node)
     if (all contains target) cyclic(node, target, "Cyclic reference")
   }
-  def cyclic[T](caller: A[T], target: A[T], msg: String) = throw new Incomplete(Some(caller), message = Some(msg), directCause = Some(new CyclicException(caller, target, msg)))
-  final class CyclicException[T](val caller: A[T], val target: A[T], msg: String) extends Exception(msg)
+  def cyclic[A](caller: F[A], target: F[A], msg: String) =
+    throw new Incomplete(
+      Some(caller),
+      message = Some(msg),
+      directCause = Some(new CyclicException(caller, target, msg))
+    )
+  final class CyclicException[A](val caller: F[A], val target: F[A], msg: String)
+      extends Exception(msg)
 
   // state testing
 
-  def pending(d: A[_]) = atState(d, Pending)
-  def running(d: A[_]) = atState(d, Running)
-  def calling(d: A[_]) = atState(d, Calling)
-  def done(d: A[_]) = atState(d, Done)
-  def notDone(d: A[_]) = !done(d)
-  def atState(d: A[_], s: State) = state.get(d) == Some(s)
-  def isNew(d: A[_]) = !added(d)
-  def added(d: A[_]) = state contains d
+  def pending(d: F[_]) = atState(d, Pending)
+  def running(d: F[_]) = atState(d, Running)
+  def calling(d: F[_]) = atState(d, Calling)
+  def done(d: F[_]) = atState(d, Done)
+  def notDone(d: F[_]) = !done(d)
+  def atState(d: F[_], s: State) = state.get(d) == Some(s)
+  def isNew(d: F[_]) = !added(d)
+  def added(d: F[_]) = state contains d
   def complete = state.values.forall(_ == Done)
 
   def pre(f: => Unit) = if (checkPreAndPostConditions) f
diff --git a/tasks/src/main/scala/sbt/ExecuteProgress.scala b/tasks/src/main/scala/sbt/ExecuteProgress.scala
index 1610d986f..e52b743fd 100644
--- a/tasks/src/main/scala/sbt/ExecuteProgress.scala
+++ b/tasks/src/main/scala/sbt/ExecuteProgress.scala
@@ -1,3 +1,10 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
 import sbt.internal.util.RMap
@@ -7,32 +14,29 @@ import sbt.internal.util.RMap
  * All methods are called from the same thread except `started` and `finished`,
  * which is called from the executing task's thread.
  * All methods should return quickly to avoid task execution overhead.
- *
- * This class is experimental and subject to binary and source incompatible changes at any time.
  */
-private[sbt] trait ExecuteProgress[A[_]] {
-  type S
-  def initial: S
+trait ExecuteProgress[F[_]] {
+  def initial(): Unit
 
   /**
    * Notifies that a `task` has been registered in the system for execution.
    * The dependencies of `task` are `allDeps` and the subset of those dependencies that
    * have not completed are `pendingDeps`.
    */
-  def registered(state: S, task: A[_], allDeps: Iterable[A[_]], pendingDeps: Iterable[A[_]]): S
+  def afterRegistered(task: F[_], allDeps: Iterable[F[_]], pendingDeps: Iterable[F[_]]): Unit
 
   /**
    * Notifies that all of the dependencies of `task` have completed and `task` is therefore
    * ready to run.  The task has not been scheduled on a thread yet.
    */
-  def ready(state: S, task: A[_]): S
+  def afterReady(task: F[_]): Unit
 
   /**
    * Notifies that the work for `task` is starting after this call returns.
    * This is called from the thread the task executes on, unlike most other methods in this callback.
    * It is called immediately before the task's work starts with minimal intervening executor overhead.
    */
-  def workStarting(task: A[_]): Unit
+  def beforeWork(task: F[_]): Unit
 
   /**
    * Notifies that the work for `task` work has finished.  The task may have computed the next task to
@@ -42,29 +46,68 @@ private[sbt] trait ExecuteProgress[A[_]] {
    * This is called from the thread the task executes on, unlike most other methods in this callback.
    * It is immediately called after the task's work is complete with minimal intervening executor overhead.
    */
-  def workFinished[T](task: A[T], result: Either[A[T], Result[T]]): Unit
+  def afterWork[A](task: F[A], result: Either[F[A], Result[A]]): Unit
 
   /**
    * Notifies that `task` has completed.
    * The task's work is done with a final `result`.
    * Any tasks called by `task` have completed.
    */
-  def completed[T](state: S, task: A[T], result: Result[T]): S
+  def afterCompleted[A](task: F[A], result: Result[A]): Unit
 
   /** All tasks have completed with the final `results` provided. */
-  def allCompleted(state: S, results: RMap[A, Result]): S
+  def afterAllCompleted(results: RMap[F, Result]): Unit
+
+  /** Notifies that either all tasks have finished or cancelled. */
+  def stop(): Unit
 }
 
 /** This module is experimental and subject to binary and source incompatible changes at any time. */
-private[sbt] object ExecuteProgress {
-  def empty[A[_]]: ExecuteProgress[A] = new ExecuteProgress[A] {
-    type S = Unit
-    def initial = ()
-    def registered(state: Unit, task: A[_], allDeps: Iterable[A[_]], pendingDeps: Iterable[A[_]]) = ()
-    def ready(state: Unit, task: A[_]) = ()
-    def workStarting(task: A[_]) = ()
-    def workFinished[T](task: A[T], result: Either[A[T], Result[T]]) = ()
-    def completed[T](state: Unit, task: A[T], result: Result[T]) = ()
-    def allCompleted(state: Unit, results: RMap[A, Result]) = ()
+object ExecuteProgress {
+  def empty[F[_]]: ExecuteProgress[F] = new ExecuteProgress[F] {
+    override def initial(): Unit = ()
+    override def afterRegistered(
+        task: F[_],
+        allDeps: Iterable[F[_]],
+        pendingDeps: Iterable[F[_]]
+    ): Unit =
+      ()
+    override def afterReady(task: F[_]): Unit = ()
+    override def beforeWork(task: F[_]): Unit = ()
+    override def afterWork[A](task: F[A], result: Either[F[A], Result[A]]): Unit = ()
+    override def afterCompleted[A](task: F[A], result: Result[A]): Unit = ()
+    override def afterAllCompleted(results: RMap[F, Result]): Unit = ()
+    override def stop(): Unit = ()
+  }
+
+  def aggregate[F[_]](reporters: Seq[ExecuteProgress[F]]) = new ExecuteProgress[F] {
+    override def initial(): Unit = {
+      reporters foreach { _.initial() }
+    }
+    override def afterRegistered(
+        task: F[_],
+        allDeps: Iterable[F[_]],
+        pendingDeps: Iterable[F[_]]
+    ): Unit = {
+      reporters foreach { _.afterRegistered(task, allDeps, pendingDeps) }
+    }
+    override def afterReady(task: F[_]): Unit = {
+      reporters foreach { _.afterReady(task) }
+    }
+    override def beforeWork(task: F[_]): Unit = {
+      reporters foreach { _.beforeWork(task) }
+    }
+    override def afterWork[A](task: F[A], result: Either[F[A], Result[A]]): Unit = {
+      reporters foreach { _.afterWork(task, result) }
+    }
+    override def afterCompleted[A](task: F[A], result: Result[A]): Unit = {
+      reporters foreach { _.afterCompleted(task, result) }
+    }
+    override def afterAllCompleted(results: RMap[F, Result]): Unit = {
+      reporters foreach { _.afterAllCompleted(results) }
+    }
+    override def stop(): Unit = {
+      reporters foreach { _.stop() }
+    }
   }
 }
diff --git a/tasks/src/main/scala/sbt/Incomplete.scala b/tasks/src/main/scala/sbt/Incomplete.scala
index 37484653b..59232f24a 100644
--- a/tasks/src/main/scala/sbt/Incomplete.scala
+++ b/tasks/src/main/scala/sbt/Incomplete.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import scala.collection.mutable.ListBuffer
@@ -17,9 +21,16 @@ import Incomplete.{ Error, Value => IValue }
  * @param causes a list of incompletions that prevented `node` from completing
  * @param directCause the exception that caused `node` to not complete
  */
-final case class Incomplete(node: Option[AnyRef], tpe: IValue = Error, message: Option[String] = None, causes: Seq[Incomplete] = Nil, directCause: Option[Throwable] = None)
-    extends Exception(message.orNull, directCause.orNull) with sbt.internal.util.UnprintableException {
-  override def toString = "Incomplete(node=" + node + ", tpe=" + tpe + ", msg=" + message + ", causes=" + causes + ", directCause=" + directCause + ")"
+final case class Incomplete(
+    node: Option[AnyRef],
+    tpe: IValue = Error,
+    message: Option[String] = None,
+    causes: Seq[Incomplete] = Nil,
+    directCause: Option[Throwable] = None
+) extends Exception(message.orNull, directCause.orNull)
+    with sbt.internal.util.UnprintableException {
+  override def toString =
+    "Incomplete(node=" + node + ", tpe=" + tpe + ", msg=" + message + ", causes=" + causes + ", directCause=" + directCause + ")"
 }
 
 object Incomplete extends Enumeration {
@@ -27,17 +38,17 @@ object Incomplete extends Enumeration {
 
   def transformTD(i: Incomplete)(f: Incomplete => Incomplete): Incomplete = transform(i, true)(f)
   def transformBU(i: Incomplete)(f: Incomplete => Incomplete): Incomplete = transform(i, false)(f)
-  def transform(i: Incomplete, topDown: Boolean)(f: Incomplete => Incomplete): Incomplete =
-    {
-      import collection.JavaConverters._
-      val visited: collection.mutable.Map[Incomplete, Incomplete] = (new java.util.IdentityHashMap[Incomplete, Incomplete]).asScala
-      def visit(inc: Incomplete): Incomplete =
-        visited.getOrElseUpdate(inc, if (topDown) visitCauses(f(inc)) else f(visitCauses(inc)))
-      def visitCauses(inc: Incomplete): Incomplete =
-        inc.copy(causes = inc.causes.map(visit))
+  def transform(i: Incomplete, topDown: Boolean)(f: Incomplete => Incomplete): Incomplete = {
+    import collection.JavaConverters._
+    val visited: collection.mutable.Map[Incomplete, Incomplete] =
+      (new java.util.IdentityHashMap[Incomplete, Incomplete]).asScala
+    def visit(inc: Incomplete): Incomplete =
+      visited.getOrElseUpdate(inc, if (topDown) visitCauses(f(inc)) else f(visitCauses(inc)))
+    def visitCauses(inc: Incomplete): Incomplete =
+      inc.copy(causes = inc.causes.map(visit))
 
-      visit(i)
-    }
+    visit(i)
+  }
   def visitAll(i: Incomplete)(f: Incomplete => Unit): Unit = {
     val visited = IDSet.create[Incomplete]
     def visit(inc: Incomplete): Unit =
@@ -47,19 +58,17 @@ object Incomplete extends Enumeration {
       }
     visit(i)
   }
-  def linearize(i: Incomplete): Seq[Incomplete] =
-    {
-      val ordered = ListBuffer[Incomplete]()
-      visitAll(i) { ordered += _ }
-      ordered.toList
-    }
+  def linearize(i: Incomplete): Seq[Incomplete] = {
+    val ordered = ListBuffer[Incomplete]()
+    visitAll(i) { ordered += _ }
+    ordered.toList
+  }
   def allExceptions(is: Seq[Incomplete]): Iterable[Throwable] =
     allExceptions(new Incomplete(None, causes = is))
-  def allExceptions(i: Incomplete): Iterable[Throwable] =
-    {
-      val exceptions = IDSet.create[Throwable]
-      visitAll(i) { exceptions ++= _.directCause.toList }
-      exceptions.all
-    }
+  def allExceptions(i: Incomplete): Iterable[Throwable] = {
+    val exceptions = IDSet.create[Throwable]
+    visitAll(i) { exceptions ++= _.directCause.toList }
+    exceptions.all
+  }
   def show(tpe: Value) = tpe match { case Skipped => "skipped"; case Error => "error" }
 }
diff --git a/tasks/src/main/scala/sbt/Node.scala b/tasks/src/main/scala/sbt/Node.scala
index e3892bb07..fac5cff58 100644
--- a/tasks/src/main/scala/sbt/Node.scala
+++ b/tasks/src/main/scala/sbt/Node.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import sbt.internal.util.AList
diff --git a/tasks/src/main/scala/sbt/Result.scala b/tasks/src/main/scala/sbt/Result.scala
index 62b2f1fa1..973e9d559 100644
--- a/tasks/src/main/scala/sbt/Result.scala
+++ b/tasks/src/main/scala/sbt/Result.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2010 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import sbt.internal.util.~>
@@ -11,10 +15,12 @@ import sbt.internal.util.~>
 sealed trait Result[+T] {
   def toEither: Either[Incomplete, T]
 }
+
 /** Indicates the task did not complete normally and so it does not have a value.*/
 final case class Inc(cause: Incomplete) extends Result[Nothing] {
   def toEither: Either[Incomplete, Nothing] = Left(cause)
 }
+
 /** Indicates the task completed normally and produced the given `value`.*/
 final case class Value[+T](value: T) extends Result[T] {
   def toEither: Either[Incomplete, T] = Right(value)
@@ -22,18 +28,14 @@ final case class Value[+T](value: T) extends Result[T] {
 
 object Result {
   type Id[X] = X
-  val tryValue = new (Result ~> Id) {
-    def apply[T](r: Result[T]): T =
-      r match {
-        case Value(v) => v
-        case Inc(i)   => throw i
-      }
+  val tryValue = λ[Result ~> Id] {
+    case Value(v) => v
+    case Inc(i)   => throw i
+  }
+  def tryValues[S](r: Seq[Result[Unit]], v: Result[S]): S = {
+    r foreach tryValue[Unit]
+    tryValue[S](v)
   }
-  def tryValues[S](r: Seq[Result[Unit]], v: Result[S]): S =
-    {
-      r foreach tryValue[Unit]
-      tryValue[S](v)
-    }
   implicit def fromEither[T](e: Either[Incomplete, T]): Result[T] = e match {
     case Left(i)  => Inc(i)
     case Right(v) => Value(v)
diff --git a/testing/NOTICE b/testing/NOTICE
index 2853703b9..36daa88f1 100644
--- a/testing/NOTICE
+++ b/testing/NOTICE
@@ -1,3 +1,4 @@
-Simple Build Tool: Testing Component
-Copyright 2008, 2009, 2010  Steven Blundy, Mark Harrah, Josh Cough
-Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
+sbt: Testing Component
+Copyright 2011 - 2017, Lightbend, Inc.
+Copyright 2008 - 2010, Mark Harrah, Steven Blundy, Josh Cough
+Licensed under BSD-3-Clause license (see LICENSE)
diff --git a/testing/agent/src/main/java/sbt/ForkConfiguration.java b/testing/agent/src/main/java/sbt/ForkConfiguration.java
index 9f51e9c69..5a357ae24 100644
--- a/testing/agent/src/main/java/sbt/ForkConfiguration.java
+++ b/testing/agent/src/main/java/sbt/ForkConfiguration.java
@@ -1,21 +1,28 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt;
 
 import java.io.Serializable;
 
 public final class ForkConfiguration implements Serializable {
-	private final boolean ansiCodesSupported;
-	private final boolean parallel;
+  private final boolean ansiCodesSupported;
+  private final boolean parallel;
 
-	public ForkConfiguration(final boolean ansiCodesSupported, final boolean parallel) {
-		this.ansiCodesSupported = ansiCodesSupported;
-		this.parallel = parallel;
-	}
+  public ForkConfiguration(final boolean ansiCodesSupported, final boolean parallel) {
+    this.ansiCodesSupported = ansiCodesSupported;
+    this.parallel = parallel;
+  }
 
-	public boolean isAnsiCodesSupported() {
-		return ansiCodesSupported;
-	}
+  public boolean isAnsiCodesSupported() {
+    return ansiCodesSupported;
+  }
 
-	public boolean isParallel() {
-		return parallel;
-	}
+  public boolean isParallel() {
+    return parallel;
+  }
 }
diff --git a/testing/agent/src/main/java/sbt/ForkMain.java b/testing/agent/src/main/java/sbt/ForkMain.java
index b7871ecde..2ba171603 100644
--- a/testing/agent/src/main/java/sbt/ForkMain.java
+++ b/testing/agent/src/main/java/sbt/ForkMain.java
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2012 Eugene Vigdorchik
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt;
 
 import sbt.testing.*;
@@ -13,330 +17,485 @@ import java.net.Socket;
 import java.net.InetAddress;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
+import java.util.LinkedHashSet;
 import java.util.concurrent.*;
 
-final public class ForkMain {
+public final class ForkMain {
 
-	// serializables
-	// -----------------------------------------------------------------------------
+  // serializables
+  // -----------------------------------------------------------------------------
 
-	final static class SubclassFingerscan implements SubclassFingerprint, Serializable {
-		private final boolean isModule;
-		private final String superclassName;
-		private final boolean requireNoArgConstructor;
-		SubclassFingerscan(final SubclassFingerprint print) {
-			isModule = print.isModule();
-			superclassName = print.superclassName();
-			requireNoArgConstructor = print.requireNoArgConstructor();
-		}
-		public boolean isModule() { return isModule; }
-		public String superclassName() { return superclassName; }
-		public boolean requireNoArgConstructor() { return requireNoArgConstructor; }
-	}
+  static final class SubclassFingerscan implements SubclassFingerprint, Serializable {
+    private final boolean isModule;
+    private final String superclassName;
+    private final boolean requireNoArgConstructor;
 
-	final static class AnnotatedFingerscan implements AnnotatedFingerprint, Serializable {
-		private final boolean isModule;
-		private final String annotationName;
-		AnnotatedFingerscan(final AnnotatedFingerprint print) {
-			isModule = print.isModule();
-			annotationName = print.annotationName();
-		}
-		public boolean isModule() { return isModule; }
-		public String annotationName() { return annotationName; }
-	}
+    SubclassFingerscan(final SubclassFingerprint print) {
+      isModule = print.isModule();
+      superclassName = print.superclassName();
+      requireNoArgConstructor = print.requireNoArgConstructor();
+    }
 
-	final static class ForkEvent implements Event, Serializable {
-		private final String fullyQualifiedName;
-		private final Fingerprint fingerprint;
-		private final Selector selector;
-		private final Status status;
-		private final OptionalThrowable throwable;
-		private final long duration;
+    public boolean isModule() {
+      return isModule;
+    }
 
-		ForkEvent(final Event e) {
-			fullyQualifiedName = e.fullyQualifiedName();
-			final Fingerprint rawFingerprint = e.fingerprint();
+    public String superclassName() {
+      return superclassName;
+    }
 
-			if (rawFingerprint instanceof SubclassFingerprint)
-				fingerprint = new SubclassFingerscan((SubclassFingerprint) rawFingerprint);
-			else
-				fingerprint = new AnnotatedFingerscan((AnnotatedFingerprint) rawFingerprint);
+    public boolean requireNoArgConstructor() {
+      return requireNoArgConstructor;
+    }
+  }
 
-			selector = e.selector();
-			checkSerializableSelector(selector);
-			status = e.status();
-			final OptionalThrowable originalThrowable = e.throwable();
+  static final class AnnotatedFingerscan implements AnnotatedFingerprint, Serializable {
+    private final boolean isModule;
+    private final String annotationName;
 
-			if (originalThrowable.isDefined())
-				throwable = new OptionalThrowable(new ForkError(originalThrowable.get()));
-			else
-				throwable = originalThrowable;
+    AnnotatedFingerscan(final AnnotatedFingerprint print) {
+      isModule = print.isModule();
+      annotationName = print.annotationName();
+    }
 
-			duration = e.duration();
-		}
+    public boolean isModule() {
+      return isModule;
+    }
 
-		public String fullyQualifiedName() { return fullyQualifiedName; }
-		public Fingerprint fingerprint() { return fingerprint; }
-		public Selector selector() { return selector; }
-		public Status status() { return status; }
-		public OptionalThrowable throwable() { return throwable; }
-		public long duration() { return duration; }
+    public String annotationName() {
+      return annotationName;
+    }
+  }
 
-		private static void checkSerializableSelector(final Selector selector) {
-			if (! (selector instanceof Serializable)) {
-				throw new UnsupportedOperationException("Selector implementation must be Serializable, but " + selector.getClass().getName() + " is not.");
-			}
-		}
-	}
+  static final class ForkEvent implements Event, Serializable {
+    private final String fullyQualifiedName;
+    private final Fingerprint fingerprint;
+    private final Selector selector;
+    private final Status status;
+    private final OptionalThrowable throwable;
+    private final long duration;
 
-	// -----------------------------------------------------------------------------
+    ForkEvent(final Event e) {
+      fullyQualifiedName = e.fullyQualifiedName();
+      final Fingerprint rawFingerprint = e.fingerprint();
 
+      if (rawFingerprint instanceof SubclassFingerprint)
+        fingerprint = new SubclassFingerscan((SubclassFingerprint) rawFingerprint);
+      else fingerprint = new AnnotatedFingerscan((AnnotatedFingerprint) rawFingerprint);
 
-	final static class ForkError extends Exception {
-		private final String originalMessage;
-		private final String originalName;
-		private ForkError cause;
-		ForkError(final Throwable t) {
-			originalMessage = t.getMessage();
-			originalName = t.getClass().getName();
-			setStackTrace(t.getStackTrace());
-			if (t.getCause() != null) cause = new ForkError(t.getCause());
-		}
-		public String getMessage() { return originalName + ": " + originalMessage; }
-		public Exception getCause() { return cause; }
-	}
+      selector = e.selector();
+      checkSerializableSelector(selector);
+      status = e.status();
+      final OptionalThrowable originalThrowable = e.throwable();
 
+      if (originalThrowable.isDefined())
+        throwable = new OptionalThrowable(new ForkError(originalThrowable.get()));
+      else throwable = originalThrowable;
 
-	// main
-	// ----------------------------------------------------------------------------------------------------------------
+      duration = e.duration();
+    }
 
-	public static void main(final String[] args) throws Exception {
-		final Socket socket = new Socket(InetAddress.getByName(null), Integer.valueOf(args[0]));
-		final ObjectInputStream is = new ObjectInputStream(socket.getInputStream());
-		final ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());
-		// Must flush the header that the constructor writes, otherwise the ObjectInputStream on the other end may block indefinitely
-		os.flush();
-		try {
-			new Run().run(is, os);
-		} finally {
-			try {
-				is.close();
-				os.close();
-			} finally {
-				System.exit(0);
-			}
-		}
-	}
+    public String fullyQualifiedName() {
+      return fullyQualifiedName;
+    }
 
-	// ----------------------------------------------------------------------------------------------------------------
+    public Fingerprint fingerprint() {
+      return fingerprint;
+    }
 
+    public Selector selector() {
+      return selector;
+    }
 
-	final private static class Run {
+    public Status status() {
+      return status;
+    }
 
-		private void run(final ObjectInputStream is, final ObjectOutputStream os) {
-			try {
-				runTests(is, os);
-			} catch (final RunAborted e) {
-				internalError(e);
-			} catch (final Throwable t) {
-				try {
-					logError(os, "Uncaught exception when running tests: " + t.toString());
-					write(os, new ForkError(t));
-				} catch (final Throwable t2) {
-					internalError(t2);
-				}
-			}
-		}
+    public OptionalThrowable throwable() {
+      return throwable;
+    }
 
-		private boolean matches(final Fingerprint f1, final Fingerprint f2) {
-			if (f1 instanceof SubclassFingerprint && f2 instanceof SubclassFingerprint) {
-				final SubclassFingerprint sf1 = (SubclassFingerprint) f1;
-				final SubclassFingerprint sf2 = (SubclassFingerprint) f2;
-				return sf1.isModule() == sf2.isModule() && sf1.superclassName().equals(sf2.superclassName());
-			} else if (f1 instanceof AnnotatedFingerprint && f2 instanceof AnnotatedFingerprint) {
-				final AnnotatedFingerprint af1 = (AnnotatedFingerprint) f1;
-				final AnnotatedFingerprint af2 = (AnnotatedFingerprint) f2;
-				return af1.isModule() == af2.isModule() && af1.annotationName().equals(af2.annotationName());
-			}
-			return false;
-		}
+    public long duration() {
+      return duration;
+    }
 
-		class RunAborted extends RuntimeException {
-			RunAborted(final Exception e) { super(e); }
-		}
+    private static void checkSerializableSelector(final Selector selector) {
+      if (!(selector instanceof Serializable)) {
+        throw new UnsupportedOperationException(
+            "Selector implementation must be Serializable, but "
+                + selector.getClass().getName()
+                + " is not.");
+      }
+    }
+  }
 
-		private synchronized void write(final ObjectOutputStream os, final Object obj) {
-			try {
-				os.writeObject(obj);
-				os.flush();
-			} catch (final IOException e) {
-				throw new RunAborted(e);
-			}
-		}
+  // -----------------------------------------------------------------------------
 
-		private void log(final ObjectOutputStream os, final String message, final ForkTags level) {
-			write(os, new Object[]{level, message});
-		}
+  static final class ForkError extends Exception {
+    private final String originalMessage;
+    private final String originalName;
+    private ForkError cause;
 
-		private void logDebug(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Debug); }
-		private void logInfo(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Info); }
-		private void logWarn(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Warn); }
-		private void logError(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Error); }
+    ForkError(final Throwable t) {
+      originalMessage = t.getMessage();
+      originalName = t.getClass().getName();
+      setStackTrace(t.getStackTrace());
+      if (t.getCause() != null) cause = new ForkError(t.getCause());
+    }
 
-		private Logger remoteLogger(final boolean ansiCodesSupported, final ObjectOutputStream os) {
-			return new Logger() {
-				public boolean ansiCodesSupported() { return ansiCodesSupported; }
-				public void error(final String s) { logError(os, s); }
-				public void warn(final String s) { logWarn(os, s); }
-				public void info(final String s) { logInfo(os, s); }
-				public void debug(final String s) { logDebug(os, s); }
-				public void trace(final Throwable t) { write(os, new ForkError(t)); }
-			};
-		}
+    public String getMessage() {
+      return originalName + ": " + originalMessage;
+    }
 
-		private void writeEvents(final ObjectOutputStream os, final TaskDef taskDef, final ForkEvent[] events) {
-			write(os, new Object[]{taskDef.fullyQualifiedName(), events});
-		}
+    public Exception getCause() {
+      return cause;
+    }
+  }
 
-		private ExecutorService executorService(final ForkConfiguration config, final ObjectOutputStream os) {
-			if(config.isParallel()) {
-				final int nbThreads = Runtime.getRuntime().availableProcessors();
-				logDebug(os, "Create a test executor with a thread pool of " + nbThreads + " threads.");
-				// more options later...
-				// TODO we might want to configure the blocking queue with size #proc
-				return Executors.newFixedThreadPool(nbThreads);
-			} else {
-				logDebug(os, "Create a single-thread test executor");
-				return Executors.newSingleThreadExecutor();
-			}
-		}
+  // main
+  // ----------------------------------------------------------------------------------------------------------------
 
-		private void runTests(final ObjectInputStream is, final ObjectOutputStream os) throws Exception {
-			final ForkConfiguration config = (ForkConfiguration) is.readObject();
-			final ExecutorService executor = executorService(config, os);
-			final TaskDef[] tests = (TaskDef[]) is.readObject();
-			final int nFrameworks = is.readInt();
-			final Logger[] loggers = { remoteLogger(config.isAnsiCodesSupported(), os) };
+  public static void main(final String[] args) throws Exception {
+    ClassLoader classLoader = new Run().getClass().getClassLoader();
+    try {
+      main(args, classLoader);
+    } finally {
+      System.exit(0);
+    }
+  }
 
-			for (int i = 0; i < nFrameworks; i++) {
-				final String[] implClassNames = (String[]) is.readObject();
-				final String[] frameworkArgs = (String[]) is.readObject();
-				final String[] remoteFrameworkArgs = (String[]) is.readObject();
+  public static void main(final String[] args, ClassLoader classLoader) throws Exception {
+    final Socket socket = new Socket(InetAddress.getByName(null), Integer.valueOf(args[0]));
+    final ObjectInputStream is = new ObjectInputStream(socket.getInputStream());
+    final ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());
+    // Must flush the header that the constructor writes, otherwise the ObjectInputStream on the
+    // other end may block indefinitely
+    os.flush();
+    try {
+      new Run().run(is, os, classLoader);
+    } finally {
+      is.close();
+      os.close();
+    }
+  }
 
-				Framework framework = null;
-				for (final String implClassName : implClassNames) {
-					try {
-						final Object rawFramework = Class.forName(implClassName).newInstance();
-						if (rawFramework instanceof Framework)
-							framework = (Framework) rawFramework;
-						else
-							framework = new FrameworkWrapper((org.scalatools.testing.Framework) rawFramework);
-						break;
-					} catch (final ClassNotFoundException e) {
-						logDebug(os, "Framework implementation '" + implClassName + "' not present.");
-					}
-				}
+  // ----------------------------------------------------------------------------------------------------------------
 
-				if (framework == null)
-					continue;
+  private static final class Run {
 
-				final ArrayList<TaskDef> filteredTests = new ArrayList<TaskDef>();
-				for (final Fingerprint testFingerprint : framework.fingerprints()) {
-					for (final TaskDef test : tests) {
-						// TODO: To pass in correct explicitlySpecified and selectors
-						if (matches(testFingerprint, test.fingerprint()))
-							filteredTests.add(new TaskDef(test.fullyQualifiedName(), test.fingerprint(), test.explicitlySpecified(), test.selectors()));
-					}
-				}
-				final Runner runner = framework.runner(frameworkArgs, remoteFrameworkArgs, getClass().getClassLoader());
-				final Task[] tasks = runner.tasks(filteredTests.toArray(new TaskDef[filteredTests.size()]));
-				logDebug(os, "Runner for " + framework.getClass().getName() + " produced " + tasks.length + " initial tasks for " + filteredTests.size() + " tests.");
+    private void run(
+        final ObjectInputStream is, final ObjectOutputStream os, ClassLoader classLoader) {
+      try {
+        runTests(is, os, classLoader);
+      } catch (final RunAborted e) {
+        internalError(e);
+      } catch (final Throwable t) {
+        try {
+          logError(os, "Uncaught exception when running tests: " + t.toString());
+          write(os, new ForkError(t));
+        } catch (final Throwable t2) {
+          internalError(t2);
+        }
+      }
+    }
 
-				runTestTasks(executor, tasks, loggers, os);
+    private boolean matches(final Fingerprint f1, final Fingerprint f2) {
+      if (f1 instanceof SubclassFingerprint && f2 instanceof SubclassFingerprint) {
+        final SubclassFingerprint sf1 = (SubclassFingerprint) f1;
+        final SubclassFingerprint sf2 = (SubclassFingerprint) f2;
+        return sf1.isModule() == sf2.isModule()
+            && sf1.superclassName().equals(sf2.superclassName());
+      } else if (f1 instanceof AnnotatedFingerprint && f2 instanceof AnnotatedFingerprint) {
+        final AnnotatedFingerprint af1 = (AnnotatedFingerprint) f1;
+        final AnnotatedFingerprint af2 = (AnnotatedFingerprint) f2;
+        return af1.isModule() == af2.isModule()
+            && af1.annotationName().equals(af2.annotationName());
+      }
+      return false;
+    }
 
-				runner.done();
-			}
-			write(os, ForkTags.Done);
-			is.readObject();
-		}
+    class RunAborted extends RuntimeException {
+      RunAborted(final Exception e) {
+        super(e);
+      }
+    }
 
-		private void runTestTasks(final ExecutorService executor, final Task[] tasks, final Logger[] loggers, final ObjectOutputStream os) {
-			if( tasks.length > 0 ) {
-				final List<Future<Task[]>> futureNestedTasks = new ArrayList<Future<Task[]>>();
-				for( final Task task : tasks ) {
-					futureNestedTasks.add(runTest(executor, task, loggers, os));
-				}
+    private synchronized void write(final ObjectOutputStream os, final Object obj) {
+      try {
+        os.writeObject(obj);
+        os.flush();
+      } catch (final IOException e) {
+        throw new RunAborted(e);
+      }
+    }
 
-				// Note: this could be optimized further, we could have a callback once a test finishes that executes immediately the nested tasks
-				//       At the moment, I'm especially interested in JUnit, which doesn't have nested tasks.
-				final List<Task> nestedTasks = new ArrayList<Task>();
-				for( final Future<Task[]> futureNestedTask : futureNestedTasks ) {
-					try {
-						nestedTasks.addAll( Arrays.asList(futureNestedTask.get()));
-					} catch (final Exception e) {
-						logError(os, "Failed to execute task " + futureNestedTask);
-					}
-				}
-				runTestTasks(executor, nestedTasks.toArray(new Task[nestedTasks.size()]), loggers, os);
-			}
-		}
+    private void log(final ObjectOutputStream os, final String message, final ForkTags level) {
+      write(os, new Object[] {level, message});
+    }
 
-		private Future<Task[]> runTest(final ExecutorService executor, final Task task, final Logger[] loggers, final ObjectOutputStream os) {
-			return executor.submit(new Callable<Task[]>() {
-				@Override
-				public Task[] call() {
-					ForkEvent[] events;
-					Task[] nestedTasks;
-					final TaskDef taskDef = task.taskDef();
-					try {
-						final List<ForkEvent> eventList = new ArrayList<ForkEvent>();
-						final EventHandler handler = new EventHandler() { public void handle(final Event e){ eventList.add(new ForkEvent(e)); } };
-						logDebug(os, "  Running " + taskDef);
-						nestedTasks = task.execute(handler, loggers);
-						if(nestedTasks.length > 0 || eventList.size() > 0)
-							logDebug(os, "    Produced " + nestedTasks.length + " nested tasks and " + eventList.size() + " events.");
-						events = eventList.toArray(new ForkEvent[eventList.size()]);
-					}
-					catch (final Throwable t) {
-						nestedTasks = new Task[0];
-						events = new ForkEvent[] { testError(os, taskDef, "Uncaught exception when running " + taskDef.fullyQualifiedName() + ": " + t.toString(), t) };
-					}
-					writeEvents(os, taskDef, events);
-					return nestedTasks;
-				}
-			});
-		}
+    private void logDebug(final ObjectOutputStream os, final String message) {
+      log(os, message, ForkTags.Debug);
+    }
 
-		private void internalError(final Throwable t) {
-			System.err.println("Internal error when running tests: " + t.toString());
-		}
+    private void logInfo(final ObjectOutputStream os, final String message) {
+      log(os, message, ForkTags.Info);
+    }
 
-		private ForkEvent testEvent(final String fullyQualifiedName, final Fingerprint fingerprint, final Selector selector, final Status r, final ForkError err, final long duration) {
-			final OptionalThrowable throwable;
-			if (err == null)
-				throwable = new OptionalThrowable();
-			else
-				throwable = new OptionalThrowable(err);
-			return new ForkEvent(new Event() {
-				public String fullyQualifiedName() { return fullyQualifiedName; }
-				public Fingerprint fingerprint() { return fingerprint; }
-				public Selector selector() { return selector; }
-				public Status status() { return r; }
-				public OptionalThrowable throwable() {
-					return throwable;
-				}
-				public long duration() {
-					return duration;
-				}
-			});
-		}
+    private void logWarn(final ObjectOutputStream os, final String message) {
+      log(os, message, ForkTags.Warn);
+    }
 
-		private ForkEvent testError(final ObjectOutputStream os, final TaskDef taskDef, final String message, final Throwable t) {
-			logError(os, message);
-			final ForkError fe = new ForkError(t);
-			write(os, fe);
-			return testEvent(taskDef.fullyQualifiedName(), taskDef.fingerprint(), new SuiteSelector(), Status.Error, fe, 0);
-		}
-	}
+    private void logError(final ObjectOutputStream os, final String message) {
+      log(os, message, ForkTags.Error);
+    }
+
+    private Logger remoteLogger(final boolean ansiCodesSupported, final ObjectOutputStream os) {
+      return new Logger() {
+        public boolean ansiCodesSupported() {
+          return ansiCodesSupported;
+        }
+
+        public void error(final String s) {
+          logError(os, s);
+        }
+
+        public void warn(final String s) {
+          logWarn(os, s);
+        }
+
+        public void info(final String s) {
+          logInfo(os, s);
+        }
+
+        public void debug(final String s) {
+          logDebug(os, s);
+        }
+
+        public void trace(final Throwable t) {
+          write(os, new ForkError(t));
+        }
+      };
+    }
+
+    private void writeEvents(
+        final ObjectOutputStream os, final TaskDef taskDef, final ForkEvent[] events) {
+      write(os, new Object[] {taskDef.fullyQualifiedName(), events});
+    }
+
+    private ExecutorService executorService(
+        final ForkConfiguration config, final ObjectOutputStream os) {
+      if (config.isParallel()) {
+        final int nbThreads = Runtime.getRuntime().availableProcessors();
+        logDebug(os, "Create a test executor with a thread pool of " + nbThreads + " threads.");
+        // more options later...
+        // TODO we might want to configure the blocking queue with size #proc
+        return Executors.newFixedThreadPool(nbThreads);
+      } else {
+        logDebug(os, "Create a single-thread test executor");
+        return Executors.newSingleThreadExecutor();
+      }
+    }
+
+    private void runTests(
+        final ObjectInputStream is, final ObjectOutputStream os, ClassLoader classLoader)
+        throws Exception {
+      final ForkConfiguration config = (ForkConfiguration) is.readObject();
+      final ExecutorService executor = executorService(config, os);
+      final TaskDef[] tests = (TaskDef[]) is.readObject();
+      final int nFrameworks = is.readInt();
+      final Logger[] loggers = {remoteLogger(config.isAnsiCodesSupported(), os)};
+
+      for (int i = 0; i < nFrameworks; i++) {
+        final String[] implClassNames = (String[]) is.readObject();
+        final String[] frameworkArgs = (String[]) is.readObject();
+        final String[] remoteFrameworkArgs = (String[]) is.readObject();
+
+        Framework framework = null;
+        for (final String implClassName : implClassNames) {
+          try {
+            final Object rawFramework =
+                Class.forName(implClassName).getDeclaredConstructor().newInstance();
+            if (rawFramework instanceof Framework) framework = (Framework) rawFramework;
+            else framework = new FrameworkWrapper((org.scalatools.testing.Framework) rawFramework);
+            break;
+          } catch (final ClassNotFoundException e) {
+            logDebug(os, "Framework implementation '" + implClassName + "' not present.");
+          }
+        }
+
+        if (framework == null) continue;
+
+        final LinkedHashSet<TaskDef> filteredTests = new LinkedHashSet<>();
+        for (final Fingerprint testFingerprint : framework.fingerprints()) {
+          for (final TaskDef test : tests) {
+            // TODO: To pass in correct explicitlySpecified and selectors
+            if (matches(testFingerprint, test.fingerprint()))
+              filteredTests.add(
+                  new TaskDef(
+                      test.fullyQualifiedName(),
+                      test.fingerprint(),
+                      test.explicitlySpecified(),
+                      test.selectors()));
+          }
+        }
+        final Runner runner = framework.runner(frameworkArgs, remoteFrameworkArgs, classLoader);
+        final Task[] tasks = runner.tasks(filteredTests.toArray(new TaskDef[filteredTests.size()]));
+        logDebug(
+            os,
+            "Runner for "
+                + framework.getClass().getName()
+                + " produced "
+                + tasks.length
+                + " initial tasks for "
+                + filteredTests.size()
+                + " tests.");
+
+        Thread callDoneOnShutdown = new Thread(() -> runner.done());
+        Runtime.getRuntime().addShutdownHook(callDoneOnShutdown);
+
+        runTestTasks(executor, tasks, loggers, os);
+
+        runner.done();
+
+        Runtime.getRuntime().removeShutdownHook(callDoneOnShutdown);
+      }
+      write(os, ForkTags.Done);
+      is.readObject();
+    }
+
+    private void runTestTasks(
+        final ExecutorService executor,
+        final Task[] tasks,
+        final Logger[] loggers,
+        final ObjectOutputStream os) {
+      if (tasks.length > 0) {
+        final List<Future<Task[]>> futureNestedTasks = new ArrayList<>();
+        for (final Task task : tasks) {
+          futureNestedTasks.add(runTest(executor, task, loggers, os));
+        }
+
+        // Note: this could be optimized further, we could have a callback once a test finishes that
+        // executes immediately the nested tasks
+        //       At the moment, I'm especially interested in JUnit, which doesn't have nested tasks.
+        final List<Task> nestedTasks = new ArrayList<>();
+        for (final Future<Task[]> futureNestedTask : futureNestedTasks) {
+          try {
+            nestedTasks.addAll(Arrays.asList(futureNestedTask.get()));
+          } catch (final Exception e) {
+            logError(os, "Failed to execute task " + futureNestedTask);
+          }
+        }
+        runTestTasks(executor, nestedTasks.toArray(new Task[nestedTasks.size()]), loggers, os);
+      }
+    }
+
+    private Future<Task[]> runTest(
+        final ExecutorService executor,
+        final Task task,
+        final Logger[] loggers,
+        final ObjectOutputStream os) {
+      return executor.submit(
+          () -> {
+            ForkEvent[] events;
+            Task[] nestedTasks;
+            final TaskDef taskDef = task.taskDef();
+            try {
+              final Collection<ForkEvent> eventList = new ConcurrentLinkedDeque<>();
+              final EventHandler handler =
+                  new EventHandler() {
+                    public void handle(final Event e) {
+                      eventList.add(new ForkEvent(e));
+                    }
+                  };
+              logDebug(os, "  Running " + taskDef);
+              nestedTasks = task.execute(handler, loggers);
+              if (nestedTasks.length > 0 || eventList.size() > 0)
+                logDebug(
+                    os,
+                    "    Produced "
+                        + nestedTasks.length
+                        + " nested tasks and "
+                        + eventList.size()
+                        + " events.");
+              events = eventList.toArray(new ForkEvent[eventList.size()]);
+            } catch (final Throwable t) {
+              nestedTasks = new Task[0];
+              events =
+                  new ForkEvent[] {
+                    testError(
+                        os,
+                        taskDef,
+                        "Uncaught exception when running "
+                            + taskDef.fullyQualifiedName()
+                            + ": "
+                            + t.toString(),
+                        t)
+                  };
+            }
+            writeEvents(os, taskDef, events);
+            return nestedTasks;
+          });
+    }
+
+    private void internalError(final Throwable t) {
+      System.err.println("Internal error when running tests: " + t.toString());
+    }
+
+    private ForkEvent testEvent(
+        final String fullyQualifiedName,
+        final Fingerprint fingerprint,
+        final Selector selector,
+        final Status r,
+        final ForkError err,
+        final long duration) {
+      final OptionalThrowable throwable;
+      if (err == null) throwable = new OptionalThrowable();
+      else throwable = new OptionalThrowable(err);
+      return new ForkEvent(
+          new Event() {
+            public String fullyQualifiedName() {
+              return fullyQualifiedName;
+            }
+
+            public Fingerprint fingerprint() {
+              return fingerprint;
+            }
+
+            public Selector selector() {
+              return selector;
+            }
+
+            public Status status() {
+              return r;
+            }
+
+            public OptionalThrowable throwable() {
+              return throwable;
+            }
+
+            public long duration() {
+              return duration;
+            }
+          });
+    }
+
+    private ForkEvent testError(
+        final ObjectOutputStream os,
+        final TaskDef taskDef,
+        final String message,
+        final Throwable t) {
+      logError(os, message);
+      final ForkError fe = new ForkError(t);
+      write(os, fe);
+      return testEvent(
+          taskDef.fullyQualifiedName(),
+          taskDef.fingerprint(),
+          new SuiteSelector(),
+          Status.Error,
+          fe,
+          0);
+    }
+  }
 }
diff --git a/testing/agent/src/main/java/sbt/ForkTags.java b/testing/agent/src/main/java/sbt/ForkTags.java
index 4318555ee..5f8022fed 100644
--- a/testing/agent/src/main/java/sbt/ForkTags.java
+++ b/testing/agent/src/main/java/sbt/ForkTags.java
@@ -1,8 +1,16 @@
-/* sbt -- Simple Build Tool
- * Copyright 2012 Eugene Vigdorchik
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt;
 
 public enum ForkTags {
-	Error, Warn, Info, Debug, Done
+  Error,
+  Warn,
+  Info,
+  Debug,
+  Done
 }
diff --git a/testing/agent/src/main/java/sbt/FrameworkWrapper.java b/testing/agent/src/main/java/sbt/FrameworkWrapper.java
index dd606ab54..22c94af0b 100644
--- a/testing/agent/src/main/java/sbt/FrameworkWrapper.java
+++ b/testing/agent/src/main/java/sbt/FrameworkWrapper.java
@@ -1,261 +1,327 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt;
 
 import sbt.testing.*;
 
 /**
- * Adapts the old {@link org.scalatools.testing.Framework} interface into the new
- * {@link sbt.testing.Framework}
+ * Adapts the old {@link org.scalatools.testing.Framework} interface into the new {@link
+ * sbt.testing.Framework}
  */
 final class FrameworkWrapper implements Framework {
 
-	private final org.scalatools.testing.Framework oldFramework;
+  private final org.scalatools.testing.Framework oldFramework;
 
-	FrameworkWrapper(final org.scalatools.testing.Framework oldFramework) {
-		this.oldFramework = oldFramework;
-	}
+  FrameworkWrapper(final org.scalatools.testing.Framework oldFramework) {
+    this.oldFramework = oldFramework;
+  }
 
-	public String name() {
-		return oldFramework.name();
-	}
+  public String name() {
+    return oldFramework.name();
+  }
 
-	public Fingerprint[] fingerprints() {
-		final org.scalatools.testing.Fingerprint[] oldFingerprints = oldFramework.tests();
-		final int length = oldFingerprints.length;
-		final Fingerprint[] fingerprints = new Fingerprint[length];
-		for (int i=0; i < length; i++) {
-			final org.scalatools.testing.Fingerprint oldFingerprint = oldFingerprints[i];
-			if (oldFingerprint instanceof org.scalatools.testing.TestFingerprint)
-				fingerprints[i] = new SubclassFingerprintWrapper((org.scalatools.testing.TestFingerprint) oldFingerprint);
-			else if (oldFingerprint instanceof org.scalatools.testing.SubclassFingerprint)
-				fingerprints[i] = new SubclassFingerprintWrapper((org.scalatools.testing.SubclassFingerprint) oldFingerprint);
-			else
-				fingerprints[i] = new AnnotatedFingerprintWrapper((org.scalatools.testing.AnnotatedFingerprint) oldFingerprint);
-		}
-		return fingerprints;
-	}
+  public Fingerprint[] fingerprints() {
+    final org.scalatools.testing.Fingerprint[] oldFingerprints = oldFramework.tests();
+    final int length = oldFingerprints.length;
+    final Fingerprint[] fingerprints = new Fingerprint[length];
+    for (int i = 0; i < length; i++) {
+      final org.scalatools.testing.Fingerprint oldFingerprint = oldFingerprints[i];
+      if (oldFingerprint instanceof org.scalatools.testing.TestFingerprint)
+        fingerprints[i] =
+            new SubclassFingerprintWrapper((org.scalatools.testing.TestFingerprint) oldFingerprint);
+      else if (oldFingerprint instanceof org.scalatools.testing.SubclassFingerprint)
+        fingerprints[i] =
+            new SubclassFingerprintWrapper(
+                (org.scalatools.testing.SubclassFingerprint) oldFingerprint);
+      else
+        fingerprints[i] =
+            new AnnotatedFingerprintWrapper(
+                (org.scalatools.testing.AnnotatedFingerprint) oldFingerprint);
+    }
+    return fingerprints;
+  }
 
-	public Runner runner(final String[] args, final String[] remoteArgs, final ClassLoader testClassLoader) {
-		return new RunnerWrapper(oldFramework, testClassLoader, args);
-	}
+  public Runner runner(
+      final String[] args, final String[] remoteArgs, final ClassLoader testClassLoader) {
+    return new RunnerWrapper(oldFramework, testClassLoader, args);
+  }
 }
 
 final class SubclassFingerprintWrapper implements SubclassFingerprint {
-	private final String superclassName;
-	private final boolean isModule;
-	private final boolean requireNoArgConstructor;
+  private final String superclassName;
+  private final boolean isModule;
+  private final boolean requireNoArgConstructor;
 
-	SubclassFingerprintWrapper(final org.scalatools.testing.SubclassFingerprint oldFingerprint) {
-		superclassName = oldFingerprint.superClassName();
-		isModule = oldFingerprint.isModule();
-		requireNoArgConstructor = false;  // Old framework SubclassFingerprint does not require no arg constructor
-	}
+  SubclassFingerprintWrapper(final org.scalatools.testing.SubclassFingerprint oldFingerprint) {
+    superclassName = oldFingerprint.superClassName();
+    isModule = oldFingerprint.isModule();
+    requireNoArgConstructor =
+        false; // Old framework SubclassFingerprint does not require no arg constructor
+  }
 
-	public boolean isModule() {
-		return isModule;
-	}
+  public boolean isModule() {
+    return isModule;
+  }
 
-	public String superclassName() {
-		return superclassName;
-	}
+  public String superclassName() {
+    return superclassName;
+  }
 
-	public boolean requireNoArgConstructor() {
-		return requireNoArgConstructor;
-	}
+  public boolean requireNoArgConstructor() {
+    return requireNoArgConstructor;
+  }
 }
 
 final class AnnotatedFingerprintWrapper implements AnnotatedFingerprint {
-	private final String annotationName;
-	private final boolean isModule;
+  private final String annotationName;
+  private final boolean isModule;
 
-	AnnotatedFingerprintWrapper(final org.scalatools.testing.AnnotatedFingerprint oldFingerprint) {
-		annotationName = oldFingerprint.annotationName();
-		isModule = oldFingerprint.isModule();
-	}
+  AnnotatedFingerprintWrapper(final org.scalatools.testing.AnnotatedFingerprint oldFingerprint) {
+    annotationName = oldFingerprint.annotationName();
+    isModule = oldFingerprint.isModule();
+  }
 
-	public boolean isModule() {
-		return isModule;
-	}
+  public boolean isModule() {
+    return isModule;
+  }
 
-	public String annotationName() {
-		return annotationName;
-	}
+  public String annotationName() {
+    return annotationName;
+  }
 }
 
 final class EventHandlerWrapper implements org.scalatools.testing.EventHandler {
 
-	private final EventHandler newEventHandler;
-	private final String fullyQualifiedName;
-	private final Fingerprint fingerprint;
+  private final EventHandler newEventHandler;
+  private final String fullyQualifiedName;
+  private final Fingerprint fingerprint;
 
-	EventHandlerWrapper(final EventHandler newEventHandler, final String fullyQualifiedName, final Fingerprint fingerprint) {
-		this.newEventHandler = newEventHandler;
-		this.fullyQualifiedName = fullyQualifiedName;
-		this.fingerprint = fingerprint;
-	}
+  EventHandlerWrapper(
+      final EventHandler newEventHandler,
+      final String fullyQualifiedName,
+      final Fingerprint fingerprint) {
+    this.newEventHandler = newEventHandler;
+    this.fullyQualifiedName = fullyQualifiedName;
+    this.fingerprint = fingerprint;
+  }
 
-	public void handle(final org.scalatools.testing.Event oldEvent) {
-		newEventHandler.handle(new EventWrapper(oldEvent, fullyQualifiedName, fingerprint));
-	}
+  public void handle(final org.scalatools.testing.Event oldEvent) {
+    newEventHandler.handle(new EventWrapper(oldEvent, fullyQualifiedName, fingerprint));
+  }
 }
 
 final class EventWrapper implements Event {
 
-	private final org.scalatools.testing.Event oldEvent;
-	private final String className;
-	private final Fingerprint fingerprint;
-	private final OptionalThrowable throwable;
+  private final org.scalatools.testing.Event oldEvent;
+  private final String className;
+  private final Fingerprint fingerprint;
+  private final OptionalThrowable throwable;
 
-	EventWrapper(final org.scalatools.testing.Event oldEvent, final String className, final Fingerprint fingerprint) {
-		this.oldEvent = oldEvent;
-		this.className = className;
-		this.fingerprint = fingerprint;
-		final Throwable oldThrowable = oldEvent.error();
-		if (oldThrowable == null)
-			throwable = new OptionalThrowable();
-		else
-			throwable = new OptionalThrowable(oldThrowable);
-	}
+  EventWrapper(
+      final org.scalatools.testing.Event oldEvent,
+      final String className,
+      final Fingerprint fingerprint) {
+    this.oldEvent = oldEvent;
+    this.className = className;
+    this.fingerprint = fingerprint;
+    final Throwable oldThrowable = oldEvent.error();
+    if (oldThrowable == null) throwable = new OptionalThrowable();
+    else throwable = new OptionalThrowable(oldThrowable);
+  }
 
-	public String fullyQualifiedName() {
-		return className;
-	}
+  public String fullyQualifiedName() {
+    return className;
+  }
 
-	public Fingerprint fingerprint() {
-		return fingerprint;
-	}
+  public Fingerprint fingerprint() {
+    return fingerprint;
+  }
 
-	public Selector selector() {
-		return new TestSelector(oldEvent.testName());
-	}
+  public Selector selector() {
+    return new TestSelector(oldEvent.testName());
+  }
 
-	public Status status() {
-		switch (oldEvent.result()) {
-			case Success:
-				return Status.Success;
-			case Error:
-				return Status.Error;
-			case Failure:
-				return Status.Failure;
-			case Skipped:
-				return Status.Skipped;
-			default:
-				throw new IllegalStateException("Invalid status.");
-		}
-	}
+  public Status status() {
+    switch (oldEvent.result()) {
+      case Success:
+        return Status.Success;
+      case Error:
+        return Status.Error;
+      case Failure:
+        return Status.Failure;
+      case Skipped:
+        return Status.Skipped;
+      default:
+        throw new IllegalStateException("Invalid status.");
+    }
+  }
 
-	public OptionalThrowable throwable() {
-		return throwable;
-	}
+  public OptionalThrowable throwable() {
+    return throwable;
+  }
 
-	public long duration() {
-		return -1;  // Just return -1 as old event does not have duration.
-	}
+  public long duration() {
+    return -1; // Just return -1 as old event does not have duration.
+  }
 }
 
 final class RunnerWrapper implements Runner {
 
-	private final org.scalatools.testing.Framework oldFramework;
-	private final ClassLoader testClassLoader;
-	private final String[] args;
+  private final org.scalatools.testing.Framework oldFramework;
+  private final ClassLoader testClassLoader;
+  private final String[] args;
 
-	RunnerWrapper(final org.scalatools.testing.Framework oldFramework, final ClassLoader testClassLoader, final String[] args) {
-		this.oldFramework = oldFramework;
-		this.testClassLoader = testClassLoader;
-		this.args = args;
-	}
+  RunnerWrapper(
+      final org.scalatools.testing.Framework oldFramework,
+      final ClassLoader testClassLoader,
+      final String[] args) {
+    this.oldFramework = oldFramework;
+    this.testClassLoader = testClassLoader;
+    this.args = args;
+  }
 
-	public Task[] tasks(final TaskDef[] taskDefs) {
-		final int length = taskDefs.length;
-		final Task[] tasks = new Task[length];
-		for (int i = 0; i < length; i++) {
-			final TaskDef taskDef = taskDefs[i];
-			tasks[i] = createTask(taskDef);
-		}
-		return tasks;
-	}
+  public Task[] tasks(final TaskDef[] taskDefs) {
+    final int length = taskDefs.length;
+    final Task[] tasks = new Task[length];
+    for (int i = 0; i < length; i++) {
+      final TaskDef taskDef = taskDefs[i];
+      tasks[i] = createTask(taskDef);
+    }
+    return tasks;
+  }
 
-	private Task createTask(final TaskDef taskDef) {
-		return new Task() {
-			public String[] tags() {
-				return new String[0];  // Old framework does not support tags
-			}
+  private Task createTask(final TaskDef taskDef) {
+    return new Task() {
+      public String[] tags() {
+        return new String[0]; // Old framework does not support tags
+      }
 
-			private org.scalatools.testing.Logger createOldLogger(final Logger logger) {
-				return new org.scalatools.testing.Logger() {
-					public boolean ansiCodesSupported() { return logger.ansiCodesSupported(); }
-					public void error(final String msg) { logger.error(msg); }
-					public void warn(final String msg) { logger.warn(msg); }
-					public void info(final String msg) { logger.info(msg); }
-					public void debug(final String msg) { logger.debug(msg); }
-					public void trace(final Throwable t) { logger.trace(t); }
-				};
-			}
+      private org.scalatools.testing.Logger createOldLogger(final Logger logger) {
+        return new org.scalatools.testing.Logger() {
+          public boolean ansiCodesSupported() {
+            return logger.ansiCodesSupported();
+          }
 
-			private void runRunner(final org.scalatools.testing.Runner runner, final Fingerprint fingerprint, final EventHandler eventHandler) {
-				// Old runner only support subclass fingerprint.
-				final SubclassFingerprint subclassFingerprint = (SubclassFingerprint) fingerprint;
-				final org.scalatools.testing.TestFingerprint oldFingerprint =
-					new org.scalatools.testing.TestFingerprint() {
-						public boolean isModule() { return subclassFingerprint.isModule(); }
-						public String superClassName() { return subclassFingerprint.superclassName(); }
-					};
-				final String name = taskDef.fullyQualifiedName();
-				runner.run(name, oldFingerprint, new EventHandlerWrapper(eventHandler, name, subclassFingerprint), args);
-			}
+          public void error(final String msg) {
+            logger.error(msg);
+          }
 
-			private void runRunner2(final org.scalatools.testing.Runner2 runner, final Fingerprint fingerprint, final EventHandler eventHandler) {
-				final org.scalatools.testing.Fingerprint oldFingerprint;
-				if (fingerprint instanceof SubclassFingerprint) {
-					final SubclassFingerprint subclassFingerprint = (SubclassFingerprint) fingerprint;
-					oldFingerprint = new org.scalatools.testing.SubclassFingerprint() {
-						public boolean isModule() { return subclassFingerprint.isModule(); }
-						public String superClassName() { return subclassFingerprint.superclassName(); }
-					};
-				}
-				else {
-					final AnnotatedFingerprint annotatedFingerprint = (AnnotatedFingerprint) fingerprint;
-					oldFingerprint = new org.scalatools.testing.AnnotatedFingerprint() {
-						public boolean isModule() { return annotatedFingerprint.isModule(); }
-						public String annotationName() { return annotatedFingerprint.annotationName(); }
-					};
-				}
-				final String name = taskDef.fullyQualifiedName();
-				runner.run(name, oldFingerprint, new EventHandlerWrapper(eventHandler, name, fingerprint), args);
-			}
+          public void warn(final String msg) {
+            logger.warn(msg);
+          }
 
-			public Task[] execute(final EventHandler eventHandler, final Logger[] loggers) {
-				final int length = loggers.length;
-				final org.scalatools.testing.Logger[] oldLoggers = new org.scalatools.testing.Logger[length];
-				for (int i=0; i<length; i++) {
-					oldLoggers[i] = createOldLogger(loggers[i]);
-				}
+          public void info(final String msg) {
+            logger.info(msg);
+          }
 
-				final org.scalatools.testing.Runner runner = oldFramework.testRunner(testClassLoader, oldLoggers);
-				final Fingerprint fingerprint = taskDef.fingerprint();
-				if (runner instanceof org.scalatools.testing.Runner2) {
-					runRunner2((org.scalatools.testing.Runner2) runner, fingerprint, eventHandler);
-				}
-				else {
-					runRunner(runner, fingerprint, eventHandler);
-				}
-				return new Task[0];
-			}
+          public void debug(final String msg) {
+            logger.debug(msg);
+          }
 
-			public TaskDef taskDef() {
-				return taskDef;
-			}
-		};
-	}
+          public void trace(final Throwable t) {
+            logger.trace(t);
+          }
+        };
+      }
 
-	public String done() {
-		return "";
-	}
+      private void runRunner(
+          final org.scalatools.testing.Runner runner,
+          final Fingerprint fingerprint,
+          final EventHandler eventHandler) {
+        // Old runner only support subclass fingerprint.
+        final SubclassFingerprint subclassFingerprint = (SubclassFingerprint) fingerprint;
+        final org.scalatools.testing.TestFingerprint oldFingerprint =
+            new org.scalatools.testing.TestFingerprint() {
+              public boolean isModule() {
+                return subclassFingerprint.isModule();
+              }
 
-	public String[] args() {
-		return args;
-	}
+              public String superClassName() {
+                return subclassFingerprint.superclassName();
+              }
+            };
+        final String name = taskDef.fullyQualifiedName();
+        runner.run(
+            name,
+            oldFingerprint,
+            new EventHandlerWrapper(eventHandler, name, subclassFingerprint),
+            args);
+      }
 
-	public String[] remoteArgs() {
-		return new String[0];  // Old framework does not support remoteArgs
-	}
+      private void runRunner2(
+          final org.scalatools.testing.Runner2 runner,
+          final Fingerprint fingerprint,
+          final EventHandler eventHandler) {
+        final org.scalatools.testing.Fingerprint oldFingerprint;
+        if (fingerprint instanceof SubclassFingerprint) {
+          final SubclassFingerprint subclassFingerprint = (SubclassFingerprint) fingerprint;
+          oldFingerprint =
+              new org.scalatools.testing.SubclassFingerprint() {
+                public boolean isModule() {
+                  return subclassFingerprint.isModule();
+                }
+
+                public String superClassName() {
+                  return subclassFingerprint.superclassName();
+                }
+              };
+        } else {
+          final AnnotatedFingerprint annotatedFingerprint = (AnnotatedFingerprint) fingerprint;
+          oldFingerprint =
+              new org.scalatools.testing.AnnotatedFingerprint() {
+                public boolean isModule() {
+                  return annotatedFingerprint.isModule();
+                }
+
+                public String annotationName() {
+                  return annotatedFingerprint.annotationName();
+                }
+              };
+        }
+        final String name = taskDef.fullyQualifiedName();
+        runner.run(
+            name, oldFingerprint, new EventHandlerWrapper(eventHandler, name, fingerprint), args);
+      }
+
+      public Task[] execute(final EventHandler eventHandler, final Logger[] loggers) {
+        final int length = loggers.length;
+        final org.scalatools.testing.Logger[] oldLoggers =
+            new org.scalatools.testing.Logger[length];
+        for (int i = 0; i < length; i++) {
+          oldLoggers[i] = createOldLogger(loggers[i]);
+        }
+
+        final org.scalatools.testing.Runner runner =
+            oldFramework.testRunner(testClassLoader, oldLoggers);
+        final Fingerprint fingerprint = taskDef.fingerprint();
+        if (runner instanceof org.scalatools.testing.Runner2) {
+          runRunner2((org.scalatools.testing.Runner2) runner, fingerprint, eventHandler);
+        } else {
+          runRunner(runner, fingerprint, eventHandler);
+        }
+        return new Task[0];
+      }
+
+      public TaskDef taskDef() {
+        return taskDef;
+      }
+    };
+  }
+
+  public String done() {
+    return "";
+  }
+
+  public String[] args() {
+    return args;
+  }
+
+  public String[] remoteArgs() {
+    return new String[0]; // Old framework does not support remoteArgs
+  }
 }
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupErrorEvent.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupErrorEvent.scala
new file mode 100644
index 000000000..915281634
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupErrorEvent.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Called if test completed with an error. */
+final class EndTestGroupErrorEvent private (
+  val name: String,
+  val error: String) extends sbt.protocol.testing.TestMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: EndTestGroupErrorEvent => (this.name == x.name) && (this.error == x.error)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.testing.EndTestGroupErrorEvent".##) + name.##) + error.##)
+  }
+  override def toString: String = {
+    "EndTestGroupErrorEvent(" + name + ", " + error + ")"
+  }
+  private[this] def copy(name: String = name, error: String = error): EndTestGroupErrorEvent = {
+    new EndTestGroupErrorEvent(name, error)
+  }
+  def withName(name: String): EndTestGroupErrorEvent = {
+    copy(name = name)
+  }
+  def withError(error: String): EndTestGroupErrorEvent = {
+    copy(error = error)
+  }
+}
+object EndTestGroupErrorEvent {
+  
+  def apply(name: String, error: String): EndTestGroupErrorEvent = new EndTestGroupErrorEvent(name, error)
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupEvent.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupEvent.scala
new file mode 100644
index 000000000..25b778918
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupEvent.scala
@@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Called if test completed. */
+final class EndTestGroupEvent private (
+  val name: String,
+  val result: sbt.protocol.testing.TestResult) extends sbt.protocol.testing.TestMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: EndTestGroupEvent => (this.name == x.name) && (this.result == x.result)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.testing.EndTestGroupEvent".##) + name.##) + result.##)
+  }
+  override def toString: String = {
+    "EndTestGroupEvent(" + name + ", " + result + ")"
+  }
+  private[this] def copy(name: String = name, result: sbt.protocol.testing.TestResult = result): EndTestGroupEvent = {
+    new EndTestGroupEvent(name, result)
+  }
+  def withName(name: String): EndTestGroupEvent = {
+    copy(name = name)
+  }
+  def withResult(result: sbt.protocol.testing.TestResult): EndTestGroupEvent = {
+    copy(result = result)
+  }
+}
+object EndTestGroupEvent {
+  
+  def apply(name: String, result: sbt.protocol.testing.TestResult): EndTestGroupEvent = new EndTestGroupEvent(name, result)
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/StartTestGroupEvent.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/StartTestGroupEvent.scala
new file mode 100644
index 000000000..29aa62b35
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/StartTestGroupEvent.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Called for each class or equivalent grouping. */
+final class StartTestGroupEvent private (
+  val name: String) extends sbt.protocol.testing.TestMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: StartTestGroupEvent => (this.name == x.name)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.testing.StartTestGroupEvent".##) + name.##)
+  }
+  override def toString: String = {
+    "StartTestGroupEvent(" + name + ")"
+  }
+  private[this] def copy(name: String = name): StartTestGroupEvent = {
+    new StartTestGroupEvent(name)
+  }
+  def withName(name: String): StartTestGroupEvent = {
+    copy(name = name)
+  }
+}
+object StartTestGroupEvent {
+  
+  def apply(name: String): StartTestGroupEvent = new StartTestGroupEvent(name)
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/TestCompleteEvent.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/TestCompleteEvent.scala
new file mode 100644
index 000000000..850e2b85a
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestCompleteEvent.scala
@@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Called once, at end of the testing. */
+final class TestCompleteEvent private (
+  val result: sbt.protocol.testing.TestResult) extends sbt.protocol.testing.TestMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestCompleteEvent => (this.result == x.result)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.testing.TestCompleteEvent".##) + result.##)
+  }
+  override def toString: String = {
+    "TestCompleteEvent(" + result + ")"
+  }
+  private[this] def copy(result: sbt.protocol.testing.TestResult = result): TestCompleteEvent = {
+    new TestCompleteEvent(result)
+  }
+  def withResult(result: sbt.protocol.testing.TestResult): TestCompleteEvent = {
+    copy(result = result)
+  }
+}
+object TestCompleteEvent {
+  
+  def apply(result: sbt.protocol.testing.TestResult): TestCompleteEvent = new TestCompleteEvent(result)
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/TestInitEvent.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/TestInitEvent.scala
new file mode 100644
index 000000000..bfb96777f
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestInitEvent.scala
@@ -0,0 +1,30 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Called once, at beginning of the testing. */
+final class TestInitEvent private () extends sbt.protocol.testing.TestMessage() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TestInitEvent => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.testing.TestInitEvent".##)
+}
+override def toString: String = {
+  "TestInitEvent()"
+}
+private[this] def copy(): TestInitEvent = {
+  new TestInitEvent()
+}
+
+}
+object TestInitEvent {
+  
+  def apply(): TestInitEvent = new TestInitEvent()
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemDetail.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemDetail.scala
new file mode 100644
index 000000000..f9517c9ae
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemDetail.scala
@@ -0,0 +1,52 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/**
+ * Mini version of sbt.testing.Event
+ * @param fullyQualifiedName The fully qualified name of a class that can rerun the suite or test
+                             about which an event was fired.
+ * @param status Indicates whether the event represents a test success, failure, error, skipped, ignored, canceled, pending.
+ * @param duration An amount of time, in milliseconds, that was required to complete the action reported by this event.
+                   None, if no duration was available.
+ */
+final class TestItemDetail private (
+  val fullyQualifiedName: String,
+  val status: sbt.testing.Status,
+  val duration: Option[Long]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestItemDetail => (this.fullyQualifiedName == x.fullyQualifiedName) && (this.status == x.status) && (this.duration == x.duration)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "sbt.protocol.testing.TestItemDetail".##) + fullyQualifiedName.##) + status.##) + duration.##)
+  }
+  override def toString: String = {
+    "TestItemDetail(" + fullyQualifiedName + ", " + status + ", " + duration + ")"
+  }
+  private[this] def copy(fullyQualifiedName: String = fullyQualifiedName, status: sbt.testing.Status = status, duration: Option[Long] = duration): TestItemDetail = {
+    new TestItemDetail(fullyQualifiedName, status, duration)
+  }
+  def withFullyQualifiedName(fullyQualifiedName: String): TestItemDetail = {
+    copy(fullyQualifiedName = fullyQualifiedName)
+  }
+  def withStatus(status: sbt.testing.Status): TestItemDetail = {
+    copy(status = status)
+  }
+  def withDuration(duration: Option[Long]): TestItemDetail = {
+    copy(duration = duration)
+  }
+  def withDuration(duration: Long): TestItemDetail = {
+    copy(duration = Option(duration))
+  }
+}
+object TestItemDetail {
+  
+  def apply(fullyQualifiedName: String, status: sbt.testing.Status, duration: Option[Long]): TestItemDetail = new TestItemDetail(fullyQualifiedName, status, duration)
+  def apply(fullyQualifiedName: String, status: sbt.testing.Status, duration: Long): TestItemDetail = new TestItemDetail(fullyQualifiedName, status, Option(duration))
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemEvent.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemEvent.scala
new file mode 100644
index 000000000..0c8086d2c
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemEvent.scala
@@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Called for each test method or equivalent. */
+final class TestItemEvent private (
+  val result: Option[sbt.protocol.testing.TestResult],
+  val detail: Vector[sbt.protocol.testing.TestItemDetail]) extends sbt.protocol.testing.TestMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestItemEvent => (this.result == x.result) && (this.detail == x.detail)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbt.protocol.testing.TestItemEvent".##) + result.##) + detail.##)
+  }
+  override def toString: String = {
+    "TestItemEvent(" + result + ", " + detail + ")"
+  }
+  private[this] def copy(result: Option[sbt.protocol.testing.TestResult] = result, detail: Vector[sbt.protocol.testing.TestItemDetail] = detail): TestItemEvent = {
+    new TestItemEvent(result, detail)
+  }
+  def withResult(result: Option[sbt.protocol.testing.TestResult]): TestItemEvent = {
+    copy(result = result)
+  }
+  def withResult(result: sbt.protocol.testing.TestResult): TestItemEvent = {
+    copy(result = Option(result))
+  }
+  def withDetail(detail: Vector[sbt.protocol.testing.TestItemDetail]): TestItemEvent = {
+    copy(detail = detail)
+  }
+}
+object TestItemEvent {
+  
+  def apply(result: Option[sbt.protocol.testing.TestResult], detail: Vector[sbt.protocol.testing.TestItemDetail]): TestItemEvent = new TestItemEvent(result, detail)
+  def apply(result: sbt.protocol.testing.TestResult, detail: Vector[sbt.protocol.testing.TestItemDetail]): TestItemEvent = new TestItemEvent(Option(result), detail)
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/TestMessage.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/TestMessage.scala
new file mode 100644
index 000000000..ea15ce798
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestMessage.scala
@@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Events for testing */
+abstract class TestMessage() extends Serializable {
+
+
+
+
+override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+  case _: TestMessage => true
+  case _ => false
+})
+override def hashCode: Int = {
+  37 * (17 + "sbt.protocol.testing.TestMessage".##)
+}
+override def toString: String = {
+  "TestMessage()"
+}
+}
+object TestMessage {
+  
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/TestResult.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/TestResult.scala
new file mode 100644
index 000000000..79d28c0b4
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestResult.scala
@@ -0,0 +1,15 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+/** Testing result */
+sealed abstract class TestResult extends Serializable
+object TestResult {
+  
+  
+  case object Passed extends TestResult
+  case object Failed extends TestResult
+  case object Error extends TestResult
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/TestStringEvent.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/TestStringEvent.scala
new file mode 100644
index 000000000..63d8077a6
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestStringEvent.scala
@@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing
+final class TestStringEvent private (
+  val value: String) extends sbt.protocol.testing.TestMessage() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: TestStringEvent => (this.value == x.value)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (17 + "sbt.protocol.testing.TestStringEvent".##) + value.##)
+  }
+  override def toString: String = {
+    value
+  }
+  private[this] def copy(value: String = value): TestStringEvent = {
+    new TestStringEvent(value)
+  }
+  def withValue(value: String): TestStringEvent = {
+    copy(value = value)
+  }
+}
+object TestStringEvent {
+  
+  def apply(value: String): TestStringEvent = new TestStringEvent(value)
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupErrorEventFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupErrorEventFormats.scala
new file mode 100644
index 000000000..6cdfa421c
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupErrorEventFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait EndTestGroupErrorEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val EndTestGroupErrorEventFormat: JsonFormat[sbt.protocol.testing.EndTestGroupErrorEvent] = new JsonFormat[sbt.protocol.testing.EndTestGroupErrorEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.EndTestGroupErrorEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val name = unbuilder.readField[String]("name")
+      val error = unbuilder.readField[String]("error")
+      unbuilder.endObject()
+      sbt.protocol.testing.EndTestGroupErrorEvent(name, error)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.EndTestGroupErrorEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("error", obj.error)
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupEventFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupEventFormats.scala
new file mode 100644
index 000000000..0f15ff95b
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/EndTestGroupEventFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait EndTestGroupEventFormats { self: sbt.protocol.testing.codec.TestResultFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val EndTestGroupEventFormat: JsonFormat[sbt.protocol.testing.EndTestGroupEvent] = new JsonFormat[sbt.protocol.testing.EndTestGroupEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.EndTestGroupEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val name = unbuilder.readField[String]("name")
+      val result = unbuilder.readField[sbt.protocol.testing.TestResult]("result")
+      unbuilder.endObject()
+      sbt.protocol.testing.EndTestGroupEvent(name, result)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.EndTestGroupEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("result", obj.result)
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/JsonProtocol.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/JsonProtocol.scala
new file mode 100644
index 000000000..1fc4767df
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/JsonProtocol.scala
@@ -0,0 +1,19 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+trait JsonProtocol extends sjsonnew.BasicJsonProtocol
+  with sbt.protocol.testing.codec.TestStringEventFormats
+  with sbt.protocol.testing.codec.TestInitEventFormats
+  with sbt.protocol.testing.codec.TestResultFormats
+  with sbt.protocol.testing.codec.TestCompleteEventFormats
+  with sbt.protocol.testing.codec.StartTestGroupEventFormats
+  with sbt.protocol.testing.codec.EndTestGroupEventFormats
+  with sbt.protocol.testing.codec.EndTestGroupErrorEventFormats
+  with sbt.internal.testing.StatusFormats
+  with sbt.protocol.testing.codec.TestItemDetailFormats
+  with sbt.protocol.testing.codec.TestItemEventFormats
+  with sbt.protocol.testing.codec.TestMessageFormats
+object JsonProtocol extends JsonProtocol
\ No newline at end of file
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/StartTestGroupEventFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/StartTestGroupEventFormats.scala
new file mode 100644
index 000000000..64e71d067
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/StartTestGroupEventFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait StartTestGroupEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val StartTestGroupEventFormat: JsonFormat[sbt.protocol.testing.StartTestGroupEvent] = new JsonFormat[sbt.protocol.testing.StartTestGroupEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.StartTestGroupEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val name = unbuilder.readField[String]("name")
+      unbuilder.endObject()
+      sbt.protocol.testing.StartTestGroupEvent(name)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.StartTestGroupEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestCompleteEventFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestCompleteEventFormats.scala
new file mode 100644
index 000000000..2bbc4f380
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestCompleteEventFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestCompleteEventFormats { self: sbt.protocol.testing.codec.TestResultFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestCompleteEventFormat: JsonFormat[sbt.protocol.testing.TestCompleteEvent] = new JsonFormat[sbt.protocol.testing.TestCompleteEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestCompleteEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val result = unbuilder.readField[sbt.protocol.testing.TestResult]("result")
+      unbuilder.endObject()
+      sbt.protocol.testing.TestCompleteEvent(result)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.TestCompleteEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("result", obj.result)
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestInitEventFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestInitEventFormats.scala
new file mode 100644
index 000000000..485f3656b
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestInitEventFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestInitEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestInitEventFormat: JsonFormat[sbt.protocol.testing.TestInitEvent] = new JsonFormat[sbt.protocol.testing.TestInitEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestInitEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      
+      unbuilder.endObject()
+      sbt.protocol.testing.TestInitEvent()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.TestInitEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemDetailFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemDetailFormats.scala
new file mode 100644
index 000000000..64eec6efc
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemDetailFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestItemDetailFormats { self: sbt.internal.testing.StatusFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestItemDetailFormat: JsonFormat[sbt.protocol.testing.TestItemDetail] = new JsonFormat[sbt.protocol.testing.TestItemDetail] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestItemDetail = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val fullyQualifiedName = unbuilder.readField[String]("fullyQualifiedName")
+      val status = unbuilder.readField[sbt.testing.Status]("status")
+      val duration = unbuilder.readField[Option[Long]]("duration")
+      unbuilder.endObject()
+      sbt.protocol.testing.TestItemDetail(fullyQualifiedName, status, duration)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.TestItemDetail, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("fullyQualifiedName", obj.fullyQualifiedName)
+    builder.addField("status", obj.status)
+    builder.addField("duration", obj.duration)
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemEventFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemEventFormats.scala
new file mode 100644
index 000000000..d6a8af553
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestItemEventFormats.scala
@@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestItemEventFormats { self: sbt.protocol.testing.codec.TestResultFormats with sbt.protocol.testing.codec.TestItemDetailFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestItemEventFormat: JsonFormat[sbt.protocol.testing.TestItemEvent] = new JsonFormat[sbt.protocol.testing.TestItemEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestItemEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val result = unbuilder.readField[Option[sbt.protocol.testing.TestResult]]("result")
+      val detail = unbuilder.readField[Vector[sbt.protocol.testing.TestItemDetail]]("detail")
+      unbuilder.endObject()
+      sbt.protocol.testing.TestItemEvent(result, detail)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.TestItemEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("result", obj.result)
+    builder.addField("detail", obj.detail)
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestMessageFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestMessageFormats.scala
new file mode 100644
index 000000000..13534855d
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestMessageFormats.scala
@@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+
+import _root_.sjsonnew.JsonFormat
+trait TestMessageFormats { self: sjsonnew.BasicJsonProtocol with sbt.protocol.testing.codec.TestStringEventFormats with sbt.protocol.testing.codec.TestInitEventFormats with sbt.protocol.testing.codec.TestResultFormats with sbt.protocol.testing.codec.TestCompleteEventFormats with sbt.protocol.testing.codec.StartTestGroupEventFormats with sbt.protocol.testing.codec.EndTestGroupEventFormats with sbt.protocol.testing.codec.EndTestGroupErrorEventFormats with sbt.protocol.testing.codec.TestItemDetailFormats with sbt.protocol.testing.codec.TestItemEventFormats =>
+implicit lazy val TestMessageFormat: JsonFormat[sbt.protocol.testing.TestMessage] = flatUnionFormat7[sbt.protocol.testing.TestMessage, sbt.protocol.testing.TestStringEvent, sbt.protocol.testing.TestInitEvent, sbt.protocol.testing.TestCompleteEvent, sbt.protocol.testing.StartTestGroupEvent, sbt.protocol.testing.EndTestGroupEvent, sbt.protocol.testing.EndTestGroupErrorEvent, sbt.protocol.testing.TestItemEvent]("type")
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestResultFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestResultFormats.scala
new file mode 100644
index 000000000..4084ddfdd
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestResultFormats.scala
@@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestResultFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestResultFormat: JsonFormat[sbt.protocol.testing.TestResult] = new JsonFormat[sbt.protocol.testing.TestResult] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestResult = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.readString(__js) match {
+        case "Passed" => sbt.protocol.testing.TestResult.Passed
+        case "Failed" => sbt.protocol.testing.TestResult.Failed
+        case "Error" => sbt.protocol.testing.TestResult.Error
+      }
+      case None =>
+      deserializationError("Expected JsString but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.TestResult, builder: Builder[J]): Unit = {
+    val str = obj match {
+      case sbt.protocol.testing.TestResult.Passed => "Passed"
+      case sbt.protocol.testing.TestResult.Failed => "Failed"
+      case sbt.protocol.testing.TestResult.Error => "Error"
+    }
+    builder.writeString(str)
+  }
+}
+}
diff --git a/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestStringEventFormats.scala b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestStringEventFormats.scala
new file mode 100644
index 000000000..64096d274
--- /dev/null
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/codec/TestStringEventFormats.scala
@@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.protocol.testing.codec
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait TestStringEventFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val TestStringEventFormat: JsonFormat[sbt.protocol.testing.TestStringEvent] = new JsonFormat[sbt.protocol.testing.TestStringEvent] {
+  override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.protocol.testing.TestStringEvent = {
+    __jsOpt match {
+      case Some(__js) =>
+      unbuilder.beginObject(__js)
+      val value = unbuilder.readField[String]("value")
+      unbuilder.endObject()
+      sbt.protocol.testing.TestStringEvent(value)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.protocol.testing.TestStringEvent, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("value", obj.value)
+    builder.endObject()
+  }
+}
+}
diff --git a/testing/src/main/contraband/testing.contra b/testing/src/main/contraband/testing.contra
new file mode 100644
index 000000000..94cb92425
--- /dev/null
+++ b/testing/src/main/contraband/testing.contra
@@ -0,0 +1,65 @@
+package sbt.protocol.testing
+@target(Scala)
+@codecPackage("sbt.protocol.testing.codec")
+@fullCodec("JsonProtocol")
+
+## Events for testing
+interface TestMessage {
+}
+
+type TestStringEvent implements TestMessage {
+  value: String!
+  #xtostring value
+}
+
+## Called once, at beginning of the testing.
+type TestInitEvent implements TestMessage {}
+
+## Called once, at end of the testing.
+type TestCompleteEvent implements TestMessage {
+  result: sbt.protocol.testing.TestResult!
+}
+
+## Called for each class or equivalent grouping.
+type StartTestGroupEvent implements TestMessage {
+  name: String!
+}
+
+## Called if test completed.
+type EndTestGroupEvent implements TestMessage {
+  name: String!
+  result: sbt.protocol.testing.TestResult!
+}
+
+## Called if test completed with an error.
+type EndTestGroupErrorEvent implements TestMessage {
+  name: String!
+  error: String!
+}
+
+## Called for each test method or equivalent.
+type TestItemEvent implements TestMessage {
+  result: sbt.protocol.testing.TestResult
+  detail: [sbt.protocol.testing.TestItemDetail]
+}
+
+## Mini version of sbt.testing.Event
+type TestItemDetail {
+  ## The fully qualified name of a class that can rerun the suite or test
+  ## about which an event was fired.
+  fullyQualifiedName: String!
+
+  ## Indicates whether the event represents a test success, failure, error, skipped, ignored, canceled, pending.
+  status: sbt.testing.Status!
+
+  ## An amount of time, in milliseconds, that was required to complete the action reported by this event.
+  ## None, if no duration was available.
+  duration: Long
+}
+
+## Testing result
+enum TestResult {
+  Passed
+  Failed
+  Error
+}
diff --git a/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala b/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala
index e4797b754..1a3cf42e9 100644
--- a/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala
+++ b/testing/src/main/scala/sbt/JUnitXmlTestsListener.scala
@@ -1,54 +1,92 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
 package sbt
 
-import java.io.{ IOException, StringWriter, PrintWriter, File }
+import java.io.{ File, IOException, PrintWriter, StringWriter }
 import java.net.InetAddress
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.time.temporal.ChronoUnit
 import java.util.Hashtable
+import java.util.concurrent.TimeUnit.NANOSECONDS
 
 import scala.collection.mutable.ListBuffer
-import scala.util.DynamicVariable
+import scala.util.Properties
 import scala.xml.{ Elem, Node => XNode, XML }
-import testing.{ Event => TEvent, Status => TStatus, OptionalThrowable, TestSelector }
+import testing.{
+  Event => TEvent,
+  NestedTestSelector,
+  Status => TStatus,
+  OptionalThrowable,
+  TestSelector
+}
+import util.Logger
+import sbt.protocol.testing.TestResult
 
 /**
  * A tests listener that outputs the results it receives in junit xml
  * report format.
  * @param outputDir path to the dir in which a folder with results is generated
  */
-class JUnitXmlTestsListener(val outputDir: String) extends TestsListener {
+class JUnitXmlTestsListener(val outputDir: String, legacyTestReport: Boolean, logger: Logger)
+    extends TestsListener {
+  // These constructors are for binary compatibility with older versions of sbt.
+  def this(outputDir: String, logger: Logger) = this(outputDir, false, logger)
+  def this(outputDir: String) = this(outputDir, false, null)
+
   /**Current hostname so we know which machine executed the tests*/
-  val hostname =
-    try InetAddress.getLocalHost.getHostName
+  val hostname: String = {
+    val start = System.nanoTime
+    val name = try InetAddress.getLocalHost.getHostName
     catch {
-      case x: IOException => "localhost"
+      case _: IOException => "localhost"
     }
+    val elapsed = System.nanoTime - start
+    if ((NANOSECONDS.toSeconds(elapsed) >= 4) && Properties.isMac && logger != null) {
+      logger.warn(
+        s"Getting the hostname $name was slow (${elapsed / 1.0e6} ms). " +
+          "This is likely because the computer's hostname is not set. You can set the " +
+          """hostname with the command: scutil --set HostName "$(scutil --get LocalHostName).local"."""
+      )
+    }
+    name
+  }
+
   /**The dir in which we put all result files. Is equal to the given dir + "/test-reports"*/
   val targetDir = new File(outputDir + "/test-reports/")
 
   /**all system properties as XML*/
-  val properties =
+  val properties: Elem =
     <properties>
       {
-        // create a clone, defending against [[ConcurrentModificationException]]
-        val clonedProperties = System.getProperties.clone.asInstanceOf[Hashtable[AnyRef, AnyRef]]
-        val iter = clonedProperties.entrySet.iterator
-        val props: ListBuffer[XNode] = new ListBuffer()
-        while (iter.hasNext) {
-          val next = iter.next
-          props += <property name={ next.getKey.toString } value={ next.getValue.toString }/>
-        }
-        props
+      // create a clone, defending against [[ConcurrentModificationException]]
+      val clonedProperties = System.getProperties.clone.asInstanceOf[Hashtable[AnyRef, AnyRef]]
+      val iter = clonedProperties.entrySet.iterator
+      val props: ListBuffer[XNode] = new ListBuffer()
+      while (iter.hasNext) {
+        val next = iter.next
+        props += <property name={next.getKey.toString} value={next.getValue.toString}/>
       }
+      props
+    }
     </properties>
 
   /**
    * Gathers data for one Test Suite. We map test groups to TestSuites.
    * Each TestSuite gets its own output file.
    */
-  class TestSuite(val name: String) {
+  class TestSuite(val name: String, timestamp: LocalDateTime) {
+    def this(name: String) = this(name, LocalDateTime.now())
+
     val events: ListBuffer[TEvent] = new ListBuffer()
 
     /**Adds one test result to this suite.*/
-    def addEvent(e: TEvent) = events += e
+    def addEvent(e: TEvent): ListBuffer[TEvent] = events += e
 
     /** Returns the number of tests of each state for the specified. */
     def count(status: TStatus) = events.count(_.status == status)
@@ -62,40 +100,66 @@ class JUnitXmlTestsListener(val outputDir: String) extends TestsListener {
 
       val (errors, failures, tests) = (count(TStatus.Error), count(TStatus.Failure), events.size)
 
-      /** Junit XML reports don't differentiate between ignored, skipped or pending tests */
-      val ignoredSkippedPending = count(TStatus.Ignored) + count(TStatus.Skipped) + count(TStatus.Pending)
+      // Junit XML reports don't differentiate between ignored, skipped or pending tests
+      val ignoredSkippedPending = count(TStatus.Ignored) + count(TStatus.Skipped) + count(
+        TStatus.Pending
+      )
 
-      val result = <testsuite hostname={ hostname } name={ name } tests={ tests + "" } errors={ errors + "" } failures={ failures + "" } skipped={ ignoredSkippedPending + "" } time={ (duration / 1000.0).toString }>
-                     { properties }
+      // for sbt/junit-interface version 0.11 (in future versions this should be done there)
+      val classnameRegex = s"^($name|${name.split('.').last})\\.?".r
+
+      val result =
+        <testsuite hostname={hostname} name={name} tests={tests + ""} errors={errors + ""} failures={
+          failures + ""
+        } skipped={ignoredSkippedPending + ""} time={(duration / 1000.0).toString} timestamp={
+          formatISO8601DateTime(timestamp)
+        }>
+                     {properties}
                      {
-                       for (e <- events) yield <testcase classname={ name } name={
-                         e.selector match {
-                           case selector: TestSelector=> selector.testName.split('.').last
-                           case _   => "(It is not a test)"
-                         }
-                       } time={ (e.duration() / 1000.0).toString }>
+          for (e <- events)
+            yield <testcase classname={
+              e.selector match {
+                case nested: NestedTestSelector => nested.suiteId()
+                case _                          => name
+              }
+            } name={
+              e.selector match {
+                case selector: TestSelector =>
+                  val matchEnd =
+                    classnameRegex.findFirstMatchIn(selector.testName).map(_.end).getOrElse(0)
+                  selector.testName.substring(matchEnd)
+                case nested: NestedTestSelector => nested.testName()
+                case other                      => s"(It is not a test it is a ${other.getClass.getCanonicalName})"
+              }
+            } time={(e.duration() / 1000.0).toString}>
                                                  {
-                                                   val trace: String = if (e.throwable.isDefined) {
-                                                     val stringWriter = new StringWriter()
-                                                     val writer = new PrintWriter(stringWriter)
-                                                     e.throwable.get.printStackTrace(writer)
-                                                     writer.flush()
-                                                     stringWriter.toString
-                                                   } else {
-                                                     ""
-                                                   }
-                                                   e.status match {
-                                                     case TStatus.Error if (e.throwable.isDefined) => <error message={ e.throwable.get.getMessage } type={ e.throwable.get.getClass.getName }>{ trace }</error>
-                                                     case TStatus.Error => <error message={ "No Exception or message provided" }/>
-                                                     case TStatus.Failure if (e.throwable.isDefined) => <failure message={ e.throwable.get.getMessage } type={ e.throwable.get.getClass.getName }>{ trace }</failure>
-                                                     case TStatus.Failure => <failure message={ "No Exception or message provided" }/>
-                                                     case TStatus.Ignored | TStatus.Skipped | TStatus.Pending => <skipped/>
-                                                     case _ => {}
-                                                   }
-                                                 }
+              val trace: String = if (e.throwable.isDefined) {
+                val stringWriter = new StringWriter()
+                val writer = new PrintWriter(stringWriter)
+                e.throwable.get.printStackTrace(writer)
+                writer.flush()
+                stringWriter.toString
+              } else {
+                ""
+              }
+              e.status match {
+                case TStatus.Error if (e.throwable.isDefined) =>
+                  <error message={e.throwable.get.getMessage} type={
+                    e.throwable.get.getClass.getName
+                  }>{trace}</error>
+                case TStatus.Error => <error message={"No Exception or message provided"}/>
+                case TStatus.Failure if (e.throwable.isDefined) =>
+                  <failure message={e.throwable.get.getMessage} type={
+                    e.throwable.get.getClass.getName
+                  }>{trace}</failure>
+                case TStatus.Failure                                     => <failure message={"No Exception or message provided"}/>
+                case TStatus.Ignored | TStatus.Skipped | TStatus.Pending => <skipped/>
+                case _                                                   => {}
+              }
+            }
                                                </testcase>
 
-                     }
+        }
                      <system-out><![CDATA[]]></system-out>
                      <system-err><![CDATA[]]></system-err>
                    </testsuite>
@@ -105,27 +169,37 @@ class JUnitXmlTestsListener(val outputDir: String) extends TestsListener {
   }
 
   /**The currently running test suite*/
-  val testSuite = new DynamicVariable(null: TestSuite)
+  private val testSuite = new InheritableThreadLocal[Option[TestSuite]] {
+    override def initialValue(): Option[TestSuite] = None
+  }
+
+  private def withTestSuite[T](f: TestSuite => T): T =
+    testSuite.get().map(f).getOrElse(sys.error("no test suite"))
 
   /**Creates the output Dir*/
-  override def doInit() = { targetDir.mkdirs() }
+  override def doInit(): Unit = {
+    val _ = targetDir.mkdirs()
+  }
 
   /**
    * Starts a new, initially empty Suite with the given name.
    */
-  override def startGroup(name: String): Unit = testSuite.value_=(new TestSuite(name))
+  override def startGroup(name: String): Unit = testSuite.set(Some(new TestSuite(name)))
 
   /**
    * Adds all details for the given even to the current suite.
    */
-  override def testEvent(event: TestEvent): Unit = for (e <- event.detail) { testSuite.value.addEvent(e) }
+  override def testEvent(event: TestEvent): Unit = for (e <- event.detail) {
+    withTestSuite(_.addEvent(e))
+  }
 
   /**
    * called for each class or equivalent grouping
    *  We map one group to one Testsuite, so for each Group
-   *  we create an XML like this:
+   *  we create [[https://github.com/windyroad/JUnit-Schema/blob/master/JUnit.xsd JUnit XML file]], and looks like this:
+   *
    *  <?xml version="1.0" encoding="UTF-8" ?>
-   *  <testsuite skipped="w" errors="x" failures="y" tests="z" hostname="example.com" name="eu.henkelmann.bla.SomeTest" time="0.23">
+   *  <testsuite skipped="w" errors="x" failures="y" tests="z" hostname="example.com" name="eu.henkelmann.bla.SomeTest" time="0.23" timestamp="2018-01-01T10:00:00">
    *       <properties>
    *           <property name="os.name" value="Linux" />
    *           ...
@@ -141,9 +215,9 @@ class JUnitXmlTestsListener(val outputDir: String) extends TestsListener {
    *       <system-err><![CDATA[]]></system-err>
    *  </testsuite>
    */
-  override def endGroup(name: String, t: Throwable) = {
+  override def endGroup(name: String, t: Throwable): Unit = {
     // create our own event to record the error
-    val event = new TEvent {
+    val event: TEvent = new TEvent {
       def fullyQualifiedName = name
       //def description =
       //"Throwable escaped the test run of '%s'".format(name)
@@ -153,7 +227,7 @@ class JUnitXmlTestsListener(val outputDir: String) extends TestsListener {
       def selector = null
       def throwable = new OptionalThrowable(t)
     }
-    testSuite.value.addEvent(event)
+    withTestSuite(_.addEvent(event))
     writeSuite()
   }
 
@@ -161,7 +235,7 @@ class JUnitXmlTestsListener(val outputDir: String) extends TestsListener {
    * Ends the current suite, wraps up the result and writes it to an XML file
    *  in the output folder that is named after the suite.
    */
-  override def endGroup(name: String, result: TestResult.Value) = {
+  override def endGroup(name: String, result: TestResult): Unit = {
     writeSuite()
   }
 
@@ -169,15 +243,27 @@ class JUnitXmlTestsListener(val outputDir: String) extends TestsListener {
   // contort the user into not using spaces.
   private[this] def normalizeName(s: String) = s.replaceAll("""\s+""", "-")
 
-  private def writeSuite() = {
-    val file = new File(targetDir, s"${normalizeName(testSuite.value.name)}.xml").getAbsolutePath
+  /**
+   * Format the date, without milliseconds or the timezone, per the JUnit spec.
+   */
+  private[this] def formatISO8601DateTime(d: LocalDateTime): String =
+    d.truncatedTo(ChronoUnit.SECONDS).format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
+
+  private def writeSuite(): Unit = {
+    val file = if (legacyTestReport) {
+      new File(targetDir, s"${normalizeName(withTestSuite(_.name))}.xml").getAbsolutePath
+    } else {
+      new File(targetDir, s"TEST-${normalizeName(withTestSuite(_.name))}.xml").getAbsolutePath
+    }
     // TODO would be nice to have a logger and log this with level debug
     // System.err.println("Writing JUnit XML test report: " + file)
-    XML.save(file, testSuite.value.stop(), "UTF-8", true, null)
+    val testSuiteResult = withTestSuite(_.stop())
+    XML.save(file, testSuiteResult, "UTF-8", xmlDecl = true, null)
+    testSuite.remove()
   }
 
   /**Does nothing, as we write each file after a suite is done.*/
-  override def doComplete(finalResult: TestResult.Value): Unit = {}
+  override def doComplete(finalResult: TestResult): Unit = {}
 
   /**Returns None*/
   override def contentLogger(test: TestDefinition): Option[ContentLogger] = None
diff --git a/testing/src/main/scala/sbt/TestFramework.scala b/testing/src/main/scala/sbt/TestFramework.scala
index 7e032388b..77f5089dd 100644
--- a/testing/src/main/scala/sbt/TestFramework.scala
+++ b/testing/src/main/scala/sbt/TestFramework.scala
@@ -1,6 +1,10 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009  Steven Blundy, Mark Harrah, Josh Cough
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
@@ -10,34 +14,62 @@ import org.scalatools.testing.{ Framework => OldFramework }
 import sbt.internal.inc.classpath.{ ClasspathUtilities, DualLoader }
 import sbt.internal.inc.ScalaInstance
 import scala.annotation.tailrec
-import sbt.util.Logger
+import sbt.internal.util.ManagedLogger
 import sbt.io.IO
-
-object TestResult extends Enumeration {
-  val Passed, Failed, Error = Value
-}
+import sbt.protocol.testing.TestResult
 
 object TestFrameworks {
-  val ScalaCheck = new TestFramework("org.scalacheck.ScalaCheckFramework")
-  val ScalaTest = new TestFramework("org.scalatest.tools.Framework", "org.scalatest.tools.ScalaTestFramework")
-  val Specs = new TestFramework("org.specs.runner.SpecsFramework")
-  val Specs2 = new TestFramework("org.specs2.runner.Specs2Framework", "org.specs2.runner.SpecsFramework")
-  val JUnit = new TestFramework("com.novocode.junit.JUnitFramework")
+  val ScalaCheck = TestFramework("org.scalacheck.ScalaCheckFramework")
+  val ScalaTest =
+    TestFramework("org.scalatest.tools.Framework", "org.scalatest.tools.ScalaTestFramework")
+  val Specs = TestFramework("org.specs.runner.SpecsFramework")
+  val Specs2 =
+    TestFramework("org.specs2.runner.Specs2Framework", "org.specs2.runner.SpecsFramework")
+  val JUnit = TestFramework("com.novocode.junit.JUnitFramework")
+  val MUnit = TestFramework("munit.Framework")
 }
 
-case class TestFramework(implClassNames: String*) {
+final class TestFramework(val implClassNames: String*) extends Serializable {
+  override def equals(o: Any): Boolean = o match {
+    case x: TestFramework => (this.implClassNames.toList == x.implClassNames.toList)
+    case _                => false
+  }
+  override def hashCode: Int = {
+    37 * (17 + implClassNames.##) + "TestFramework".##
+  }
+  override def toString: String = {
+    "TestFramework(" + implClassNames.mkString(", ") + ")"
+  }
+
   @tailrec
-  private def createFramework(loader: ClassLoader, log: Logger, frameworkClassNames: List[String]): Option[Framework] = {
+  private def createFramework(
+      loader: ClassLoader,
+      log: ManagedLogger,
+      frameworkClassNames: List[String]
+  ): Option[Framework] = {
+    def logError(e: Throwable): Option[Framework] = {
+      log.error(
+        s"Error loading test framework ($e). This usually means that you are"
+          + " using a layered class loader that cannot reach the sbt.testing.Framework class."
+          + " The most likely cause is that your project has a runtime dependency on your"
+          + " test framework, e.g. scalatest. To fix this, you can try to set\n"
+          + "Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.ScalaLibrary\nor\n"
+          + "Test / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat"
+      )
+      None
+    }
     frameworkClassNames match {
       case head :: tail =>
         try {
-          Some(Class.forName(head, true, loader).newInstance match {
+          Some(Class.forName(head, true, loader).getDeclaredConstructor().newInstance() match {
             case newFramework: Framework    => newFramework
             case oldFramework: OldFramework => new FrameworkWrapper(oldFramework)
           })
         } catch {
-          case e: ClassNotFoundException =>
-            log.debug("Framework implementation '" + head + "' not present.");
+          case e: NoClassDefFoundError => logError(e)
+          case e: MatchError           => logError(e)
+          case _: ClassNotFoundException =>
+            log.debug("Framework implementation '" + head + "' not present.")
             createFramework(loader, log, tail)
         }
       case Nil =>
@@ -45,10 +77,15 @@ case class TestFramework(implClassNames: String*) {
     }
   }
 
-  def create(loader: ClassLoader, log: Logger): Option[Framework] =
+  def create(loader: ClassLoader, log: ManagedLogger): Option[Framework] =
     createFramework(loader, log, implClassNames.toList)
 }
-final class TestDefinition(val name: String, val fingerprint: Fingerprint, val explicitlySpecified: Boolean, val selectors: Array[Selector]) {
+final class TestDefinition(
+    val name: String,
+    val fingerprint: Fingerprint,
+    val explicitlySpecified: Boolean,
+    val selectors: Array[Selector]
+) {
   override def toString = "Test " + name + " : " + TestFramework.toString(fingerprint)
   override def equals(t: Any) =
     t match {
@@ -58,56 +95,92 @@ final class TestDefinition(val name: String, val fingerprint: Fingerprint, val e
   override def hashCode: Int = (name.hashCode, TestFramework.hashCode(fingerprint)).hashCode
 }
 
-final class TestRunner(delegate: Runner, listeners: Seq[TestReportListener], log: Logger) {
+final class TestRunner(
+    delegate: Runner,
+    listeners: Vector[TestReportListener],
+    log: ManagedLogger
+) {
 
   final def tasks(testDefs: Set[TestDefinition]): Array[TestTask] =
-    delegate.tasks(testDefs.map(df => new TaskDef(df.name, df.fingerprint, df.explicitlySpecified, df.selectors)).toArray)
+    delegate.tasks(
+      testDefs
+        .map(df => new TaskDef(df.name, df.fingerprint, df.explicitlySpecified, df.selectors))
+        .toArray
+    )
 
-  final def run(taskDef: TaskDef, testTask: TestTask): (SuiteResult, Seq[TestTask]) =
-    {
-      val testDefinition = new TestDefinition(taskDef.fullyQualifiedName, taskDef.fingerprint, taskDef.explicitlySpecified, taskDef.selectors)
-      log.debug("Running " + taskDef)
-      val name = testDefinition.name
+  final def run(taskDef: TaskDef, testTask: TestTask): (SuiteResult, Seq[TestTask]) = {
+    val testDefinition = new TestDefinition(
+      taskDef.fullyQualifiedName,
+      taskDef.fingerprint,
+      taskDef.explicitlySpecified,
+      taskDef.selectors
+    )
+    log.debug("Running " + taskDef)
+    val name = testDefinition.name
 
-      def runTest() =
-        {
-          // here we get the results! here is where we'd pass in the event listener
-          val results = new scala.collection.mutable.ListBuffer[Event]
-          val handler = new EventHandler { def handle(e: Event): Unit = { results += e } }
-          val loggers = listeners.flatMap(_.contentLogger(testDefinition))
-          val nestedTasks =
-            try testTask.execute(handler, loggers.map(_.log).toArray)
-            finally loggers.foreach(_.flush())
-          val event = TestEvent(results)
-          safeListenersCall(_.testEvent(event))
-          (SuiteResult(results), nestedTasks.toSeq)
+    def runTest() = {
+      // here we get the results! here is where we'd pass in the event listener
+      val results = new scala.collection.mutable.ListBuffer[Event]
+      val handler = new EventHandler { def handle(e: Event): Unit = { results += e } }
+      val loggers: Vector[ContentLogger] = listeners.flatMap(_.contentLogger(testDefinition))
+      def errorEvents(e: Throwable): Array[sbt.testing.Task] = {
+        val taskDef = testTask.taskDef
+        val event = new Event {
+          val status = Status.Error
+          val throwable = new OptionalThrowable(e)
+          val fullyQualifiedName = taskDef.fullyQualifiedName
+          val selector = new TestSelector(name)
+          val fingerprint = taskDef.fingerprint
+          val duration = -1L
         }
-
-      safeListenersCall(_.startGroup(name))
-      try {
-        val (suiteResult, nestedTasks) = runTest()
-        safeListenersCall(_.endGroup(name, suiteResult.result))
-        (suiteResult, nestedTasks)
-      } catch {
-        case NonFatal(e) =>
-          safeListenersCall(_.endGroup(name, e))
-          (SuiteResult.Error, Seq.empty[TestTask])
+        results += event
+        Array.empty
       }
+      val nestedTasks =
+        try testTask.execute(handler, loggers.map(_.log).toArray)
+        catch {
+          case e: NoClassDefFoundError => errorEvents(e)
+          case NonFatal(e)             => errorEvents(e)
+          case e: IllegalAccessError   => errorEvents(e)
+        } finally {
+          loggers.foreach(_.flush())
+        }
+      val event = TestEvent(results.toList)
+      safeListenersCall(_.testEvent(event))
+      (SuiteResult(results.toList), nestedTasks.toSeq)
     }
 
+    safeListenersCall(_.startGroup(name))
+    try {
+      val (suiteResult, nestedTasks) = runTest()
+      safeListenersCall(_.endGroup(name, suiteResult.result))
+      (suiteResult, nestedTasks)
+    } catch {
+      case NonFatal(e) =>
+        safeListenersCall(_.endGroup(name, e))
+        (SuiteResult.Error, Seq.empty[TestTask])
+    }
+  }
+
   protected def safeListenersCall(call: (TestReportListener) => Unit): Unit =
     TestFramework.safeForeach(listeners, log)(call)
 }
 
 object TestFramework {
+  def apply(implClassNames: String*): TestFramework = new TestFramework(implClassNames: _*)
+
   def getFingerprints(framework: Framework): Seq[Fingerprint] =
     framework.getClass.getMethod("fingerprints").invoke(framework) match {
       case fingerprints: Array[Fingerprint] => fingerprints.toList
       case _                                => sys.error("Could not call 'fingerprints' on framework " + framework)
     }
 
-  private[sbt] def safeForeach[T](it: Iterable[T], log: Logger)(f: T => Unit): Unit =
-    it.foreach(i => try f(i) catch { case NonFatal(e) => log.trace(e); log.error(e.toString) })
+  private[sbt] def safeForeach[T](it: Iterable[T], log: ManagedLogger)(f: T => Unit): Unit =
+    it.foreach(
+      i =>
+        try f(i)
+        catch { case NonFatal(e) => log.trace(e); log.error(e.toString) }
+    )
 
   private[sbt] def hashCode(f: Fingerprint): Int = f match {
     case s: SubclassFingerprint  => (s.isModule, s.superclassName).hashCode
@@ -116,8 +189,10 @@ object TestFramework {
   }
   def matches(a: Fingerprint, b: Fingerprint) =
     (a, b) match {
-      case (a: SubclassFingerprint, b: SubclassFingerprint) => a.isModule == b.isModule && a.superclassName == b.superclassName
-      case (a: AnnotatedFingerprint, b: AnnotatedFingerprint) => a.isModule == b.isModule && a.annotationName == b.annotationName
+      case (a: SubclassFingerprint, b: SubclassFingerprint) =>
+        a.isModule == b.isModule && a.superclassName == b.superclassName
+      case (a: AnnotatedFingerprint, b: AnnotatedFingerprint) =>
+        a.isModule == b.isModule && a.annotationName == b.annotationName
       case _ => false
     }
   def toString(f: Fingerprint): String =
@@ -127,83 +202,130 @@ object TestFramework {
       case _                        => f.toString
     }
 
-  def testTasks(frameworks: Map[TestFramework, Framework],
-    runners: Map[TestFramework, Runner],
-    testLoader: ClassLoader,
-    tests: Seq[TestDefinition],
-    log: Logger,
-    listeners: Seq[TestReportListener]): (() => Unit, Seq[(String, TestFunction)], TestResult.Value => () => Unit) =
-    {
-      val mappedTests = testMap(frameworks.values.toSeq, tests)
-      if (mappedTests.isEmpty)
-        (() => (), Nil, _ => () => ())
-      else
-        createTestTasks(testLoader, runners.map { case (tf, r) => (frameworks(tf), new TestRunner(r, listeners, log)) }, mappedTests, tests, log, listeners)
-    }
+  def testTasks(
+      frameworks: Map[TestFramework, Framework],
+      runners: Map[TestFramework, Runner],
+      testLoader: ClassLoader,
+      tests: Vector[TestDefinition],
+      log: ManagedLogger,
+      listeners: Vector[TestReportListener]
+  ): (() => Unit, Vector[(String, TestFunction)], TestResult => () => Unit) = {
+    val mappedTests = testMap(frameworks.values.toSeq, tests)
+    if (mappedTests.isEmpty)
+      (() => (), Vector(), _ => () => ())
+    else
+      createTestTasks(testLoader, runners.map {
+        case (tf, r) => (frameworks(tf), new TestRunner(r, listeners, log))
+      }, mappedTests, tests, log, listeners)
+  }
 
-  private[this] def order(mapped: Map[String, TestFunction], inputs: Seq[TestDefinition]): Seq[(String, TestFunction)] =
+  private[this] def order(
+      mapped: Map[String, TestFunction],
+      inputs: Vector[TestDefinition]
+  ): Vector[(String, TestFunction)] =
     for (d <- inputs; act <- mapped.get(d.name)) yield (d.name, act)
 
-  private[this] def testMap(frameworks: Seq[Framework], tests: Seq[TestDefinition]): Map[Framework, Set[TestDefinition]] =
-    {
-      import scala.collection.mutable.{ HashMap, HashSet, Set }
-      val map = new HashMap[Framework, Set[TestDefinition]]
-      def assignTest(test: TestDefinition): Unit = {
-        def isTestForFramework(framework: Framework) = getFingerprints(framework).exists { t => matches(t, test.fingerprint) }
-        for (framework <- frameworks.find(isTestForFramework))
-          map.getOrElseUpdate(framework, new HashSet[TestDefinition]) += test
+  private[this] def testMap(
+      frameworks: Seq[Framework],
+      tests: Seq[TestDefinition]
+  ): Map[Framework, Set[TestDefinition]] = {
+    import scala.collection.mutable.{ HashMap, HashSet, Set }
+    val map = new HashMap[Framework, Set[TestDefinition]]
+    def assignTest(test: TestDefinition): Unit = {
+      def isTestForFramework(framework: Framework) = getFingerprints(framework).exists { t =>
+        matches(t, test.fingerprint)
       }
-      if (frameworks.nonEmpty)
-        for (test <- tests) assignTest(test)
-      map.toMap.mapValues(_.toSet)
+      for (framework <- frameworks.find(isTestForFramework))
+        map.getOrElseUpdate(framework, new HashSet[TestDefinition]) += test
     }
+    if (frameworks.nonEmpty)
+      for (test <- tests) assignTest(test)
+    map.toMap.mapValues(_.toSet).toMap
+  }
 
-  private def createTestTasks(loader: ClassLoader, runners: Map[Framework, TestRunner], tests: Map[Framework, Set[TestDefinition]], ordered: Seq[TestDefinition], log: Logger, listeners: Seq[TestReportListener]) =
-    {
-      val testsListeners = listeners collect { case tl: TestsListener => tl }
+  private def createTestTasks(
+      loader: ClassLoader,
+      runners: Map[Framework, TestRunner],
+      tests: Map[Framework, Set[TestDefinition]],
+      ordered: Vector[TestDefinition],
+      log: ManagedLogger,
+      listeners: Vector[TestReportListener]
+  ): (() => Unit, Vector[(String, TestFunction)], TestResult => (() => Unit)) = {
+    val testsListeners = listeners collect { case tl: TestsListener => tl }
 
-      def foreachListenerSafe(f: TestsListener => Unit): () => Unit = () => safeForeach(testsListeners, log)(f)
+    def foreachListenerSafe(f: TestsListener => Unit): () => Unit =
+      () => safeForeach(testsListeners, log)(f)
 
-      val startTask = foreachListenerSafe(_.doInit)
-      val testTasks =
-        tests flatMap {
-          case (framework, testDefinitions) =>
-            val runner = runners(framework)
-            val testTasks = withContextLoader(loader) { runner.tasks(testDefinitions) }
-            for (testTask <- testTasks) yield {
-              val taskDef = testTask.taskDef
-              (taskDef.fullyQualifiedName, createTestFunction(loader, taskDef, runner, testTask))
-            }
-        }
+    val startTask = foreachListenerSafe(_.doInit)
+    val testTasks =
+      Map(tests.toSeq.flatMap {
+        case (framework, testDefinitions) =>
+          val runner = runners(framework)
+          val testTasks = withContextLoader(loader) { runner.tasks(testDefinitions) }
+          for (testTask <- testTasks) yield {
+            val taskDef = testTask.taskDef
+            (taskDef.fullyQualifiedName, createTestFunction(loader, taskDef, runner, testTask))
+          }
+      }: _*)
 
-      val endTask = (result: TestResult.Value) => foreachListenerSafe(_.doComplete(result))
-      (startTask, order(testTasks, ordered), endTask)
+    val endTask = (result: TestResult) => foreachListenerSafe(_.doComplete(result))
+    (startTask, order(testTasks, ordered), endTask)
+  }
+  private[this] def withContextLoader[T](loader: ClassLoader)(eval: => T): T = {
+    val oldLoader = Thread.currentThread.getContextClassLoader
+    Thread.currentThread.setContextClassLoader(loader)
+    try {
+      eval
+    } finally {
+      Thread.currentThread.setContextClassLoader(oldLoader)
     }
-  private[this] def withContextLoader[T](loader: ClassLoader)(eval: => T): T =
-    {
-      val oldLoader = Thread.currentThread.getContextClassLoader
-      Thread.currentThread.setContextClassLoader(loader)
-      try { eval } finally { Thread.currentThread.setContextClassLoader(oldLoader) }
+  }
+  @deprecated("1.3.0", "This has been replaced by the ClassLoaders.test task.")
+  def createTestLoader(
+      classpath: Seq[File],
+      scalaInstance: ScalaInstance,
+      tempDir: File
+  ): ClassLoader = {
+    val interfaceJar = IO.classLocationPath(classOf[testing.Framework]).toFile
+    val interfaceFilter = (name: String) =>
+      name.startsWith("org.scalatools.testing.") || name.startsWith("sbt.testing.")
+    val notInterfaceFilter = (name: String) => !interfaceFilter(name)
+    val dual = new DualLoader(
+      scalaInstance.loader,
+      notInterfaceFilter,
+      x => true,
+      getClass.getClassLoader,
+      interfaceFilter,
+      x => false
+    )
+    val main = ClasspathUtilities.makeLoader(classpath, dual, scalaInstance, tempDir)
+    // TODO - There's actually an issue with the classpath facility such that unmanagedScalaInstances are not added
+    // to the classpath correctly.  We have a temporary workaround here.
+    val cp: Seq[File] =
+      if (scalaInstance.isManagedVersion) interfaceJar +: classpath
+      else scalaInstance.allJars ++ (interfaceJar +: classpath)
+    ClasspathUtilities.filterByClasspath(cp, main)
+  }
+  def createTestFunction(
+      loader: ClassLoader,
+      taskDef: TaskDef,
+      runner: TestRunner,
+      testTask: TestTask
+  ): TestFunction =
+    new TestFunction(
+      taskDef,
+      runner,
+      (r: TestRunner) => withContextLoader(loader) { r.run(taskDef, testTask) }
+    ) {
+      def tags = testTask.tags
     }
-  def createTestLoader(classpath: Seq[File], scalaInstance: ScalaInstance, tempDir: File): ClassLoader =
-    {
-      val interfaceJar = IO.classLocationFile(classOf[testing.Framework])
-      val interfaceFilter = (name: String) => name.startsWith("org.scalatools.testing.") || name.startsWith("sbt.testing.")
-      val notInterfaceFilter = (name: String) => !interfaceFilter(name)
-      val dual = new DualLoader(scalaInstance.loader, notInterfaceFilter, x => true, getClass.getClassLoader, interfaceFilter, x => false)
-      val main = ClasspathUtilities.makeLoader(classpath, dual, scalaInstance, tempDir)
-      // TODO - There's actually an issue with the classpath facility such that unmanagedScalaInstances are not added
-      // to the classpath correctly.  We have a temporary workaround here.
-      val cp: Seq[File] =
-        if (scalaInstance.isManagedVersion) interfaceJar +: classpath
-        else scalaInstance.allJars ++ (interfaceJar +: classpath)
-      ClasspathUtilities.filterByClasspath(cp, main)
-    }
-  def createTestFunction(loader: ClassLoader, taskDef: TaskDef, runner: TestRunner, testTask: TestTask): TestFunction =
-    new TestFunction(taskDef, runner, (r: TestRunner) => withContextLoader(loader) { r.run(taskDef, testTask) }) { def tags = testTask.tags }
 }
 
-abstract class TestFunction(val taskDef: TaskDef, val runner: TestRunner, fun: (TestRunner) => (SuiteResult, Seq[TestTask])) {
+abstract class TestFunction(
+    val taskDef: TaskDef,
+    val runner: TestRunner,
+    fun: (TestRunner) => (SuiteResult, Seq[TestTask])
+) {
 
   def apply(): (SuiteResult, Seq[TestTask]) = fun(runner)
 
diff --git a/testing/src/main/scala/sbt/TestReportListener.scala b/testing/src/main/scala/sbt/TestReportListener.scala
index c2679985c..08df6c415 100644
--- a/testing/src/main/scala/sbt/TestReportListener.scala
+++ b/testing/src/main/scala/sbt/TestReportListener.scala
@@ -1,14 +1,17 @@
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009  Steven Blundy, Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
 
 package sbt
 
 import testing.{ Logger => TLogger, Event => TEvent, Status => TStatus }
-import sbt.internal.util.{ BufferedLogger, FullLogger }
-import sbt.util.Level
+import sbt.protocol.testing._
 
 trait TestReportListener {
+
   /** called for each class or equivalent grouping */
   def startGroup(name: String): Unit
 
@@ -19,52 +22,105 @@ trait TestReportListener {
   def endGroup(name: String, t: Throwable): Unit
 
   /** called if test completed */
-  def endGroup(name: String, result: TestResult.Value): Unit
+  def endGroup(name: String, result: TestResult): Unit
+
+  /** Used by the test framework for logging test results */
+  def contentLogger(@deprecated("unused", "") test: TestDefinition): Option[ContentLogger] = None
 
-  /** Used by the test framework for logging test results*/
-  def contentLogger(test: TestDefinition): Option[ContentLogger] = None
 }
 
+final class ContentLogger(val log: TLogger, val flush: () => Unit)
+
 trait TestsListener extends TestReportListener {
+
   /** called once, at beginning. */
   def doInit(): Unit
 
-  /** called once, at end. */
-  def doComplete(finalResult: TestResult.Value): Unit
+  /** called once, at end of the test group. */
+  def doComplete(finalResult: TestResult): Unit
+
 }
 
 /** Provides the overall `result` of a group of tests (a suite) and test counts for each result type. */
 final class SuiteResult(
-    val result: TestResult.Value,
-    val passedCount: Int, val failureCount: Int, val errorCount: Int,
-    val skippedCount: Int, val ignoredCount: Int, val canceledCount: Int, val pendingCount: Int) {
+    val result: TestResult,
+    val passedCount: Int,
+    val failureCount: Int,
+    val errorCount: Int,
+    val skippedCount: Int,
+    val ignoredCount: Int,
+    val canceledCount: Int,
+    val pendingCount: Int,
+    val throwables: Seq[Throwable]
+) {
+  def this(
+      result: TestResult,
+      passedCount: Int,
+      failureCount: Int,
+      errorCount: Int,
+      skippedCount: Int,
+      ignoredCount: Int,
+      canceledCount: Int,
+      pendingCount: Int,
+  ) =
+    this(
+      result,
+      passedCount,
+      failureCount,
+      errorCount,
+      skippedCount,
+      ignoredCount,
+      canceledCount,
+      pendingCount,
+      Nil
+    )
   def +(other: SuiteResult): SuiteResult = {
     val combinedTestResult =
       (result, other.result) match {
-        case (TestResult.Passed, TestResult.Passed) => TestResult.Passed
-        case (_, TestResult.Error)                  => TestResult.Error
-        case (TestResult.Error, _)                  => TestResult.Error
-        case _                                      => TestResult.Failed
+        case (TestResult.Passed, TestResult.Passed) => TestResult.Passed: TestResult
+        case (_, TestResult.Error)                  => TestResult.Error: TestResult
+        case (TestResult.Error, _)                  => TestResult.Error: TestResult
+        case _                                      => TestResult.Failed: TestResult
       }
-    new SuiteResult(combinedTestResult, passedCount + other.passedCount, failureCount + other.failureCount, errorCount + other.errorCount, skippedCount + other.skippedCount,
-      ignoredCount + other.ignoredCount, canceledCount + other.canceledCount, pendingCount + other.pendingCount)
+    new SuiteResult(
+      combinedTestResult,
+      passedCount + other.passedCount,
+      failureCount + other.failureCount,
+      errorCount + other.errorCount,
+      skippedCount + other.skippedCount,
+      ignoredCount + other.ignoredCount,
+      canceledCount + other.canceledCount,
+      pendingCount + other.pendingCount,
+      throwables ++ other.throwables
+    )
   }
 }
 
 object SuiteResult {
+
   /** Computes the overall result and counts for a suite with individual test results in `events`. */
-  def apply(events: Seq[TEvent]): SuiteResult =
-    {
-      def count(status: TStatus) = events.count(_.status == status)
-      new SuiteResult(TestEvent.overallResult(events), count(TStatus.Success), count(TStatus.Failure), count(TStatus.Error),
-        count(TStatus.Skipped), count(TStatus.Ignored), count(TStatus.Canceled), count(TStatus.Pending))
-    }
+  def apply(events: Seq[TEvent]): SuiteResult = {
+    def count(status: TStatus) = events.count(_.status == status)
+    new SuiteResult(
+      TestEvent.overallResult(events),
+      count(TStatus.Success),
+      count(TStatus.Failure),
+      count(TStatus.Error),
+      count(TStatus.Skipped),
+      count(TStatus.Ignored),
+      count(TStatus.Canceled),
+      count(TStatus.Pending),
+      events.collect { case e if e.throwable.isDefined => e.throwable.get }
+    )
+  }
+
   val Error: SuiteResult = new SuiteResult(TestResult.Error, 0, 0, 0, 0, 0, 0, 0)
   val Empty: SuiteResult = new SuiteResult(TestResult.Passed, 0, 0, 0, 0, 0, 0, 0)
+
 }
 
 abstract class TestEvent {
-  def result: Option[TestResult.Value]
+  def result: Option[TestResult]
   def detail: Seq[TEvent] = Nil
 }
 object TestEvent {
@@ -74,8 +130,8 @@ object TestEvent {
       override val detail = events
     }
 
-  private[sbt] def overallResult(events: Seq[TEvent]): TestResult.Value =
-    (TestResult.Passed /: events) { (sum, event) =>
+  private[sbt] def overallResult(events: Seq[TEvent]): TestResult =
+    events.foldLeft(TestResult.Passed: TestResult) { (sum, event) =>
       (sum, event.status) match {
         case (TestResult.Error, _)  => TestResult.Error
         case (_, TStatus.Error)     => TestResult.Error
@@ -85,60 +141,3 @@ object TestEvent {
       }
     }
 }
-
-object TestLogger {
-  @deprecated("Doesn't provide for underlying resources to be released.", "0.13.1")
-  def apply(logger: sbt.util.Logger, logTest: TestDefinition => sbt.util.Logger, buffered: Boolean): TestLogger =
-    new TestLogger(new TestLogging(wrap(logger), tdef => contentLogger(logTest(tdef), buffered)))
-
-  @deprecated("Doesn't provide for underlying resources to be released.", "0.13.1")
-  def contentLogger(log: sbt.util.Logger, buffered: Boolean): ContentLogger =
-    {
-      val blog = new BufferedLogger(FullLogger(log))
-      if (buffered) blog.record()
-      new ContentLogger(wrap(blog), () => blog.stopQuietly())
-    }
-
-  final class PerTest private[sbt] (val log: sbt.util.Logger, val flush: () => Unit, val buffered: Boolean)
-
-  def make(global: sbt.util.Logger, perTest: TestDefinition => PerTest): TestLogger =
-    {
-      def makePerTest(tdef: TestDefinition): ContentLogger =
-        {
-          val per = perTest(tdef)
-          val blog = new BufferedLogger(FullLogger(per.log))
-          if (per.buffered) blog.record()
-          new ContentLogger(wrap(blog), () => { blog.stopQuietly(); per.flush() })
-        }
-      val config = new TestLogging(wrap(global), makePerTest)
-      new TestLogger(config)
-    }
-
-  def wrap(logger: sbt.util.Logger): TLogger =
-    new TLogger {
-      def error(s: String) = log(Level.Error, s)
-      def warn(s: String) = log(Level.Warn, s)
-      def info(s: String) = log(Level.Info, s)
-      def debug(s: String) = log(Level.Debug, s)
-      def trace(t: Throwable) = logger.trace(t)
-      private def log(level: Level.Value, s: String) = logger.log(level, s)
-      def ansiCodesSupported() = logger.ansiCodesSupported
-    }
-}
-final class TestLogging(val global: TLogger, val logTest: TestDefinition => ContentLogger)
-final class ContentLogger(val log: TLogger, val flush: () => Unit)
-class TestLogger(val logging: TestLogging) extends TestsListener {
-  import logging.{ global => log, logTest }
-
-  def startGroup(name: String): Unit = ()
-  def testEvent(event: TestEvent): Unit = ()
-  def endGroup(name: String, t: Throwable): Unit = {
-    log.trace(t)
-    log.error("Could not run test " + name + ": " + t.toString)
-  }
-  def endGroup(name: String, result: TestResult.Value): Unit = ()
-  def doInit: Unit = ()
-  /** called once, at end of test group. */
-  def doComplete(finalResult: TestResult.Value): Unit = ()
-  override def contentLogger(test: TestDefinition): Option[ContentLogger] = Some(logTest(test))
-}
diff --git a/testing/src/main/scala/sbt/TestStatusReporter.scala b/testing/src/main/scala/sbt/TestStatusReporter.scala
index 738b6c6cf..38a7987ac 100644
--- a/testing/src/main/scala/sbt/TestStatusReporter.scala
+++ b/testing/src/main/scala/sbt/TestStatusReporter.scala
@@ -1,40 +1,49 @@
-/* sbt -- Simple Build Tool
- * Copyright 2009, 2010, 2011, 2012 Mark Harrah
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
  */
+
 package sbt
 
 import java.io.File
-import sbt.io.IO
 
-import scala.collection.mutable.Map
+import sbt.io.IO
+import sbt.protocol.testing.TestResult
+import java.util.concurrent.ConcurrentHashMap
+
+import scala.collection.concurrent
 
 // Assumes exclusive ownership of the file.
 private[sbt] class TestStatusReporter(f: File) extends TestsListener {
-  private lazy val succeeded = TestStatus.read(f)
+  private lazy val succeeded: concurrent.Map[String, Long] = TestStatus.read(f)
 
   def doInit = ()
-  def startGroup(name: String): Unit = { succeeded remove name }
+  def startGroup(name: String): Unit = { succeeded remove name; () }
   def testEvent(event: TestEvent): Unit = ()
   def endGroup(name: String, t: Throwable): Unit = ()
-  def endGroup(name: String, result: TestResult.Value): Unit = {
+  def endGroup(name: String, result: TestResult): Unit = {
     if (result == TestResult.Passed)
       succeeded(name) = System.currentTimeMillis
   }
-  def doComplete(finalResult: TestResult.Value): Unit = {
+  def doComplete(finalResult: TestResult): Unit = {
     TestStatus.write(succeeded, "Successful Tests", f)
   }
 }
 
 private[sbt] object TestStatus {
   import java.util.Properties
-  def read(f: File): Map[String, Long] =
-    {
-      import scala.collection.JavaConverters._
-      val properties = new Properties
-      IO.load(properties, f)
-      properties.asScala map { case (k, v) => (k, v.toLong) }
-    }
-  def write(map: Map[String, Long], label: String, f: File): Unit = {
+  def read(f: File): concurrent.Map[String, Long] = {
+    import scala.collection.JavaConverters._
+    val properties = new Properties
+    IO.load(properties, f)
+    val result = new ConcurrentHashMap[String, Long]()
+    properties.asScala.iterator.foreach { case (k, v) => result.put(k, v.toLong) }
+    result.asScala
+  }
+
+  def write(map: collection.Map[String, Long], label: String, f: File): Unit = {
     val properties = new Properties
     for ((test, lastSuccessTime) <- map)
       properties.setProperty(test, lastSuccessTime.toString)
diff --git a/testing/src/main/scala/sbt/internal/testing/StatusFormats.scala b/testing/src/main/scala/sbt/internal/testing/StatusFormats.scala
new file mode 100644
index 000000000..51729dcb3
--- /dev/null
+++ b/testing/src/main/scala/sbt/internal/testing/StatusFormats.scala
@@ -0,0 +1,45 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.testing
+
+import sbt.testing.Status
+
+import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder }
+
+trait StatusFormats { self: sjsonnew.BasicJsonProtocol =>
+  implicit lazy val StatusFormat: JsonFormat[Status] = new JsonFormat[Status] {
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Status = {
+      jsOpt match {
+        case Some(js) =>
+          unbuilder.readString(js) match {
+            case "Success"  => Status.Success
+            case "Error"    => Status.Error
+            case "Failure"  => Status.Failure
+            case "Skipped"  => Status.Skipped
+            case "Ignored"  => Status.Ignored
+            case "Canceled" => Status.Canceled
+            case "Pending"  => Status.Pending
+          }
+        case None =>
+          deserializationError("Expected JsString but found None")
+      }
+    }
+    override def write[J](obj: Status, builder: Builder[J]): Unit = {
+      val str = obj match {
+        case Status.Success  => "Success"
+        case Status.Error    => "Error"
+        case Status.Failure  => "Failure"
+        case Status.Skipped  => "Skipped"
+        case Status.Ignored  => "Ignored"
+        case Status.Canceled => "Canceled"
+        case Status.Pending  => "Pending"
+      }
+      builder.writeString(str)
+    }
+  }
+}
diff --git a/testing/src/main/scala/sbt/internal/testing/TestLogger.scala b/testing/src/main/scala/sbt/internal/testing/TestLogger.scala
new file mode 100644
index 000000000..86ca21de2
--- /dev/null
+++ b/testing/src/main/scala/sbt/internal/testing/TestLogger.scala
@@ -0,0 +1,151 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal.testing
+
+import testing.{ Logger => TLogger }
+import sbt.internal.util.{ BufferedAppender, ManagedLogger, Terminal }
+import sbt.util.{ Level, ShowLines }
+import sbt.protocol.testing._
+import java.util.concurrent.atomic.AtomicInteger
+
+object TestLogger {
+  import sbt.protocol.testing.codec.JsonProtocol._
+
+  implicit val testStringEventShowLines: ShowLines[TestStringEvent] =
+    ShowLines[TestStringEvent]({
+      case a: TestStringEvent => List(a.value)
+    })
+
+  private def generateName: String = "test-" + generateId.incrementAndGet
+  private val generateId: AtomicInteger = new AtomicInteger
+
+  private def generateBufferName: String = "testbuffer-" + generateBufferId.incrementAndGet
+  private val generateBufferId: AtomicInteger = new AtomicInteger
+
+  final class PerTest private[sbt] (
+      val log: ManagedLogger,
+      val flush: () => Unit,
+      val buffered: Boolean
+  )
+
+  @deprecated("Use make variant that accepts a log level.", "1.4.0")
+  def make(
+      global: ManagedLogger,
+      perTest: TestDefinition => PerTest,
+  ): TestLogger = make(global, perTest, Level.Debug)
+
+  def make(
+      global: ManagedLogger,
+      perTest: TestDefinition => PerTest,
+      level: Level.Value
+  ): TestLogger = {
+    val context = global.context
+    val as = context.appenders(global.name)
+    def makePerTest(tdef: TestDefinition): ContentLogger = {
+      val per = perTest(tdef)
+      val l0 = per.log
+      val buffs = as.map(a => BufferedAppender(generateBufferName, a)).toList
+      val newLog = context.logger(generateName, l0.channelName, l0.execId)
+      context.clearAppenders(newLog.name)
+      buffs.foreach { b =>
+        context.addAppender(newLog.name, b -> level)
+      }
+      if (per.buffered) {
+        buffs foreach { _.record() }
+      }
+      new ContentLogger(
+        wrap(newLog),
+        () => {
+          buffs foreach { _.stopQuietly() }
+          per.flush()
+          // do not unbind here. since there's a delay in the async appender,
+          // it will result in missing log output.
+        }
+      )
+    }
+
+    global.registerStringCodec[TestStringEvent]
+
+    def showNoLines[A] = ShowLines[A](_ => Nil)
+    implicit val showNoLinesTestInitEvent = showNoLines[TestInitEvent]
+    implicit val showNoLinesStartTestGroupEvent = showNoLines[StartTestGroupEvent]
+    implicit val showNoLinesTestItemEvent = showNoLines[TestItemEvent]
+    implicit val showNoLinesEndTestGroupEvent = showNoLines[EndTestGroupEvent]
+    implicit val showNoLinesTestCompleteEvent = showNoLines[TestCompleteEvent]
+    global.registerStringCodec[TestInitEvent]
+    global.registerStringCodec[StartTestGroupEvent]
+    global.registerStringCodec[TestItemEvent]
+    global.registerStringCodec[EndTestGroupEvent]
+    global.registerStringCodec[TestCompleteEvent]
+
+    val config = new TestLogging(wrap(global), global, makePerTest)
+    new TestLogger(config)
+  }
+
+  def wrap(logger: ManagedLogger): TLogger =
+    new TLogger {
+      def error(s: String) = log(Level.Error, TestStringEvent(s))
+      def warn(s: String) = log(Level.Warn, TestStringEvent(s))
+      def info(s: String) = log(Level.Info, TestStringEvent(s))
+      def debug(s: String) = log(Level.Debug, TestStringEvent(s))
+      def trace(t: Throwable) = logger.trace(t)
+      private def log(level: Level.Value, event: TestStringEvent) = logger.logEvent(level, event)
+      def ansiCodesSupported() = Terminal.isAnsiSupported
+    }
+
+  private[sbt] def toTestItemEvent(event: TestEvent): TestItemEvent =
+    TestItemEvent(
+      event.result,
+      event.detail.toVector map { d =>
+        TestItemDetail(
+          d.fullyQualifiedName,
+          d.status,
+          d.duration match {
+            case -1 => (None: Option[Long]) // util.Util is not in classpath
+            case x  => (Some(x): Option[Long])
+          }
+        )
+      }
+    )
+}
+final class TestLogging(
+    val global: TLogger,
+    val managed: ManagedLogger,
+    val logTest: TestDefinition => ContentLogger
+)
+
+class TestLogger(val logging: TestLogging) extends TestsListener {
+  import TestLogger._
+  import logging.{ global => log, logTest, managed }
+  import sbt.protocol.testing.codec.JsonProtocol._
+
+  def doInit: Unit = managed.logEvent(Level.Info, TestInitEvent())
+
+  def startGroup(name: String): Unit = managed.logEvent(Level.Info, StartTestGroupEvent(name))
+
+  def testEvent(event: TestEvent): Unit = managed.logEvent(Level.Info, toTestItemEvent(event))
+
+  def endGroup(name: String, result: TestResult): Unit =
+    managed.logEvent(Level.Info, EndTestGroupEvent(name, result))
+
+  def endGroup(name: String, t: Throwable): Unit = {
+    log.trace(t)
+    log.error(s"Could not run test $name: $t")
+    managed.logEvent(
+      Level.Info,
+      EndTestGroupErrorEvent(name, (t.getMessage + t.getStackTrace.toString).mkString("\n"))
+    )
+    ()
+  }
+
+  def doComplete(finalResult: TestResult): Unit =
+    managed.logEvent(Level.Info, TestCompleteEvent(finalResult))
+
+  override def contentLogger(test: TestDefinition): Option[ContentLogger] = Some(logTest(test))
+}
diff --git a/util-cache/NOTICE b/util-cache/NOTICE
new file mode 100644
index 000000000..8f0040336
--- /dev/null
+++ b/util-cache/NOTICE
@@ -0,0 +1,3 @@
+Simple Build Tool: Cache Component
+Copyright 2009  Mark Harrah
+Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
diff --git a/util-cache/src/main/scala/sbt/internal/util/EmptyCacheError.scala b/util-cache/src/main/scala/sbt/internal/util/EmptyCacheError.scala
new file mode 100644
index 000000000..a3e555859
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/internal/util/EmptyCacheError.scala
@@ -0,0 +1,12 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package util
+
+class EmptyCacheError extends RuntimeException
diff --git a/util-cache/src/main/scala/sbt/util/BasicCacheImplicits.scala b/util-cache/src/main/scala/sbt/util/BasicCacheImplicits.scala
new file mode 100644
index 000000000..f0931a4fb
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/BasicCacheImplicits.scala
@@ -0,0 +1,25 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import sjsonnew.{ BasicJsonProtocol, JsonFormat }
+
+trait BasicCacheImplicits { self: BasicJsonProtocol =>
+
+  implicit def basicCache[I: JsonFormat, O: JsonFormat]: Cache[I, O] =
+    new BasicCache[I, O]()
+
+  def wrapIn[I, J](implicit f: I => J, g: J => I, jCache: SingletonCache[J]): SingletonCache[I] =
+    new SingletonCache[I] {
+      override def read(from: Input): I = g(jCache.read(from))
+      override def write(to: Output, value: I) = jCache.write(to, f(value))
+    }
+
+  def singleton[T](t: T): SingletonCache[T] =
+    SingletonCache.basicSingletonCache(asSingleton(t))
+}
diff --git a/util-cache/src/main/scala/sbt/util/Cache.scala b/util-cache/src/main/scala/sbt/util/Cache.scala
new file mode 100644
index 000000000..c0cbd9a8e
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/Cache.scala
@@ -0,0 +1,82 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.io.File
+
+/** The result of a cache query */
+sealed trait CacheResult[K]
+
+/** A successful hit on the cache */
+case class Hit[O](value: O) extends CacheResult[O]
+
+/**
+ * A cache miss.
+ * `update` associates the missing key with `O` in the cache.
+ */
+case class Miss[O](update: O => Unit) extends CacheResult[O]
+
+/**
+ * A simple cache with keys of type `I` and values of type `O`
+ */
+trait Cache[I, O] {
+
+  /**
+   * Queries the cache backed with store `store` for key `key`.
+   */
+  def apply(store: CacheStore)(key: I): CacheResult[O]
+}
+
+object Cache {
+
+  /**
+   * Materializes a cache.
+   */
+  def cache[I, O](implicit c: Cache[I, O]): Cache[I, O] = c
+
+  /**
+   * Returns a function that represents a cache that inserts on miss.
+   *
+   * @param cacheFile The store that backs this cache.
+   * @param default   A function that computes a default value to insert on
+   */
+  def cached[I, O](cacheFile: File)(default: I => O)(implicit cache: Cache[I, O]): I => O =
+    cached(CacheStore(cacheFile))(default)
+
+  /**
+   * Returns a function that represents a cache that inserts on miss.
+   *
+   * @param store    The store that backs this cache.
+   * @param default  A function that computes a default value to insert on
+   */
+  def cached[I, O](store: CacheStore)(default: I => O)(implicit cache: Cache[I, O]): I => O =
+    key =>
+      cache(store)(key) match {
+        case Hit(value) =>
+          value
+
+        case Miss(update) =>
+          val result = default(key)
+          update(result)
+          result
+      }
+
+  def debug[I](label: String, cache: SingletonCache[I]): SingletonCache[I] =
+    new SingletonCache[I] {
+      override def read(from: Input): I = {
+        val value = cache.read(from)
+        println(label + ".read: " + value)
+        value
+      }
+
+      override def write(to: Output, value: I): Unit = {
+        println(label + ".write: " + value)
+        cache.write(to, value)
+      }
+    }
+}
diff --git a/util-cache/src/main/scala/sbt/util/CacheImplicits.scala b/util-cache/src/main/scala/sbt/util/CacheImplicits.scala
new file mode 100644
index 000000000..ba72b9d79
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/CacheImplicits.scala
@@ -0,0 +1,13 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import sjsonnew.BasicJsonProtocol
+
+object CacheImplicits extends CacheImplicits
+trait CacheImplicits extends BasicCacheImplicits with BasicJsonProtocol
diff --git a/util-cache/src/main/scala/sbt/util/CacheStore.scala b/util-cache/src/main/scala/sbt/util/CacheStore.scala
new file mode 100644
index 000000000..42cc10c40
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/CacheStore.scala
@@ -0,0 +1,105 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.io.{ File, InputStream, OutputStream }
+
+import sbt.io.syntax.fileToRichFile
+import sbt.io.IO
+import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Parser }
+import sjsonnew.{ IsoString, JsonReader, JsonWriter, SupportConverter }
+
+/** A `CacheStore` is used by the caching infrastructure to persist cached information. */
+abstract class CacheStore extends Input with Output {
+
+  /** Delete the persisted information. */
+  def delete(): Unit
+
+}
+
+object CacheStore {
+  @deprecated("Create your own IsoString[JValue]", "1.4")
+  implicit lazy val jvalueIsoString: IsoString[JValue] =
+    IsoString.iso(CompactPrinter.apply, Parser.parseUnsafe)
+
+  /** Returns file-based CacheStore using standard JSON converter. */
+  def apply(cacheFile: File): CacheStore = file(cacheFile)
+
+  /** Returns file-based CacheStore using standard JSON converter. */
+  def file(cacheFile: File): CacheStore = new FileBasedStore(cacheFile)
+}
+
+/** Factory that can make new stores. */
+abstract class CacheStoreFactory {
+
+  /** Create a new store. */
+  def make(identifier: String): CacheStore
+
+  /** Create a new `CacheStoreFactory` from this factory. */
+  def sub(identifier: String): CacheStoreFactory
+
+  /** A symbolic alias for `sub`. */
+  final def /(identifier: String): CacheStoreFactory = sub(identifier)
+}
+
+object CacheStoreFactory {
+  @deprecated("Create your own IsoString[JValue]", "1.4")
+  implicit lazy val jvalueIsoString: IsoString[JValue] =
+    IsoString.iso(CompactPrinter.apply, Parser.parseUnsafe)
+
+  /** Returns directory-based CacheStoreFactory using standard JSON converter. */
+  def apply(base: File): CacheStoreFactory = directory(base)
+
+  /** Returns directory-based CacheStoreFactory using standard JSON converter. */
+  def directory(base: File): CacheStoreFactory = new DirectoryStoreFactory(base)
+}
+
+/** A factory that creates new stores persisted in `base`. */
+class DirectoryStoreFactory[J](base: File) extends CacheStoreFactory {
+  IO.createDirectory(base)
+
+  @deprecated("Use constructor without converter", "1.4")
+  def this(base: File, converter: sjsonnew.SupportConverter[J])(implicit e: sjsonnew.IsoString[J]) =
+    this(base)
+
+  def make(identifier: String): CacheStore = new FileBasedStore(base / identifier)
+
+  def sub(identifier: String): CacheStoreFactory =
+    new DirectoryStoreFactory(base / identifier)
+}
+
+/** A `CacheStore` that persists information in `file`. */
+class FileBasedStore[J](file: File) extends CacheStore {
+  IO.touch(file, setModified = false)
+
+  @deprecated("Use constructor without converter", "1.4")
+  def this(file: File, converter: sjsonnew.SupportConverter[J])(implicit e: sjsonnew.IsoString[J]) =
+    this(file)
+
+  def read[T: JsonReader]() =
+    new FileInput(file).read()
+
+  def write[T: JsonWriter](value: T) =
+    new FileOutput(file).write(value)
+
+  def delete() = IO.delete(file)
+  def close() = ()
+}
+
+/** A store that reads from `inputStream` and writes to `outputStream`. */
+class StreamBasedStore[J: IsoString](
+    inputStream: InputStream,
+    outputStream: OutputStream,
+    converter: SupportConverter[J]
+) extends CacheStore {
+  def read[T: JsonReader]() = new PlainInput(inputStream, converter).read()
+  def write[T: JsonWriter](value: T) = new PlainOutput(outputStream, converter).write(value)
+  def delete() = ()
+  def close() = { inputStream.close(); outputStream.close() }
+}
diff --git a/util-cache/src/main/scala/sbt/util/FileInfo.scala b/util-cache/src/main/scala/sbt/util/FileInfo.scala
new file mode 100644
index 000000000..b9d0e646d
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/FileInfo.scala
@@ -0,0 +1,267 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.io.File
+
+import scala.util.control.NonFatal
+import sbt.io.{ Hash, IO }
+import sjsonnew.{ Builder, DeserializationException, JsonFormat, Unbuilder, deserializationError }
+import CacheImplicits.{ arrayFormat => _, _ }
+import sbt.nio.file._
+import sbt.nio.file.syntax._
+
+sealed trait FileInfo { def file: File }
+sealed trait HashFileInfo extends FileInfo {
+  @deprecated("Use hashArray instead", "1.3.0")
+  def hash: List[Byte] = hashArray.toList
+  private[util] def hashArray: Array[Byte]
+}
+sealed trait ModifiedFileInfo extends FileInfo { def lastModified: Long }
+sealed trait PlainFileInfo extends FileInfo { def exists: Boolean }
+
+sealed trait HashModifiedFileInfo extends HashFileInfo with ModifiedFileInfo
+
+object HashFileInfo {
+  implicit val format: JsonFormat[HashFileInfo] = FileInfo.hash.format
+}
+object ModifiedFileInfo {
+  implicit val format: JsonFormat[ModifiedFileInfo] = FileInfo.lastModified.format
+}
+object PlainFileInfo {
+  implicit val format: JsonFormat[PlainFileInfo] = FileInfo.exists.format
+}
+object HashModifiedFileInfo {
+  implicit val format: JsonFormat[HashModifiedFileInfo] = FileInfo.full.format
+}
+
+private final case class PlainFile(file: File, exists: Boolean) extends PlainFileInfo
+private final case class FileModified(file: File, lastModified: Long) extends ModifiedFileInfo
+@deprecated("Kept for plugin compat, but will be removed in sbt 2.0", "1.3.0")
+private final case class FileHash(file: File, override val hash: List[Byte]) extends HashFileInfo {
+  override val hashArray: Array[Byte] = hash.toArray
+}
+private final case class FileHashArrayRepr(file: File, override val hashArray: Array[Byte])
+    extends HashFileInfo {
+  override def hashCode(): Int = (file, java.util.Arrays.hashCode(hashArray)).hashCode()
+  override def equals(obj: Any): Boolean = obj match {
+    case that: FileHashArrayRepr =>
+      this.file == that.file && java.util.Arrays.equals(this.hashArray, that.hashArray)
+    case _ => false
+  }
+}
+@deprecated("Kept for plugin compat, but will be removed in sbt 2.0", "1.3.0")
+private final case class FileHashModified(
+    file: File,
+    override val hash: List[Byte],
+    lastModified: Long
+) extends HashModifiedFileInfo {
+  override val hashArray: Array[Byte] = hash.toArray
+}
+private final case class FileHashModifiedArrayRepr(
+    file: File,
+    override val hashArray: Array[Byte],
+    lastModified: Long
+) extends HashModifiedFileInfo
+
+final case class FilesInfo[F <: FileInfo] private (files: Set[F])
+object FilesInfo {
+  def empty[F <: FileInfo]: FilesInfo[F] = FilesInfo(Set.empty[F])
+
+  implicit def format[F <: FileInfo: JsonFormat]: JsonFormat[FilesInfo[F]] =
+    projectFormat(_.files, (fs: Set[F]) => FilesInfo(fs))
+
+  def full: FileInfo.Style = FileInfo.full
+  def hash: FileInfo.Style = FileInfo.hash
+  def lastModified: FileInfo.Style = FileInfo.lastModified
+  def exists: FileInfo.Style = FileInfo.exists
+}
+
+object FileInfo {
+
+  /**
+   * Stores byte arrays as hex encoded strings, but falls back to reading an array of integers,
+   * which is how it used to be stored, if that fails.
+   */
+  implicit val byteArrayFormat: JsonFormat[Array[Byte]] = new JsonFormat[Array[Byte]] {
+    override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Array[Byte] = {
+      jsOpt match {
+        case Some(js) =>
+          try {
+            Hash.fromHex(unbuilder.readString(js))
+          } catch {
+            case _: DeserializationException =>
+              CacheImplicits.arrayFormat[Byte].read(jsOpt, unbuilder)
+          }
+        case None => Array.empty
+      }
+    }
+
+    override def write[J](obj: Array[Byte], builder: Builder[J]): Unit = {
+      builder.writeString(Hash.toHex(obj))
+    }
+  }
+
+  sealed trait Style {
+    type F <: FileInfo
+
+    implicit def format: JsonFormat[F]
+    implicit def formats: JsonFormat[FilesInfo[F]] =
+      projectFormat(_.files, (fs: Set[F]) => FilesInfo(fs))
+
+    def apply(file: File): F
+    def apply(files: Set[File]): FilesInfo[F] = FilesInfo(files map apply)
+
+    def unapply(info: F): File = info.file
+    def unapply(infos: FilesInfo[F]): Set[File] = infos.files map (_.file)
+  }
+
+  object full extends Style {
+    type F = HashModifiedFileInfo
+
+    implicit val format: JsonFormat[HashModifiedFileInfo] = new JsonFormat[HashModifiedFileInfo] {
+      def write[J](obj: HashModifiedFileInfo, builder: Builder[J]) = {
+        builder.beginObject()
+        builder.addField("file", obj.file)
+        builder.addField("hash", obj.hashArray)
+        builder.addField("lastModified", obj.lastModified)
+        builder.endObject()
+      }
+
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+        case Some(js) =>
+          unbuilder.beginObject(js)
+          val file = unbuilder.readField[File]("file")
+          val hash = unbuilder.readField[Array[Byte]]("hash")
+          val lastModified = unbuilder.readField[Long]("lastModified")
+          unbuilder.endObject()
+          FileHashModifiedArrayRepr(file, hash, lastModified)
+        case None => deserializationError("Expected JsObject but found None")
+      }
+    }
+
+    implicit def apply(file: File): HashModifiedFileInfo =
+      FileHashModifiedArrayRepr(file.getAbsoluteFile, Hash(file), IO.getModifiedTimeOrZero(file))
+    def apply(file: File, hash: Array[Byte], lastModified: Long): HashModifiedFileInfo =
+      FileHashModifiedArrayRepr(file.getAbsoluteFile, hash, lastModified)
+  }
+
+  object hash extends Style {
+    type F = HashFileInfo
+
+    implicit val format: JsonFormat[HashFileInfo] = new JsonFormat[HashFileInfo] {
+      def write[J](obj: HashFileInfo, builder: Builder[J]) = {
+        builder.beginObject()
+        builder.addField("file", obj.file)
+        builder.addField("hash", obj.hashArray)
+        builder.endObject()
+      }
+
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+        case Some(js) =>
+          unbuilder.beginObject(js)
+          val file = unbuilder.readField[File]("file")
+          val hash = unbuilder.readField[Array[Byte]]("hash")
+          unbuilder.endObject()
+          FileHashArrayRepr(file, hash)
+        case None => deserializationError("Expected JsObject but found None")
+      }
+    }
+
+    implicit def apply(file: File): HashFileInfo =
+      FileHashArrayRepr(file.getAbsoluteFile, computeHash(file))
+    def apply(file: File, bytes: Array[Byte]): HashFileInfo =
+      FileHashArrayRepr(file.getAbsoluteFile, bytes)
+
+    private def computeHash(file: File): Array[Byte] =
+      try Hash(file)
+      catch { case NonFatal(_) => Array.empty }
+  }
+
+  object lastModified extends Style {
+    type F = ModifiedFileInfo
+
+    implicit val format: JsonFormat[ModifiedFileInfo] = new JsonFormat[ModifiedFileInfo] {
+      override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): ModifiedFileInfo =
+        jsOpt match {
+          case Some(js) =>
+            unbuilder.beginObject(js)
+            val file = unbuilder.readField[File]("file")
+            val lastModified = unbuilder.readField[Long]("lastModified")
+            unbuilder.endObject()
+            FileModified(file, lastModified)
+          case None =>
+            deserializationError("Expected JsObject but found None")
+        }
+
+      override def write[J](obj: ModifiedFileInfo, builder: Builder[J]): Unit = {
+        builder.beginObject()
+        builder.addField("file", obj.file)
+        builder.addField("lastModified", obj.lastModified)
+        builder.endObject()
+      }
+    }
+
+    implicit def apply(file: File): ModifiedFileInfo =
+      FileModified(file.getAbsoluteFile, IO.getModifiedTimeOrZero(file))
+    def apply(file: File, lastModified: Long): ModifiedFileInfo =
+      FileModified(file.getAbsoluteFile, lastModified)
+
+    /**
+     * Returns an instance of [[FileModified]] where, for any directory, the maximum last
+     * modified time taken from its contents is used rather than the last modified time of the
+     * directory itself. The specific motivation was to prevent the doc task from re-running when
+     * the modified time changed for a directory classpath but none of the classfiles had changed.
+     *
+     * @param file the file or directory
+     * @return the [[FileModified]]
+     */
+    private[sbt] def fileOrDirectoryMax(file: File): ModifiedFileInfo = {
+      val maxLastModified =
+        if (file.isDirectory) FileTreeView.default.list(file.toGlob / **).foldLeft(0L) {
+          case (max, (path, attributes)) =>
+            val lm = if (!attributes.isDirectory) IO.getModifiedTimeOrZero(path.toFile) else 0L
+            if (lm > max) lm else max
+        }
+        else IO.getModifiedTimeOrZero(file)
+      FileModified(file, maxLastModified)
+    }
+  }
+
+  object exists extends Style {
+    type F = PlainFileInfo
+
+    implicit val format: JsonFormat[PlainFileInfo] = new JsonFormat[PlainFileInfo] {
+      def write[J](obj: PlainFileInfo, builder: Builder[J]): Unit = {
+        builder.beginObject()
+        builder.addField("file", obj.file)
+        builder.addField("exists", obj.exists)
+        builder.endObject()
+      }
+
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+        case Some(js) =>
+          unbuilder.beginObject(js)
+          val file = unbuilder.readField[File]("file")
+          val exists = unbuilder.readField[Boolean]("exists")
+          unbuilder.endObject()
+          PlainFile(file, exists)
+        case None => deserializationError("Expected JsObject but found None")
+      }
+    }
+
+    implicit def apply(file: File): PlainFileInfo = {
+      val abs = file.getAbsoluteFile
+      PlainFile(abs, abs.exists)
+    }
+    def apply(file: File, exists: Boolean): PlainFileInfo = {
+      val abs = file.getAbsoluteFile
+      PlainFile(abs, exists)
+    }
+  }
+}
diff --git a/util-cache/src/main/scala/sbt/util/Input.scala b/util-cache/src/main/scala/sbt/util/Input.scala
new file mode 100644
index 000000000..a79b84822
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/Input.scala
@@ -0,0 +1,58 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.io.{ Closeable, File, InputStream }
+
+import scala.util.control.NonFatal
+import sjsonnew.{ IsoString, JsonReader, SupportConverter }
+import sbt.io.{ IO, Using }
+import sbt.internal.util.EmptyCacheError
+
+trait Input extends Closeable {
+  def read[T: JsonReader](): T
+  def read[T: JsonReader](default: => T): T =
+    try read[T]()
+    catch { case NonFatal(_) => default }
+}
+
+class PlainInput[J: IsoString](input: InputStream, converter: SupportConverter[J]) extends Input {
+  val isoFormat: IsoString[J] = implicitly
+
+  private def readFully(): String = {
+    Using.streamReader((input, IO.utf8)) { reader =>
+      val builder = new StringBuilder()
+      val bufferSize = 1024
+      val buffer = new Array[Char](bufferSize)
+      var read = 0
+      while ({ read = reader.read(buffer, 0, bufferSize); read != -1 }) {
+        builder.appendAll(buffer, 0, read)
+      }
+      builder.toString()
+    }
+  }
+
+  def read[T: JsonReader](): T = {
+    val str = readFully()
+    if (str == "") throw new EmptyCacheError()
+    else converter.fromJson(isoFormat.from(str)).get
+  }
+
+  def close() = input.close()
+}
+
+class FileInput(file: File) extends Input {
+
+  override def read[T: JsonReader](): T = {
+    sjsonnew.support.scalajson.unsafe.Converter
+      .fromJson(sjsonnew.support.scalajson.unsafe.Parser.parseFromFile(file).get)
+      .get
+  }
+
+  def close() = ()
+}
diff --git a/util-cache/src/main/scala/sbt/util/Output.scala b/util-cache/src/main/scala/sbt/util/Output.scala
new file mode 100644
index 000000000..2c19f18ce
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/Output.scala
@@ -0,0 +1,47 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.io.{ Closeable, File, OutputStream }
+
+import sjsonnew.{ IsoString, JsonWriter, SupportConverter }
+import sbt.io.Using
+
+trait Output extends Closeable {
+  def write[T: JsonWriter](value: T): Unit
+}
+
+class PlainOutput[J: IsoString](output: OutputStream, converter: SupportConverter[J])
+    extends Output {
+  val isoFormat: IsoString[J] = implicitly
+
+  def write[T: JsonWriter](value: T) = {
+    val js = converter.toJson(value).get
+    val asString = isoFormat.to(js)
+    Using.bufferedOutputStream(output) { writer =>
+      val out = new java.io.PrintWriter(writer)
+      out.print(asString)
+      out.flush()
+    }
+  }
+
+  def close() = output.close()
+}
+
+class FileOutput(file: File) extends Output {
+  override def write[T: JsonWriter](value: T): Unit = {
+    val js = sjsonnew.support.scalajson.unsafe.Converter.toJson(value).get
+    Using.fileOutputStream(append = false)(file) { stream =>
+      val out = new java.io.PrintWriter(stream)
+      sjsonnew.support.scalajson.unsafe.CompactPrinter.print(js, out)
+      out.flush()
+    }
+  }
+
+  def close() = ()
+}
diff --git a/util-cache/src/main/scala/sbt/util/SeparatedCache.scala b/util-cache/src/main/scala/sbt/util/SeparatedCache.scala
new file mode 100644
index 000000000..9596436fb
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/SeparatedCache.scala
@@ -0,0 +1,65 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import scala.util.Try
+
+import sjsonnew.JsonFormat
+import sjsonnew.support.murmurhash.Hasher
+
+import CacheImplicits._
+
+/**
+ * A cache that stores a single value.
+ */
+trait SingletonCache[A] {
+
+  /** Reads the cache from the backing `from`. */
+  def read(from: Input): A
+
+  /** Writes `value` to the backing `to`. */
+  def write(to: Output, value: A): Unit
+
+}
+
+object SingletonCache {
+
+  implicit def basicSingletonCache[A: JsonFormat]: SingletonCache[A] =
+    new SingletonCache[A] {
+      override def read(from: Input): A = from.read[A]
+      override def write(to: Output, value: A) = to.write(value)
+    }
+
+  /** A lazy `SingletonCache` */
+  def lzy[A: JsonFormat](mkCache: => SingletonCache[A]): SingletonCache[A] =
+    new SingletonCache[A] {
+      lazy val cache = mkCache
+      override def read(from: Input): A = cache.read(from)
+      override def write(to: Output, value: A) = cache.write(to, value)
+    }
+}
+
+/**
+ * Simple key-value cache.
+ */
+class BasicCache[I: JsonFormat, O: JsonFormat] extends Cache[I, O] {
+  private val singletonCache: SingletonCache[(Long, O)] = implicitly
+  val jsonFormat: JsonFormat[I] = implicitly
+  override def apply(store: CacheStore)(key: I): CacheResult[O] = {
+    val keyHash: Long = Hasher.hashUnsafe[I](key).toLong
+    Try {
+      val (previousKeyHash, previousValue) = singletonCache.read(store)
+      if (keyHash == previousKeyHash) Hit(previousValue)
+      else Miss(update(store)(keyHash))
+    } getOrElse Miss(update(store)(keyHash))
+  }
+
+  private def update(store: CacheStore)(keyHash: Long) = (value: O) => {
+    singletonCache.write(store, (keyHash, value))
+  }
+}
diff --git a/util-cache/src/main/scala/sbt/util/StampedFormat.scala b/util-cache/src/main/scala/sbt/util/StampedFormat.scala
new file mode 100644
index 000000000..eccb0f5bb
--- /dev/null
+++ b/util-cache/src/main/scala/sbt/util/StampedFormat.scala
@@ -0,0 +1,54 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import scala.reflect.Manifest
+
+import sjsonnew.{ BasicJsonProtocol, Builder, deserializationError, JsonFormat, Unbuilder }
+
+object StampedFormat extends BasicJsonProtocol {
+
+  def apply[T](format: JsonFormat[T])(implicit mf: Manifest[JsonFormat[T]]): JsonFormat[T] = {
+    withStamp(stamp(format))(format)
+  }
+
+  def withStamp[T, S](stamp: S)(format: JsonFormat[T])(
+      implicit formatStamp: JsonFormat[S],
+      equivStamp: Equiv[S]
+  ): JsonFormat[T] =
+    new JsonFormat[T] {
+      override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): T =
+        jsOpt match {
+          case Some(js) =>
+            val stampedLength = unbuilder.beginArray(js)
+            if (stampedLength != 2)
+              sys.error(s"Expected JsArray of size 2, found JsArray of size $stampedLength.")
+            val readStamp = unbuilder.nextElement
+            val readValue = unbuilder.nextElement
+            val actualStamp = formatStamp.read(Some(readStamp), unbuilder)
+            if (equivStamp.equiv(actualStamp, stamp)) format.read(Some(readValue), unbuilder)
+            else sys.error(s"Incorrect stamp. Expected: $stamp, Found: $readStamp")
+
+          case None =>
+            deserializationError("Expected JsArray but found None.")
+        }
+
+      override def write[J](obj: T, builder: Builder[J]): Unit = {
+        builder.beginArray()
+        formatStamp.write(stamp, builder)
+        format.write(obj, builder)
+        builder.endArray()
+      }
+    }
+
+  private def stamp[T](format: JsonFormat[T])(implicit mf: Manifest[JsonFormat[T]]): Int =
+    typeHash(mf)
+
+  private def typeHash[T](implicit mf: Manifest[T]) = mf.toString.hashCode
+
+}
diff --git a/util-cache/src/test/scala/CacheSpec.scala b/util-cache/src/test/scala/CacheSpec.scala
new file mode 100644
index 000000000..587efed32
--- /dev/null
+++ b/util-cache/src/test/scala/CacheSpec.scala
@@ -0,0 +1,80 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import sbt.io.IO
+import sbt.io.syntax._
+
+import CacheImplicits._
+
+import org.scalatest.FlatSpec
+
+class CacheSpec extends FlatSpec {
+
+  "A cache" should "NOT throw an exception if read without being written previously" in {
+    testCache[String, Int] {
+      case (cache, store) =>
+        cache(store)("missing") match {
+          case Hit(_)  => fail
+          case Miss(_) => ()
+        }
+    }
+  }
+
+  it should "write a very simple value" in {
+    testCache[String, Int] {
+      case (cache, store) =>
+        cache(store)("missing") match {
+          case Hit(_)       => fail
+          case Miss(update) => update(5)
+        }
+    }
+  }
+
+  it should "be updatable" in {
+    testCache[String, Int] {
+      case (cache, store) =>
+        val value = 5
+        cache(store)("someKey") match {
+          case Hit(_)       => fail
+          case Miss(update) => update(value)
+        }
+
+        cache(store)("someKey") match {
+          case Hit(read) => assert(read === value); ()
+          case Miss(_)   => fail
+        }
+    }
+  }
+
+  it should "return the value that has been previously written" in {
+    testCache[String, Int] {
+      case (cache, store) =>
+        val key = "someKey"
+        val value = 5
+        cache(store)(key) match {
+          case Hit(_)       => fail
+          case Miss(update) => update(value)
+        }
+
+        cache(store)(key) match {
+          case Hit(read) => assert(read === value); ()
+          case Miss(_)   => fail
+        }
+    }
+  }
+
+  private def testCache[K, V](f: (Cache[K, V], CacheStore) => Unit)(
+      implicit cache: Cache[K, V]
+  ): Unit =
+    IO.withTemporaryDirectory { tmp =>
+      val store = new FileBasedStore(tmp / "cache-store")
+      f(cache, store)
+    }
+
+}
diff --git a/util-cache/src/test/scala/FileInfoSpec.scala b/util-cache/src/test/scala/FileInfoSpec.scala
new file mode 100644
index 000000000..cfaf3af37
--- /dev/null
+++ b/util-cache/src/test/scala/FileInfoSpec.scala
@@ -0,0 +1,32 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import sjsonnew.shaded.scalajson.ast.unsafe._
+import sjsonnew._, support.scalajson.unsafe._
+import org.scalatest.FlatSpec
+import sbt.io.IO
+
+class FileInfoSpec extends FlatSpec {
+  val file = new java.io.File(".").getAbsoluteFile
+  val fileInfo: ModifiedFileInfo = FileModified(file, IO.getModifiedTimeOrZero(file))
+  val filesInfo = FilesInfo(Set(fileInfo))
+
+  it should "round trip" in assertRoundTrip(filesInfo)
+
+  def assertRoundTrip[A: JsonWriter: JsonReader](x: A) = {
+    val jsonString: String = toJsonString(x)
+    val jValue: JValue = Parser.parseUnsafe(jsonString)
+    val y: A = Converter.fromJson[A](jValue).get
+    assert(x === y)
+  }
+
+  def assertJsonString[A: JsonWriter](x: A, s: String) = assert(toJsonString(x) === s)
+
+  def toJsonString[A: JsonWriter](x: A): String = CompactPrinter(Converter.toJson(x).get)
+}
diff --git a/util-cache/src/test/scala/SingletonCacheSpec.scala b/util-cache/src/test/scala/SingletonCacheSpec.scala
new file mode 100644
index 000000000..568a5e2aa
--- /dev/null
+++ b/util-cache/src/test/scala/SingletonCacheSpec.scala
@@ -0,0 +1,96 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import sbt.io.IO
+import sbt.io.syntax._
+
+import CacheImplicits._
+
+import sjsonnew.{ Builder, deserializationError, JsonFormat, Unbuilder }
+import org.scalatest.FlatSpec
+
+class SingletonCacheSpec extends FlatSpec {
+
+  case class ComplexType(val x: Int, y: String, z: List[Int])
+  object ComplexType {
+    implicit val format: JsonFormat[ComplexType] =
+      new JsonFormat[ComplexType] {
+        override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): ComplexType = {
+          jsOpt match {
+            case Some(js) =>
+              unbuilder.beginObject(js)
+              val x = unbuilder.readField[Int]("x")
+              val y = unbuilder.readField[String]("y")
+              val z = unbuilder.readField[List[Int]]("z")
+              unbuilder.endObject()
+              ComplexType(x, y, z)
+
+            case None =>
+              deserializationError("Exception JObject but found None")
+          }
+        }
+
+        override def write[J](obj: ComplexType, builder: Builder[J]): Unit = {
+          builder.beginObject()
+          builder.addField("x", obj.x)
+          builder.addField("y", obj.y)
+          builder.addField("z", obj.z)
+          builder.endObject()
+        }
+      }
+  }
+
+  "A singleton cache" should "throw an exception if read without being written previously" in {
+    testCache[Int] {
+      case (cache, store) =>
+        intercept[Exception] {
+          cache.read(store)
+        }
+        ()
+    }
+  }
+
+  it should "write a very simple value" in {
+    testCache[Int] {
+      case (cache, store) =>
+        cache.write(store, 5)
+    }
+  }
+
+  it should "return the simple value that has been previously written" in {
+    testCache[Int] {
+      case (cache, store) =>
+        val value = 5
+        cache.write(store, value)
+        val read = cache.read(store)
+
+        assert(read === value); ()
+    }
+  }
+
+  it should "write a complex value" in {
+    testCache[ComplexType] {
+      case (cache, store) =>
+        val value = ComplexType(1, "hello, world!", (1 to 10 by 3).toList)
+        cache.write(store, value)
+        val read = cache.read(store)
+
+        assert(read === value); ()
+    }
+  }
+
+  private def testCache[T](f: (SingletonCache[T], CacheStore) => Unit)(
+      implicit cache: SingletonCache[T]
+  ): Unit =
+    IO.withTemporaryDirectory { tmp =>
+      val store = new FileBasedStore(tmp / "cache-store")
+      f(cache, store)
+    }
+
+}
diff --git a/util-tracking/NOTICE b/util-tracking/NOTICE
new file mode 100644
index 000000000..c7c0531d9
--- /dev/null
+++ b/util-tracking/NOTICE
@@ -0,0 +1,3 @@
+Simple Build Tool: Tracking Component
+Copyright 2009, 2010  Mark Harrah
+Licensed under BSD-style license (see LICENSE)
\ No newline at end of file
diff --git a/util-tracking/src/main/scala/sbt/util/ChangeReport.scala b/util-tracking/src/main/scala/sbt/util/ChangeReport.scala
new file mode 100644
index 000000000..abbb3ac06
--- /dev/null
+++ b/util-tracking/src/main/scala/sbt/util/ChangeReport.scala
@@ -0,0 +1,86 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+object ChangeReport {
+  def modified[T](files: Set[T]): ChangeReport[T] =
+    new EmptyChangeReport[T] {
+      override def checked = files
+      override def modified = files
+      override def markAllModified = this
+    }
+
+  def unmodified[T](files: Set[T]): ChangeReport[T] =
+    new EmptyChangeReport[T] {
+      override def checked = files
+      override def unmodified = files
+    }
+}
+
+/** The result of comparing some current set of objects against a previous set of objects.*/
+trait ChangeReport[T] {
+
+  /** The set of all of the objects in the current set.*/
+  def checked: Set[T]
+
+  /** All of the objects that are in the same state in the current and reference sets.*/
+  def unmodified: Set[T]
+
+  /**
+   * All checked objects that are not in the same state as the reference.  This includes objects that are in both
+   * sets but have changed and files that are only in one set.
+   */
+  def modified: Set[T] // all changes, including added
+
+  /** All objects that are only in the current set.*/
+  def added: Set[T]
+
+  /** All objects only in the previous set*/
+  def removed: Set[T]
+  def +++(other: ChangeReport[T]): ChangeReport[T] = new CompoundChangeReport(this, other)
+
+  /**
+   * Generate a new report with this report's unmodified set included in the new report's modified set.  The new report's
+   * unmodified set is empty.  The new report's added, removed, and checked sets are the same as in this report.
+   */
+  def markAllModified: ChangeReport[T] =
+    new ChangeReport[T] {
+      def checked = ChangeReport.this.checked
+      def unmodified = Set.empty[T]
+      def modified = ChangeReport.this.checked
+      def added = ChangeReport.this.added
+      def removed = ChangeReport.this.removed
+      override def markAllModified = this
+    }
+
+  override def toString = {
+    val labels = List("Checked", "Modified", "Unmodified", "Added", "Removed")
+    val sets = List(checked, modified, unmodified, added, removed)
+    val keyValues = labels.zip(sets).map { case (label, set) => label + ": " + set.mkString(", ") }
+    keyValues.mkString("Change report:\n\t", "\n\t", "")
+  }
+
+}
+
+class EmptyChangeReport[T] extends ChangeReport[T] {
+  def checked = Set.empty[T]
+  def unmodified = Set.empty[T]
+  def modified = Set.empty[T]
+  def added = Set.empty[T]
+  def removed = Set.empty[T]
+  override def toString = "No changes"
+}
+
+private class CompoundChangeReport[T](a: ChangeReport[T], b: ChangeReport[T])
+    extends ChangeReport[T] {
+  lazy val checked = a.checked ++ b.checked
+  lazy val unmodified = a.unmodified ++ b.unmodified
+  lazy val modified = a.modified ++ b.modified
+  lazy val added = a.added ++ b.added
+  lazy val removed = a.removed ++ b.removed
+}
diff --git a/util-tracking/src/main/scala/sbt/util/FileFunction.scala b/util-tracking/src/main/scala/sbt/util/FileFunction.scala
new file mode 100644
index 000000000..8ffea2008
--- /dev/null
+++ b/util-tracking/src/main/scala/sbt/util/FileFunction.scala
@@ -0,0 +1,158 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import java.io.File
+
+object FileFunction {
+  type UpdateFunction = (ChangeReport[File], ChangeReport[File]) => Set[File]
+  private val defaultInStyle = FileInfo.lastModified
+  private val defaultOutStyle = FileInfo.exists
+
+  /**
+   * Generic change-detection helper used to help build / artifact generation /
+   * etc. steps detect whether or not they need to run. Returns a function whose
+   * input is a Set of input files, and subsequently executes the action function
+   * (which does the actual work: compiles, generates resources, etc.), returning
+   * a Set of output files that it generated.
+   *
+   * The input file and resulting output file state is cached in stores issued by
+   * `storeFactory`. On each invocation, the state of the input and output
+   * files from the previous run is compared against the cache, as is the set of
+   * input files. If a change in file state / input files set is detected, the
+   * action function is re-executed.
+   *
+   * @param cacheBaseDirectory The folder in which to store
+   * @param action The work function, which receives a list of input files and returns a list of output files
+   */
+  def cached(cacheBaseDirectory: File)(action: Set[File] => Set[File]): Set[File] => Set[File] =
+    cached(cacheBaseDirectory, inStyle = defaultInStyle, outStyle = defaultOutStyle)(action)
+
+  /**
+   * Generic change-detection helper used to help build / artifact generation /
+   * etc. steps detect whether or not they need to run. Returns a function whose
+   * input is a Set of input files, and subsequently executes the action function
+   * (which does the actual work: compiles, generates resources, etc.), returning
+   * a Set of output files that it generated.
+   *
+   * The input file and resulting output file state is cached in stores issued by
+   * `storeFactory`. On each invocation, the state of the input and output
+   * files from the previous run is compared against the cache, as is the set of
+   * input files. If a change in file state / input files set is detected, the
+   * action function is re-executed.
+   *
+   * @param cacheBaseDirectory The folder in which to store
+   * @param inStyle The strategy by which to detect state change in the input files from the previous run
+   * @param action The work function, which receives a list of input files and returns a list of output files
+   */
+  def cached(cacheBaseDirectory: File, inStyle: FileInfo.Style)(
+      action: Set[File] => Set[File]
+  ): Set[File] => Set[File] =
+    cached(cacheBaseDirectory, inStyle = inStyle, outStyle = defaultOutStyle)(action)
+
+  /**
+   * Generic change-detection helper used to help build / artifact generation /
+   * etc. steps detect whether or not they need to run. Returns a function whose
+   * input is a Set of input files, and subsequently executes the action function
+   * (which does the actual work: compiles, generates resources, etc.), returning
+   * a Set of output files that it generated.
+   *
+   * The input file and resulting output file state is cached in stores issued by
+   * `storeFactory`. On each invocation, the state of the input and output
+   * files from the previous run is compared against the cache, as is the set of
+   * input files. If a change in file state / input files set is detected, the
+   * action function is re-executed.
+   *
+   * @param cacheBaseDirectory The folder in which to store
+   * @param inStyle The strategy by which to detect state change in the input files from the previous run
+   * @param outStyle The strategy by which to detect state change in the output files from the previous run
+   * @param action The work function, which receives a list of input files and returns a list of output files
+   */
+  def cached(cacheBaseDirectory: File, inStyle: FileInfo.Style, outStyle: FileInfo.Style)(
+      action: Set[File] => Set[File]
+  ): Set[File] => Set[File] =
+    cached(CacheStoreFactory(cacheBaseDirectory), inStyle, outStyle)(
+      (in, out) => action(in.checked)
+    )
+
+  /**
+   * Generic change-detection helper used to help build / artifact generation /
+   * etc. steps detect whether or not they need to run. Returns a function whose
+   * input is a Set of input files, and subsequently executes the action function
+   * (which does the actual work: compiles, generates resources, etc.), returning
+   * a Set of output files that it generated.
+   *
+   * The input file and resulting output file state is cached in stores issued by
+   * `storeFactory`. On each invocation, the state of the input and output
+   * files from the previous run is compared against the cache, as is the set of
+   * input files. If a change in file state / input files set is detected, the
+   * action function is re-executed.
+   *
+   * @param storeFactory The factory to use to get stores for the input and output files.
+   * @param action The work function, which receives a list of input files and returns a list of output files
+   */
+  def cached(storeFactory: CacheStoreFactory)(action: UpdateFunction): Set[File] => Set[File] =
+    cached(storeFactory, inStyle = defaultInStyle, outStyle = defaultOutStyle)(action)
+
+  /**
+   * Generic change-detection helper used to help build / artifact generation /
+   * etc. steps detect whether or not they need to run. Returns a function whose
+   * input is a Set of input files, and subsequently executes the action function
+   * (which does the actual work: compiles, generates resources, etc.), returning
+   * a Set of output files that it generated.
+   *
+   * The input file and resulting output file state is cached in stores issued by
+   * `storeFactory`. On each invocation, the state of the input and output
+   * files from the previous run is compared against the cache, as is the set of
+   * input files. If a change in file state / input files set is detected, the
+   * action function is re-executed.
+   *
+   * @param storeFactory The factory to use to get stores for the input and output files.
+   * @param inStyle The strategy by which to detect state change in the input files from the previous run
+   * @param action The work function, which receives a list of input files and returns a list of output files
+   */
+  def cached(storeFactory: CacheStoreFactory, inStyle: FileInfo.Style)(
+      action: UpdateFunction
+  ): Set[File] => Set[File] =
+    cached(storeFactory, inStyle = inStyle, outStyle = defaultOutStyle)(action)
+
+  /**
+   * Generic change-detection helper used to help build / artifact generation /
+   * etc. steps detect whether or not they need to run. Returns a function whose
+   * input is a Set of input files, and subsequently executes the action function
+   * (which does the actual work: compiles, generates resources, etc.), returning
+   * a Set of output files that it generated.
+   *
+   * The input file and resulting output file state is cached in stores issued by
+   * `storeFactory`. On each invocation, the state of the input and output
+   * files from the previous run is compared against the cache, as is the set of
+   * input files. If a change in file state / input files set is detected, the
+   * action function is re-executed.
+   *
+   * @param storeFactory The factory to use to get stores for the input and output files.
+   * @param inStyle The strategy by which to detect state change in the input files from the previous run
+   * @param outStyle The strategy by which to detect state change in the output files from the previous run
+   * @param action The work function, which receives a list of input files and returns a list of output files
+   */
+  def cached(storeFactory: CacheStoreFactory, inStyle: FileInfo.Style, outStyle: FileInfo.Style)(
+      action: UpdateFunction
+  ): Set[File] => Set[File] = {
+    lazy val inCache = Difference.inputs(storeFactory.make("in-cache"), inStyle)
+    lazy val outCache = Difference.outputs(storeFactory.make("out-cache"), outStyle)
+    inputs => {
+      inCache(inputs) { inReport =>
+        outCache { outReport =>
+          if (inReport.modified.isEmpty && outReport.modified.isEmpty)
+            outReport.checked
+          else
+            action(inReport, outReport)
+        }
+      }
+    }
+  }
+}
diff --git a/util-tracking/src/main/scala/sbt/util/Tracked.scala b/util-tracking/src/main/scala/sbt/util/Tracked.scala
new file mode 100644
index 000000000..883872f1d
--- /dev/null
+++ b/util-tracking/src/main/scala/sbt/util/Tracked.scala
@@ -0,0 +1,421 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import scala.util.{ Failure, Try, Success => USuccess }
+
+import java.io.File
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.internal.util.EmptyCacheError
+
+import sjsonnew.{ JsonFormat, JsonWriter }
+import sjsonnew.support.murmurhash.Hasher
+
+object Tracked {
+
+  /**
+   * Creates a tracker that provides the last time it was evaluated.
+   * If the function throws an exception.
+   */
+  def tstamp(store: CacheStore): Timestamp = tstamp(store, true)
+
+  /**
+   * Creates a tracker that provides the last time it was evaluated.
+   * If the function throws an exception.
+   */
+  def tstamp(cacheFile: File): Timestamp = tstamp(CacheStore(cacheFile))
+
+  /**
+   * Creates a tracker that provides the last time it was evaluated.
+   * If 'useStartTime' is true, the recorded time is the start of the evaluated function.
+   * If 'useStartTime' is false, the recorded time is when the evaluated function completes.
+   * In both cases, the timestamp is not updated if the function throws an exception.
+   */
+  def tstamp(store: CacheStore, useStartTime: Boolean): Timestamp = {
+    import CacheImplicits.LongJsonFormat
+    new Timestamp(store, useStartTime)
+  }
+
+  /**
+   * Creates a tracker that provides the last time it was evaluated.
+   * If 'useStartTime' is true, the recorded time is the start of the evaluated function.
+   * If 'useStartTime' is false, the recorded time is when the evaluated function completes.
+   * In both cases, the timestamp is not updated if the function throws an exception.
+   */
+  def tstamp(cacheFile: File, useStartTime: Boolean): Timestamp =
+    tstamp(CacheStore(cacheFile), useStartTime)
+
+  /** Creates a tracker that provides the difference between a set of input files for successive invocations.*/
+  def diffInputs(store: CacheStore, style: FileInfo.Style): Difference =
+    Difference.inputs(store, style)
+
+  /** Creates a tracker that provides the difference between a set of input files for successive invocations.*/
+  def diffInputs(cacheFile: File, style: FileInfo.Style): Difference =
+    diffInputs(CacheStore(cacheFile), style)
+
+  /** Creates a tracker that provides the difference between a set of output files for successive invocations.*/
+  def diffOutputs(store: CacheStore, style: FileInfo.Style): Difference =
+    Difference.outputs(store, style)
+
+  /** Creates a tracker that provides the difference between a set of output files for successive invocations.*/
+  def diffOutputs(cacheFile: File, style: FileInfo.Style): Difference =
+    diffOutputs(CacheStore(cacheFile), style)
+
+  /** Creates a tracker that provides the output of the most recent invocation of the function */
+  def lastOutput[I, O: JsonFormat](store: CacheStore)(f: (I, Option[O]) => O): I => O = { in =>
+    val previous = Try { store.read[O] }.toOption
+    val next = f(in, previous)
+    store.write(next)
+    next
+  }
+
+  /** Creates a tracker that provides the output of the most recent invocation of the function */
+  def lastOutput[I, O: JsonFormat](cacheFile: File)(f: (I, Option[O]) => O): I => O =
+    lastOutput(CacheStore(cacheFile))(f)
+
+  /**
+   * Creates a tracker that indicates whether the output returned from `p` has changed or not.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cacheStoreFactory.make("inputs")) { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cacheStoreFactory.make("output")) { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   */
+  def outputChanged[A1: JsonFormat, A2](store: CacheStore)(
+      f: (Boolean, A1) => A2
+  ): (() => A1) => A2 = {
+    outputChangedW(store)(f)
+  }
+
+  /**
+   * Creates a tracker that indicates whether the output returned from `p` has changed or not.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cacheStoreFactory.make("inputs")) { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cacheStoreFactory.make("output")) { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   *
+   * This is a variant of `outputChanged` that takes `A1: JsonWriter` as opposed to `A1: JsonFormat`.
+   */
+  def outputChangedW[A1: JsonWriter, A2](store: CacheStore)(
+      f: (Boolean, A1) => A2
+  ): (() => A1) => A2 = p => {
+    val cache: SingletonCache[Long] = {
+      import CacheImplicits.LongJsonFormat
+      implicitly
+    }
+    val initial = p()
+    val help = new CacheHelp(cache)
+    val changed = help.changed(store, initial)
+    val result = f(changed, initial)
+    if (changed) {
+      help.save(store, p())
+    }
+    result
+  }
+
+  /**
+   * Creates a tracker that indicates whether the output returned from `p` has changed or not.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cache / "inputs") { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cache / "output") { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   */
+  def outputChanged[A1: JsonFormat, A2](cacheFile: File)(f: (Boolean, A1) => A2): (() => A1) => A2 =
+    outputChanged[A1, A2](CacheStore(cacheFile))(f)
+
+  /**
+   * Creates a tracker that indicates whether the output returned from `p` has changed or not.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cache / "inputs") { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cache / "output") { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   *
+   * This is a variant of `outputChanged` that takes `A1: JsonWriter` as opposed to `A1: JsonFormat`.
+   */
+  def outputChangedW[A1: JsonWriter, A2](
+      cacheFile: File
+  )(f: (Boolean, A1) => A2): (() => A1) => A2 =
+    outputChangedW[A1, A2](CacheStore(cacheFile))(f)
+
+  /**
+   * Creates a tracker that indicates whether the arguments given to f have changed since the most
+   * recent invocation.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cacheStoreFactory.make("inputs")) { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cacheStoreFactory.make("output")) { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   */
+  def inputChanged[I: JsonFormat: SingletonCache, O](store: CacheStore)(
+      f: (Boolean, I) => O
+  ): I => O =
+    inputChangedW(store)(f)
+
+  /**
+   * Creates a tracker that indicates whether the arguments given to f have changed since the most
+   * recent invocation.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cacheStoreFactory.make("inputs")) { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cacheStoreFactory.make("output")) { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   *
+   * This is a variant of `inputChanged` that takes `I: JsonWriter` as opposed to `I: JsonFormat`.
+   */
+  def inputChangedW[I: JsonWriter, O](store: CacheStore)(
+      f: (Boolean, I) => O
+  ): I => O = { in =>
+    val cache: SingletonCache[Long] = {
+      import CacheImplicits.LongJsonFormat
+      implicitly
+    }
+    val help = new CacheHelp(cache)
+    val changed = help.changed(store, in)
+    val result = f(changed, in)
+    if (changed)
+      help.save(store, in)
+    result
+  }
+
+  /**
+   * Creates a tracker that indicates whether the arguments given to f have changed since the most
+   * recent invocation.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cache / "inputs") { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cache / "output") { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   */
+  def inputChanged[I: JsonFormat: SingletonCache, O](cacheFile: File)(
+      f: (Boolean, I) => O
+  ): I => O =
+    inputChanged(CacheStore(cacheFile))(f)
+
+  /**
+   * Creates a tracker that indicates whether the arguments given to f have changed since the most
+   * recent invocation.
+   *
+   * {{{
+   * val cachedTask = inputChanged(cache / "inputs") { (inChanged, in: Inputs) =>
+   *   Tracked.outputChanged(cache / "output") { (outChanged, outputs: FilesInfo[PlainFileInfo]) =>
+   *     if (inChanged || outChanged) {
+   *       doSomething(label, sources, classpath, outputDirectory, options, log)
+   *     }
+   *   }
+   * }
+   * cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
+   * }}}
+   *
+   * This is a variant of `inputChanged` that takes `I: JsonWriter` as opposed to `I: JsonFormat`.
+   */
+  def inputChangedW[I: JsonWriter, O](cacheFile: File)(
+      f: (Boolean, I) => O
+  ): I => O =
+    inputChangedW(CacheStore(cacheFile))(f)
+
+  private final class CacheHelp[I: JsonWriter](val sc: SingletonCache[Long]) {
+    import CacheImplicits.implicitHashWriter
+    import CacheImplicits.LongJsonFormat
+    def save(store: CacheStore, value: I): Unit = {
+      Hasher.hash(value) match {
+        case USuccess(keyHash) => store.write[Long](keyHash.toLong)
+        case Failure(e) =>
+          if (isStrictMode) throw e
+          else ()
+      }
+    }
+
+    def changed(store: CacheStore, value: I): Boolean =
+      Try { store.read[Long] } match {
+        case USuccess(prev: Long) =>
+          Hasher.hash(value) match {
+            case USuccess(keyHash: Int) => keyHash.toLong != prev
+            case Failure(e) =>
+              if (isStrictMode) throw e
+              else true
+          }
+        case Failure(_: EmptyCacheError) => true
+        case Failure(e) =>
+          if (isStrictMode) throw e
+          else true
+      }
+  }
+
+  private[sbt] def isStrictMode: Boolean =
+    java.lang.Boolean.getBoolean("sbt.strict")
+}
+
+trait Tracked {
+
+  /** Cleans outputs and clears the cache.*/
+  def clean(): Unit
+
+}
+
+class Timestamp(val store: CacheStore, useStartTime: Boolean)(implicit format: JsonFormat[Long])
+    extends Tracked {
+  def clean() = store.delete()
+
+  /**
+   * Reads the previous timestamp, evaluates the provided function,
+   * and then updates the timestamp if the function completes normally.
+   */
+  def apply[T](f: Long => T): T = {
+    val start = now()
+    val result = f(readTimestamp)
+    store.write(if (useStartTime) start else now())
+    result
+  }
+
+  private def now() = System.currentTimeMillis
+
+  def readTimestamp: Long =
+    Try { store.read[Long] } getOrElse 0
+}
+
+@deprecated("Use Tracked.inputChanged and Tracked.outputChanged instead", "1.0.1")
+class Changed[O: Equiv: JsonFormat](val store: CacheStore) extends Tracked {
+  def clean() = store.delete()
+
+  def apply[O2](ifChanged: O => O2, ifUnchanged: O => O2): O => O2 = value => {
+    if (uptodate(value))
+      ifUnchanged(value)
+    else {
+      update(value)
+      ifChanged(value)
+    }
+  }
+
+  def update(value: O): Unit =
+    store.write(value) //Using.fileOutputStream(false)(cacheFile)(stream => format.writes(stream, value))
+
+  def uptodate(value: O): Boolean = {
+    val equiv: Equiv[O] = implicitly
+    equiv.equiv(value, store.read[O])
+  }
+}
+
+object Difference {
+  def constructor(
+      defineClean: Boolean,
+      filesAreOutputs: Boolean
+  ): (CacheStore, FileInfo.Style) => Difference =
+    (store, style) => new Difference(store, style, defineClean, filesAreOutputs)
+
+  /**
+   * Provides a constructor for a Difference that removes the files from the previous run on a call to 'clean' and saves the
+   * hash/last modified time of the files as they are after running the function.  This means that this information must be evaluated twice:
+   * before and after running the function.
+   */
+  val outputs = constructor(true, true)
+
+  /**
+   * Provides a constructor for a Difference that does nothing on a call to 'clean' and saves the
+   * hash/last modified time of the files as they were prior to running the function.
+   */
+  val inputs = constructor(false, false)
+
+}
+
+class Difference(
+    val store: CacheStore,
+    val style: FileInfo.Style,
+    val defineClean: Boolean,
+    val filesAreOutputs: Boolean
+) extends Tracked {
+  def clean() = {
+    if (defineClean) IO.delete(raw(cachedFilesInfo)) else ()
+    clearCache()
+  }
+
+  private def clearCache() = store.delete()
+
+  private def cachedFilesInfo = store.read(default = FilesInfo.empty[style.F])(style.formats).files
+  private def raw(fs: Set[style.F]): Set[File] = fs.map(_.file)
+
+  def apply[T](files: Set[File])(f: ChangeReport[File] => T): T = {
+    val lastFilesInfo = cachedFilesInfo
+    apply(files, lastFilesInfo)(f)(_ => files)
+  }
+
+  def apply[T](f: ChangeReport[File] => T)(implicit toFiles: T => Set[File]): T = {
+    val lastFilesInfo = cachedFilesInfo
+    apply(raw(lastFilesInfo), lastFilesInfo)(f)(toFiles)
+  }
+
+  private def abs(files: Set[File]) = files.map(_.getAbsoluteFile)
+
+  private[this] def apply[T](files: Set[File], lastFilesInfo: Set[style.F])(
+      f: ChangeReport[File] => T
+  )(extractFiles: T => Set[File]): T = {
+    val lastFiles = raw(lastFilesInfo)
+    val currentFiles = abs(files)
+    val currentFilesInfo = style(currentFiles)
+
+    val report = new ChangeReport[File] {
+      lazy val checked = currentFiles
+      lazy val removed = lastFiles -- checked // all files that were included previously but not this time.  This is independent of whether the files exist.
+      lazy val added = checked -- lastFiles // all files included now but not previously.  This is independent of whether the files exist.
+      lazy val modified = raw(lastFilesInfo -- currentFilesInfo.files) ++ added
+      lazy val unmodified = checked -- modified
+    }
+
+    val result = f(report)
+    val info = if (filesAreOutputs) style(abs(extractFiles(result))) else currentFilesInfo
+
+    store.write(info)(style.formats)
+
+    result
+  }
+}
diff --git a/util-tracking/src/test/scala/sbt/util/TrackedSpec.scala b/util-tracking/src/test/scala/sbt/util/TrackedSpec.scala
new file mode 100644
index 000000000..f456931f0
--- /dev/null
+++ b/util-tracking/src/test/scala/sbt/util/TrackedSpec.scala
@@ -0,0 +1,230 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.util
+
+import org.scalatest.FlatSpec
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.util.CacheImplicits._
+import sjsonnew.{ Builder, JsonWriter }
+
+import scala.concurrent.Promise
+
+class TrackedSpec extends FlatSpec {
+  "lastOutput" should "store the last output" in {
+    withStore { store =>
+      val value = 5
+      val otherValue = 10
+
+      val res0 =
+        Tracked.lastOutput[Int, Int](store) {
+          case (in, None) =>
+            assert(in === value)
+            in
+          case (_, Some(_)) =>
+            fail()
+        }(implicitly)(value)
+      assert(res0 === value)
+
+      val res1 =
+        Tracked.lastOutput[Int, Int](store) {
+          case (_, None) =>
+            fail()
+          case (in, Some(read)) =>
+            assert(in === otherValue)
+            assert(read === value)
+            read
+        }(implicitly)(otherValue)
+      assert(res1 === value)
+
+      val res2 =
+        Tracked.lastOutput[Int, Int](store) {
+          case (_, None) =>
+            fail()
+          case (in, Some(read)) =>
+            assert(in === otherValue)
+            assert(read === value)
+            read
+        }(implicitly)(otherValue)
+      assert(res2 === value)
+
+      ()
+    }
+  }
+
+  "inputChangedW" should "not require the input to have a JsonReader instance" in {
+    case class Input(v: Int)
+
+    implicit val writer = new JsonWriter[Input] {
+      override def write[J](obj: Input, builder: Builder[J]): Unit = builder.writeInt(obj.v)
+    }
+
+    withStore { store =>
+      val input0 = Input(1)
+
+      val cachedFun = Tracked.inputChangedW[Input, Int](store) {
+        case (_, in) => in.v
+      }
+
+      val res0 = cachedFun(input0)
+      assert(res0 === input0.v)
+      ()
+    }
+
+  }
+
+  "inputChanged" should "detect that the input has not changed" in {
+    withStore { store =>
+      val input0 = "foo"
+
+      val res0 =
+        Tracked.inputChanged[String, String](store) {
+          case (true, in) =>
+            assert(in === input0)
+            in
+          case (false, _) =>
+            fail()
+        }(implicitly, implicitly)(input0)
+      assert(res0 === input0)
+
+      val res1 =
+        Tracked.inputChanged[String, String](store) {
+          case (true, _) =>
+            fail()
+          case (false, in) =>
+            assert(in === input0)
+            in
+        }(implicitly, implicitly)(input0)
+      assert(res1 === input0)
+
+      ()
+    }
+  }
+
+  it should "detect that the input has changed" in {
+    withStore { store =>
+      val input0 = 0
+      val input1 = 1
+
+      val res0 =
+        Tracked.inputChanged[Int, Int](store) {
+          case (true, in) =>
+            assert(in === input0)
+            in
+          case (false, _) =>
+            fail()
+        }(implicitly, implicitly)(input0)
+      assert(res0 === input0)
+
+      val res1 =
+        Tracked.inputChanged[Int, Int](store) {
+          case (true, in) =>
+            assert(in === input1)
+            in
+          case (false, _) =>
+            fail()
+        }(implicitly, implicitly)(input1)
+      assert(res1 === input1)
+
+      ()
+    }
+  }
+
+  "outputChangedW" should "not require the input to have a JsonReader instance" in {
+    case class Input(v: Int)
+
+    implicit val writer = new JsonWriter[Input] {
+      override def write[J](obj: Input, builder: Builder[J]): Unit = builder.writeInt(obj.v)
+    }
+
+    withStore { store =>
+      val input0 = Input(1)
+
+      val cachedFun = Tracked.outputChangedW[Input, Int](store) {
+        case (_, in) => in.v
+      }
+
+      val res0 = cachedFun(() => input0)
+      assert(res0 === input0.v)
+      ()
+    }
+
+  }
+
+  "outputChanged" should "detect that the output has not changed" in {
+    withStore { store =>
+      val beforeCompletion: String = "before-completion"
+      val afterCompletion: String = "after-completion"
+      val sideEffectCompleted = Promise[Unit]
+      val p0: () => String = () => {
+        if (sideEffectCompleted.isCompleted) {
+          afterCompletion
+        } else {
+          sideEffectCompleted.success(())
+          beforeCompletion
+        }
+      }
+      val firstExpectedResult = "first-result"
+      val secondExpectedResult = "second-result"
+
+      val res0 =
+        Tracked.outputChanged[String, String](store) {
+          case (true, in) =>
+            assert(in === beforeCompletion)
+            firstExpectedResult
+          case (false, _) =>
+            fail()
+        }(implicitly)(p0)
+      assert(res0 === firstExpectedResult)
+
+      val res1 =
+        Tracked.outputChanged[String, String](store) {
+          case (true, _) =>
+            fail()
+          case (false, in) =>
+            assert(in === afterCompletion)
+            secondExpectedResult
+        }(implicitly)(p0)
+      assert(res1 === secondExpectedResult)
+
+      ()
+    }
+  }
+
+  "tstamp tracker" should "have a timestamp of 0 on first invocation" in {
+    withStore { store =>
+      Tracked.tstamp(store) { last =>
+        assert(last === 0)
+      }
+
+      ()
+    }
+  }
+
+  it should "provide the last time a function has been evaluated" in {
+    withStore { store =>
+      Tracked.tstamp(store) { last =>
+        assert(last === 0)
+      }
+
+      Tracked.tstamp(store) { last =>
+        val difference = System.currentTimeMillis - last
+        assert(difference < 1000)
+      }
+
+      ()
+    }
+  }
+
+  private def withStore(f: CacheStore => Unit): Unit =
+    IO.withTemporaryDirectory { tmp =>
+      val store = CacheStore(tmp / "cache-store")
+      f(store)
+    }
+
+}
diff --git a/vscode-sbt-scala/.vscode/launch.json b/vscode-sbt-scala/.vscode/launch.json
new file mode 100644
index 000000000..5201e0897
--- /dev/null
+++ b/vscode-sbt-scala/.vscode/launch.json
@@ -0,0 +1,33 @@
+{
+	"version": "0.2.0",
+	// List of configurations. Add new configurations or edit existing ones.
+	"configurations": [
+		{
+			"name": "Launch Client",
+			"type": "extensionHost",
+			"request": "launch",
+			"runtimeExecutable": "${execPath}",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceRoot}/client"
+			],
+			"stopOnEntry": false,
+			"sourceMaps": true,
+			"outFiles": [
+				"${workspaceRoot}/client/out/**/*.js"
+			]
+			// "preLaunchTask": "Client Watch"
+		},
+		{
+			"name": "Attach to Server",
+			"type": "node",
+			"request": "attach",
+			"port": 6009,
+			"sourceMaps": true,
+			"outFiles": [
+				"${workspaceRoot}/client/server/**/*.js"
+			],
+			"protocol": "legacy"
+			// "preLaunchTask": "Server Watch"
+		}
+	]
+}
\ No newline at end of file
diff --git a/vscode-sbt-scala/.vscode/settings.json b/vscode-sbt-scala/.vscode/settings.json
new file mode 100644
index 000000000..ed40daef9
--- /dev/null
+++ b/vscode-sbt-scala/.vscode/settings.json
@@ -0,0 +1,10 @@
+{
+	"files.exclude": {
+		"out": false // set this to true to hide the "out" folder with the compiled JS files
+	},
+	"search.exclude": {
+		"out": true // set this to false to include "out" folder in search results
+	},
+	"typescript.tsdk": "./node_modules/typescript/lib",
+	"typescript.tsc.autoDetect": "off"
+}
\ No newline at end of file
diff --git a/vscode-sbt-scala/.vscode/tasks.json b/vscode-sbt-scala/.vscode/tasks.json
new file mode 100644
index 000000000..51026cd2d
--- /dev/null
+++ b/vscode-sbt-scala/.vscode/tasks.json
@@ -0,0 +1,79 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"taskName": "compile",
+			"dependsOn": [
+				"compile:client",
+				"compile:server"
+			],
+			"problemMatcher": []
+		},
+		{
+			"label": "compile:client",
+			"type": "npm",
+			"script": "compile:client",
+			"group": "build",
+			"presentation": {
+				"panel": "dedicated",
+				"reveal": "never"
+			},
+			"problemMatcher": [
+				"$tsc"
+			]
+		},
+		{
+			"label": "compile:server",
+			"type": "npm",
+			"script": "compile:server",
+			"group": "build",
+			"presentation": {
+				"panel": "dedicated",
+				"reveal": "never"
+			},
+			"problemMatcher": [
+				"$tsc"
+			]
+		},
+		{
+			"taskName": "watch",
+			"dependsOn": [
+				"watch:client",
+				"watch:server"
+			],
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"problemMatcher": []
+		},
+		{
+			"label": "watch:client",
+			"type": "npm",
+			"script": "watch:client",
+			"isBackground": true,
+			"group": "build",
+			"presentation": {
+				"panel": "dedicated",
+				"reveal": "never"
+			},
+			"problemMatcher": [
+				"$tsc-watch"
+			]
+		},
+		{
+			"label": "watch:server",
+			"type": "npm",
+			"script": "watch:server",
+			"isBackground": true,
+			"group": "build",
+			"presentation": {
+				"panel": "dedicated",
+				"reveal": "never"
+			},
+			"problemMatcher": [
+				"$tsc-watch"
+			]
+		}
+	]
+}
\ No newline at end of file
diff --git a/vscode-sbt-scala/client/.vscodeignore b/vscode-sbt-scala/client/.vscodeignore
new file mode 100644
index 000000000..93e28ff2f
--- /dev/null
+++ b/vscode-sbt-scala/client/.vscodeignore
@@ -0,0 +1,9 @@
+.vscode/**
+typings/**
+out/test/**
+test/**
+src/**
+**/*.map
+.gitignore
+tsconfig.json
+vsc-extension-quickstart.md
diff --git a/vscode-sbt-scala/client/README.md b/vscode-sbt-scala/client/README.md
new file mode 100644
index 000000000..01de59573
--- /dev/null
+++ b/vscode-sbt-scala/client/README.md
@@ -0,0 +1,9 @@
+Scala language support using sbt
+================================
+
+This is an experimental Scala language support using sbt as the language server.
+
+To try this, use sbt 1.1.0-RC1 or above.
+
+- Saving `*.scala` will trigger `compile` task.
+- Jump to definition support for class names.
diff --git a/vscode-sbt-scala/client/images/sbt-logo-bgwhite-455x262.png b/vscode-sbt-scala/client/images/sbt-logo-bgwhite-455x262.png
new file mode 100644
index 000000000..cce326960
Binary files /dev/null and b/vscode-sbt-scala/client/images/sbt-logo-bgwhite-455x262.png differ
diff --git a/vscode-sbt-scala/client/images/sbt-logo.svg b/vscode-sbt-scala/client/images/sbt-logo.svg
new file mode 100644
index 000000000..d028d0540
--- /dev/null
+++ b/vscode-sbt-scala/client/images/sbt-logo.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 14.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 43363)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="257.333px" height="147.833px" viewBox="0 0 257.333 147.833" enable-background="new 0 0 257.333 147.833"
+	 xml:space="preserve">
+<g id="guidelines" display="none">
+	<line display="inline" fill="none" stroke="#FF2D00" x1="160.833" y1="21.833" x2="126.958" y2="159.208"/>
+	<line display="inline" fill="none" stroke="#FF2D00" x1="181.25" y1="28.875" x2="147.375" y2="166.25"/>
+</g>
+<g id="Layer_3">
+	<path fill="#380D09" d="M17.417,106.458l-13.25,12c0,0,6.5,8.125,15.125,13s13.381,4.508,23.065,4.379
+		c9.31,0,18.81-1.754,26.435-8.504s9.066-8.6,9.033-17.112c-0.016-3.994-1.075-12.813-5.908-18.513
+		c-5.466-6.445-14.781-9.566-14.781-9.566s-28.53-7.155-25.594-17.059c1.232-4.156,7.818-5.726,14.292-4.583
+		c8.192,1.444,16.474,6.371,16.474,6.371l11.577-11.33c0,0-5.274-6.198-13.468-10.208c-6.064-2.967-14.428-4.059-19.783-4.078
+		c-12.592-0.047-28.335,11.197-30.217,22.828c-1.375,8.5,1.383,15.676,7.625,21.125c7.875,6.875,13.478,7.771,13.478,7.771
+		s25.123,6.469,25.123,14.286s-6.101,10.692-15.851,10.817S17.417,106.458,17.417,106.458z"/>
+	<path fill="#380D09" d="M198.508,45.484l0.2,18.199h10.4l0.1,53.9c0,0,1.801,6.2,6.5,10.8c6.065,5.937,12.4,7.454,12.4,7.454
+		h20.399l0.101-18.554l-11-0.1c0,0-2.401,0.101-5.1-2.5c-2.801-2.7-2.7-6.2-2.7-6.2l0.2-44.9h20l0.1-18.2l-20-0.1l-0.2-35.2h-20.8
+		l0.2,35.4H198.508z"/>
+	<path fill="#380D09" d="M156.667,49.833c-12.529-2.767-25.25-1.375-33.375,3.375l10.625-43.125l-21.188-5.188L82.604,126.333
+		l21,6.062L106.5,120.5c6.167,11.666,13.194,17.279,26.667,20.333c25,5.667,47.312-11.762,53.334-38.667
+		C191.667,79.083,175.917,54.083,156.667,49.833z M162.756,117.094l-30.152,8.302l-22.49-22.776l7.666-31.077l30.155-8.302
+		l22.487,22.776L162.756,117.094z"/>
+</g>
+</svg>
diff --git a/vscode-sbt-scala/client/language-configuration.json b/vscode-sbt-scala/client/language-configuration.json
new file mode 100644
index 000000000..aa2571000
--- /dev/null
+++ b/vscode-sbt-scala/client/language-configuration.json
@@ -0,0 +1,30 @@
+{
+    "comments": {
+        // symbol used for single line comment. Remove this entry if your language does not support line comments
+        "lineComment": "//",
+        // symbols used for start and end a block comment. Remove this entry if your language does not support block comments
+        "blockComment": [ "/*", "*/" ]
+    },
+    // symbols used as brackets
+    "brackets": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"]
+    ],
+    // symbols that are auto closed when typing
+    "autoClosingPairs": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+        ["\"", "\""],
+        ["'", "'"]
+    ],
+    // symbols that that can be used to surround a selection
+    "surroundingPairs": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+        ["\"", "\""],
+        ["'", "'"]
+    ]
+}
\ No newline at end of file
diff --git a/vscode-sbt-scala/client/package-lock.json b/vscode-sbt-scala/client/package-lock.json
new file mode 100644
index 000000000..75dc4fb56
--- /dev/null
+++ b/vscode-sbt-scala/client/package-lock.json
@@ -0,0 +1,47 @@
+{
+  "name": "vscode-sbt-scala",
+  "version": "0.2.4",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@types/vscode": {
+      "version": "1.34.0",
+      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.34.0.tgz",
+      "integrity": "sha512-t81rGr6aFw8TMap7UJdikC5ilOtL0yNr/pkovyyTy31fZ4XJehrxLMRh8nJuoOF3+g4rG9ljmtQo7tm6wyoaYA==",
+      "dev": true
+    },
+    "semver": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
+      "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg=="
+    },
+    "vscode-jsonrpc": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-4.0.0.tgz",
+      "integrity": "sha512-perEnXQdQOJMTDFNv+UF3h1Y0z4iSiaN9jIlb0OqIYgosPCZGYh/MCUlkFtV2668PL69lRDO32hmvL2yiidUYg=="
+    },
+    "vscode-languageclient": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-5.2.1.tgz",
+      "integrity": "sha512-7jrS/9WnV0ruqPamN1nE7qCxn0phkH5LjSgSp9h6qoJGoeAKzwKz/PF6M+iGA/aklx4GLZg1prddhEPQtuXI1Q==",
+      "requires": {
+        "semver": "^5.5.0",
+        "vscode-languageserver-protocol": "3.14.1"
+      }
+    },
+    "vscode-languageserver-protocol": {
+      "version": "3.14.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.14.1.tgz",
+      "integrity": "sha512-IL66BLb2g20uIKog5Y2dQ0IiigW0XKrvmWiOvc0yXw80z3tMEzEnHjaGAb3ENuU7MnQqgnYJ1Cl2l9RvNgDi4g==",
+      "requires": {
+        "vscode-jsonrpc": "^4.0.0",
+        "vscode-languageserver-types": "3.14.0"
+      }
+    },
+    "vscode-languageserver-types": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.14.0.tgz",
+      "integrity": "sha512-lTmS6AlAlMHOvPQemVwo3CezxBp0sNB95KNPkqp3Nxd5VFEnuG1ByM0zlRWos0zjO3ZWtkvhal0COgiV1xIA4A=="
+    }
+  }
+}
diff --git a/vscode-sbt-scala/client/package.json b/vscode-sbt-scala/client/package.json
new file mode 100644
index 000000000..15736ae67
--- /dev/null
+++ b/vscode-sbt-scala/client/package.json
@@ -0,0 +1,54 @@
+{
+  "name": "vscode-sbt-scala",
+  "displayName": "Scala (sbt)",
+  "version": "0.2.4",
+  "author": "Lightbend, Inc.",
+  "license": "BSD-3-Clause",
+  "publisher": "lightbend",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sbt/sbt"
+  },
+  "description": "Scala language support using sbt",
+  "icon": "images/sbt-logo-bgwhite-455x262.png",
+  "engines": {
+    "vscode": "^1.23.0"
+  },
+  "categories": [
+    "Languages"
+  ],
+  "contributes": {
+    "languages": [
+      {
+        "id": "scala",
+        "aliases": [
+          "Scala",
+          "scala"
+        ],
+        "extensions": [
+          ".scala",
+          ".sbt"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "scala",
+        "scopeName": "source.scala",
+        "path": "./syntaxes/Scala.tmLanguage"
+      }
+    ]
+  },
+  "activationEvents": [
+    "workspaceContains:build.sbt"
+  ],
+  "main": "./out/src/extension",
+  "scripts": {},
+  "dependencies": {
+    "vscode-languageclient": "^5.2.1"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.32.0"
+  }
+}
diff --git a/vscode-sbt-scala/client/src/extension.ts b/vscode-sbt-scala/client/src/extension.ts
new file mode 100644
index 000000000..4ccebed75
--- /dev/null
+++ b/vscode-sbt-scala/client/src/extension.ts
@@ -0,0 +1,129 @@
+'use strict';
+
+import * as path from 'path';
+import * as url from 'url';
+import * as net from 'net';
+let fs = require('fs'),
+	os = require('os');
+import * as vscode from 'vscode';
+import { ExtensionContext, workspace } from 'vscode'; // workspace, 
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  RevealOutputChannelOn,
+  ServerOptions,
+  TransportKind
+} from 'vscode-languageclient';
+
+let terminal: vscode.Terminal = null;
+
+function delay(ms: number) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export async function deactivate() {
+	if (terminal != null) {
+		terminal.sendText("exit");
+		await delay(1000);
+		terminal.dispose();
+	}
+}
+
+export async function activate(context: ExtensionContext) {
+	// Start sbt
+	terminal = vscode.window.createTerminal(`sbt`);
+	terminal.show();
+	terminal.sendText("sbt");
+	// Wait for sbt server to start
+	let retries = 60;
+	while (retries > 0) {
+		retries--;
+		await delay(1000);
+		if (isServerUp()) {
+			break;
+		}
+	}
+
+	// The server is implemented in node
+	let serverModule = context.asAbsolutePath(path.join('server', 'server.js'));
+	// The debug options for the server
+	// let debugOptions = { execArgv: ["--nolazy", "--debug=6009"] };
+	
+	// If the extension is launched in debug mode then the debug server options are used
+	// Otherwise the run options are used
+	let serverOptions: ServerOptions = {
+		run : { module: serverModule, transport: TransportKind.stdio },
+		debug: { module: serverModule, transport: TransportKind.stdio }
+	}
+	
+	// Options to control the language client
+	let clientOptions: LanguageClientOptions = {
+		documentSelector: [{ language: 'scala', scheme: 'file' }, { language: 'java', scheme: 'file' }],
+		revealOutputChannelOn: RevealOutputChannelOn.Never,
+		initializationOptions: () => { 
+			return discoverToken();
+		}
+	}
+
+	// Don't start VS Code connection until sbt server is confirmed to be up and running.
+	function isServerUp(): boolean {
+		let isFileThere = fs.existsSync(path.join(workspace.rootPath, 'project', 'target', 'active.json'));
+		if (!isFileThere) {
+			return false;
+		} else {
+			let skt = new net.Socket();
+			try {
+				connectSocket(skt);
+			} catch(e) {
+				return false;
+			}
+			skt.end();
+			return true;
+		}
+	}
+
+	function connectSocket(socket: net.Socket): 　net.Socket {
+		let u = discoverUrl();
+		// let socket = net.Socket();
+		if (u.protocol == 'tcp:') {
+			socket.connect(+u.port, '127.0.0.1');
+		} else if (u.protocol == 'local:' && os.platform() == 'win32') {
+			let pipePath = '\\\\.\\pipe\\' + u.hostname;
+			socket.connect(pipePath);
+		} else if (u.protocol == 'local:') {
+			socket.connect(u.path);
+		} else {
+			throw 'Unknown protocol ' + u.protocol;
+		}
+		return socket;
+	}
+
+	// the port file is hardcoded to a particular location relative to the build.
+	function discoverUrl(): url.Url {
+		let pf = path.join(process.cwd(), 'project', 'target', 'active.json');
+		let portfile = JSON.parse(fs.readFileSync(pf));
+		return url.parse(portfile.uri);
+	}
+
+	// the port file is hardcoded to a particular location relative to the build.
+	function discoverToken(): any {
+		let pf = path.join(workspace.rootPath, 'project', 'target', 'active.json');
+		let portfile = JSON.parse(fs.readFileSync(pf));
+
+		// if tokenfilepath exists, return the token.
+		if (portfile.hasOwnProperty('tokenfilePath')) {
+			let tf = portfile.tokenfilePath;
+			let tokenfile = JSON.parse(fs.readFileSync(tf));
+			return {
+				token: tokenfile.token
+			};
+		} else {
+      return {};
+		}
+	}
+
+	// Create the language client and start the client.
+	let disposable = new LanguageClient('lspSbtScala', 'sbt Scala Language Server', serverOptions, clientOptions).start();
+	
+	context.subscriptions.push(disposable);
+}
diff --git a/vscode-sbt-scala/client/syntaxes/Scala.tmLanguage b/vscode-sbt-scala/client/syntaxes/Scala.tmLanguage
new file mode 100644
index 000000000..aee49eaf0
--- /dev/null
+++ b/vscode-sbt-scala/client/syntaxes/Scala.tmLanguage
@@ -0,0 +1,1262 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>fileTypes</key>
+	<array>
+		<string>scala</string>
+	</array>
+	<key>firstLineMatch</key>
+	<string>^#!/.*\b\w*scala\b</string>
+	<key>foldingStartMarker</key>
+	<string>/\*\*|\{\s*$</string>
+	<key>foldingStopMarker</key>
+	<string>\*\*/|^\s*\}</string>
+	<key>keyEquivalent</key>
+	<string>^~S</string>
+	<key>name</key>
+	<string>Scala</string>
+	<key>patterns</key>
+	<array>
+		<dict>
+			<key>include</key>
+			<string>#code</string>
+		</dict>
+	</array>
+	<key>repository</key>
+	<dict>
+		<key>block-comments</key>
+		<dict>
+			<key>begin</key>
+			<string>/\*</string>
+			<key>end</key>
+			<string>\*/</string>
+			<key>name</key>
+			<string>comment.block.scala</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>#block-comments</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>(?x)
+			(?! /\*)
+			(?! \*/)
+		  </string>
+				</dict>
+			</array>
+		</dict>
+		<key>char-literal</key>
+		<dict>
+			<key>begin</key>
+			<string>'</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.character.begin.scala</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>'</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.character.end.scala</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>constant.character.literal.scala</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>\\(?:[btnfr\\"']|[0-7]{1,3}|u[0-9A-Fa-f]{4})</string>
+					<key>name</key>
+					<string>constant.character.escape.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\\.</string>
+					<key>name</key>
+					<string>invalid.illegal.unrecognized-character-escape.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>[^']{2,}</string>
+					<key>name</key>
+					<string>invalid.illegal.character-literal-too-long</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>(?&lt;!')[^']</string>
+					<key>name</key>
+					<string>invalid.illegal.character-literal-too-long</string>
+				</dict>
+			</array>
+		</dict>
+		<key>code</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>#script-header</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#storage-modifiers</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#declarations</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#inheritance</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#imports</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#comments</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#strings</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#initialization</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#xml-literal</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#keywords</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#constants</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#scala-symbol</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#special-identifier</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#char-literal</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#empty-parentheses</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#parameter-list</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#qualifiedClassName</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#meta-brackets</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#meta-bounds</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#meta-colons</string>
+				</dict>
+			</array>
+		</dict>
+		<key>comments</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.comment.scala</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>/\*\*/</string>
+					<key>name</key>
+					<string>comment.block.empty.scala</string>
+				</dict>
+				<dict>
+					<key>begin</key>
+					<string>^\s*(/\*\*)(?!/)</string>
+					<key>beginCaptures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.comment.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>\*/</string>
+					<key>endCaptures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.comment.scala</string>
+						</dict>
+					</dict>
+					<key>name</key>
+					<string>comment.block.documentation.scala</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>captures</key>
+							<dict>
+								<key>1</key>
+								<dict>
+									<key>name</key>
+									<string>keyword.other.documentation.scaladoc.scala</string>
+								</dict>
+								<key>2</key>
+								<dict>
+									<key>name</key>
+									<string>variable.parameter.scala</string>
+								</dict>
+							</dict>
+							<key>match</key>
+							<string>(@param)\s+(\S+)</string>
+						</dict>
+						<dict>
+							<key>captures</key>
+							<dict>
+								<key>1</key>
+								<dict>
+									<key>name</key>
+									<string>keyword.other.documentation.scaladoc.scala</string>
+								</dict>
+								<key>2</key>
+								<dict>
+									<key>name</key>
+									<string>entity.name.class</string>
+								</dict>
+							</dict>
+							<key>match</key>
+							<string>(@(?:tparam|throws))\s+(\S+)</string>
+						</dict>
+						<dict>
+							<key>match</key>
+							<string>@(return|see|note|example|usecase|author|version|since|todo|deprecated|migration|define|inheritdoc)\b</string>
+							<key>name</key>
+							<string>keyword.other.documentation.scaladoc.scala</string>
+						</dict>
+						<dict>
+							<key>captures</key>
+							<dict>
+								<key>1</key>
+								<dict>
+									<key>name</key>
+									<string>punctuation.definition.documentation.link.scala</string>
+								</dict>
+								<key>2</key>
+								<dict>
+									<key>name</key>
+									<string>entity.other.documentation.link.scala</string>
+								</dict>
+								<key>3</key>
+								<dict>
+									<key>name</key>
+									<string>punctuation.definition.documentation.link.scala</string>
+								</dict>
+							</dict>
+							<key>match</key>
+							<string>(\[\[)([^\]]+)(\]\])</string>
+						</dict>
+					</array>
+				</dict>
+				<dict>
+					<key>begin</key>
+					<string>/\*</string>
+					<key>captures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.comment.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>\*/</string>
+					<key>name</key>
+					<string>comment.block.scala</string>
+				</dict>
+				<dict>
+					<key>begin</key>
+					<string>(^[ \t]+)?(?=//)</string>
+					<key>beginCaptures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.whitespace.comment.leading.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>(?!\G)</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>begin</key>
+							<string>//</string>
+							<key>beginCaptures</key>
+							<dict>
+								<key>0</key>
+								<dict>
+									<key>name</key>
+									<string>punctuation.definition.comment.scala</string>
+								</dict>
+							</dict>
+							<key>end</key>
+							<string>\n</string>
+							<key>name</key>
+							<string>comment.line.double-slash.scala</string>
+						</dict>
+					</array>
+				</dict>
+			</array>
+		</dict>
+		<key>constants</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>\b(false|null|true|Nil|None)\b</string>
+					<key>name</key>
+					<string>constant.language.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.[0-9]+)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?|[0-9]+)([LlFfDd]|UL|ul)?\b</string>
+					<key>name</key>
+					<string>constant.numeric.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b(this|super|self)\b</string>
+					<key>name</key>
+					<string>variable.language.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b(Unit|Boolean|Byte|Char|Short|Int|Float|Long|Double)\b</string>
+					<key>name</key>
+					<string>storage.type.primitive.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b(String|Symbol)\b</string>
+					<key>name</key>
+					<string>storage.type.scala</string>
+				</dict>
+			</array>
+		</dict>
+		<key>declarations</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.function.declaration</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>(?x)
+						\b(def)\s+
+						(`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\t .,;()\[\]{}'"`\w])(?=[(\t ])|[_$a-zA-Z][_$a-zA-Z0-9]*|[-?~&gt;&lt;^+*%:!#|/@\\]+)</string>
+				</dict>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.scala</string>
+						</dict>
+						<key>3</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.class.declaration</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>(case)?\b(class|trait|object)\s+([^\s\{\(\[]+)</string>
+				</dict>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.type.declaration</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>\b(type)\s+(`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\s])(?=[\t ])|[_$a-zA-Z][_$a-zA-Z0-9]*|[-?~&gt;&lt;^+*%:!#|/@\\]+)</string>
+				</dict>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.stable.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>constant.other.declaration.scala</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>\b(val)\s+(?:([A-Z][_a-zA-Z0-9]*))\b</string>
+				</dict>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.stable.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.volatile.scala</string>
+						</dict>
+						<key>3</key>
+						<dict>
+							<key>name</key>
+							<string>variable.other.declaration.scala</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>\b(?:(val)|(var))\s+(?:(`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\t .,;()\[\]{}'"`\w])(?=[\t ])|[_$a-zA-Z][_$a-zA-Z0-9]*|[-?~&gt;&lt;^+*%:!#|/@\\]+)|(?=\())</string>
+				</dict>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.other.scoping.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.scala</string>
+						</dict>
+						<key>3</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.class.declaration</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>\b(package)\s+(object)\s+([^\s\{\(\[]+)</string>
+				</dict>
+				<dict>
+					<key>begin</key>
+					<string>\b(package)\s+</string>
+					<key>beginCaptures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.other.import.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>(?&lt;=[\n;])</string>
+					<key>name</key>
+					<string>meta.package.scala</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>include</key>
+							<string>#comments</string>
+						</dict>
+						<dict>
+							<key>match</key>
+							<string>(`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*)</string>
+							<key>name</key>
+							<string>entity.name.package.scala</string>
+						</dict>
+						<dict>
+							<key>match</key>
+							<string>\.</string>
+							<key>name</key>
+							<string>punctuation.definition.package</string>
+						</dict>
+					</array>
+				</dict>
+			</array>
+		</dict>
+		<key>empty-parentheses</key>
+		<dict>
+			<key>captures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>meta.bracket.scala</string>
+				</dict>
+			</dict>
+			<key>match</key>
+			<string>(\(\))</string>
+			<key>name</key>
+			<string>meta.parentheses.scala</string>
+		</dict>
+		<key>imports</key>
+		<dict>
+			<key>begin</key>
+			<string>\b(import)\s+</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>keyword.other.import.scala</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>(?&lt;=[\n;])</string>
+			<key>name</key>
+			<string>meta.import.scala</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>#comments</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>(`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*)</string>
+					<key>name</key>
+					<string>entity.name.import.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\.</string>
+					<key>name</key>
+					<string>punctuation.definition.import</string>
+				</dict>
+				<dict>
+					<key>begin</key>
+					<string>{</string>
+					<key>beginCaptures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>meta.bracket.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>}</string>
+					<key>endCaptures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>meta.bracket.scala</string>
+						</dict>
+					</dict>
+					<key>name</key>
+					<string>meta.import.selector.scala</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>captures</key>
+							<dict>
+								<key>1</key>
+								<dict>
+									<key>name</key>
+									<string>entity.name.import.renamed-from.scala</string>
+								</dict>
+								<key>2</key>
+								<dict>
+									<key>name</key>
+									<string>keyword.other.arrow.scala</string>
+								</dict>
+								<key>3</key>
+								<dict>
+									<key>name</key>
+									<string>entity.name.import.renamed-to.scala</string>
+								</dict>
+							</dict>
+							<key>match</key>
+							<string>(?x) \s*
+				      (`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*) \s*
+				      (=&gt;) \s*
+				      (`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*) \s*
+			        </string>
+						</dict>
+						<dict>
+							<key>match</key>
+							<string>([^\s.,}]+)</string>
+							<key>name</key>
+							<string>entity.name.import.scala</string>
+						</dict>
+					</array>
+				</dict>
+			</array>
+		</dict>
+		<key>inheritance</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>keyword.declaration.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>entity.other.inherited-class.scala</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string>(extends|with)\s+([^\s\{\(\[\]]+)</string>
+				</dict>
+			</array>
+		</dict>
+		<key>initialization</key>
+		<dict>
+			<key>captures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>keyword.declaration.scala</string>
+				</dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>entity.name.class</string>
+				</dict>
+			</dict>
+			<key>match</key>
+			<string>\b(new)\s+([^\s,\{\}\(\)\[\]]+)</string>
+		</dict>
+		<key>keywords</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>\b(return|throw)\b</string>
+					<key>name</key>
+					<string>keyword.control.flow.jump.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b(classOf|isInstanceOf|asInstanceOf)\b</string>
+					<key>name</key>
+					<string>support.function.type-of.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b(else|if|do|while|for|yield|match|case)\b</string>
+					<key>name</key>
+					<string>keyword.control.flow.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b(catch|finally|try)\b</string>
+					<key>name</key>
+					<string>keyword.control.exception.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>(==?|!=|&lt;=|&gt;=|&lt;&gt;|&lt;|&gt;)</string>
+					<key>name</key>
+					<string>keyword.operator.comparison.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>(\-|\+|\*|/(?![/*])|%|~)</string>
+					<key>name</key>
+					<string>keyword.operator.arithmetic.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>(!|&amp;&amp;|\|\|)</string>
+					<key>name</key>
+					<string>keyword.operator.logical.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>(&lt;-|←|-&gt;|→|=&gt;|⇒|\?|\:+|@|\|)+</string>
+					<key>name</key>
+					<string>keyword.operator.scala</string>
+				</dict>
+			</array>
+		</dict>
+		<key>meta-bounds</key>
+		<dict>
+			<key>comment</key>
+			<string>For themes: Matching view bounds</string>
+			<key>match</key>
+			<string>&lt;%|=:=|&lt;:&lt;|&lt;%&lt;|&gt;:|&lt;:</string>
+			<key>name</key>
+			<string>meta.bounds.scala</string>
+		</dict>
+		<key>meta-brackets</key>
+		<dict>
+			<key>comment</key>
+			<string>For themes: Brackets look nice when colored.</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>comment</key>
+					<string>The punctuation.section.*.begin is needed for return snippet in source bundle</string>
+					<key>match</key>
+					<string>\{</string>
+					<key>name</key>
+					<string>punctuation.section.block.begin.scala</string>
+				</dict>
+				<dict>
+					<key>comment</key>
+					<string>The punctuation.section.*.end is needed for return snippet in source bundle</string>
+					<key>match</key>
+					<string>\}</string>
+					<key>name</key>
+					<string>punctuation.section.block.end.scala</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>{|}|\(|\)|\[|\]</string>
+					<key>name</key>
+					<string>meta.bracket.scala</string>
+				</dict>
+			</array>
+		</dict>
+		<key>meta-colons</key>
+		<dict>
+			<key>comment</key>
+			<string>For themes: Matching type colons</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>(?&lt;!:):(?!:)</string>
+					<key>name</key>
+					<string>meta.colon.scala</string>
+				</dict>
+			</array>
+		</dict>
+		<key>parameter-list</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>variable.parameter.scala</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>meta.colon.scala</string>
+						</dict>
+					</dict>
+					<key>comment</key>
+					<string>We do not match param names that start with a Capitol letter</string>
+					<key>match</key>
+					<string>(?&lt;=[^\._$a-zA-Z0-9])(`[^`]+`|[_$a-z][_$a-zA-Z0-9]*(?:_[^\s])(?=[\t ])|[_$a-z][_$a-zA-Z0-9]*|[-?~&gt;&lt;^+*%:!#|/@\\]+)\s*(:)\s+</string>
+				</dict>
+			</array>
+		</dict>
+		<key>qualifiedClassName</key>
+		<dict>
+			<key>captures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>entity.name.class</string>
+				</dict>
+			</dict>
+			<key>match</key>
+			<string>(\b([A-Z][\w]*))</string>
+		</dict>
+		<key>scala-symbol</key>
+		<dict>
+			<key>match</key>
+			<string>'\w+(?=[^'\w]|$)</string>
+			<key>name</key>
+			<string>constant.other.symbol.scala</string>
+		</dict>
+		<key>script-header</key>
+		<dict>
+			<key>captures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>string.unquoted.shebang.scala</string>
+				</dict>
+			</dict>
+			<key>match</key>
+			<string>^#!(.*)$</string>
+			<key>name</key>
+			<string>comment.block.shebang.scala</string>
+		</dict>
+		<key>special-identifier</key>
+		<dict>
+			<key>comment</key>
+			<string>
+		    Match special scala style identifiers that can end with and underscore and
+		    a a not letter such as blank_?.  This way the symbol will not be colored
+		    differently.
+		  </string>
+			<key>match</key>
+			<string>\b[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\t .,;()\[\]{}'"`\w])</string>
+		</dict>
+		<key>storage-modifiers</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>match</key>
+					<string>\b(private\[\S+\]|protected\[\S+\]|private|protected)\b</string>
+					<key>name</key>
+					<string>storage.modifier.access</string>
+				</dict>
+				<dict>
+					<key>match</key>
+					<string>\b(synchronized|@volatile|abstract|final|lazy|sealed|implicit|override|@transient|@native)\b</string>
+					<key>name</key>
+					<string>storage.modifier.other</string>
+				</dict>
+			</array>
+		</dict>
+		<key>strings</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>begin</key>
+					<string>"""</string>
+					<key>beginCaptures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.string.begin.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>"""(?!")</string>
+					<key>endCaptures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.string.end.scala</string>
+						</dict>
+					</dict>
+					<key>name</key>
+					<string>string.quoted.triple.scala</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>match</key>
+							<string>\\\\|\\u[0-9A-Fa-f]{4}</string>
+							<key>name</key>
+							<string>constant.character.escape.scala</string>
+						</dict>
+					</array>
+				</dict>
+				<dict>
+					<key>begin</key>
+					<string>"</string>
+					<key>beginCaptures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.string.begin.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>"</string>
+					<key>endCaptures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.string.end.scala</string>
+						</dict>
+					</dict>
+					<key>name</key>
+					<string>string.quoted.double.scala</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>match</key>
+							<string>\\(?:[btnfr\\"']|[0-7]{1,3}|u[0-9A-Fa-f]{4})</string>
+							<key>name</key>
+							<string>constant.character.escape.scala</string>
+						</dict>
+						<dict>
+							<key>match</key>
+							<string>\\.</string>
+							<key>name</key>
+							<string>invalid.illegal.unrecognized-string-escape.scala</string>
+						</dict>
+					</array>
+				</dict>
+			</array>
+		</dict>
+		<key>xml-doublequotedString</key>
+		<dict>
+			<key>begin</key>
+			<string>"</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.begin.xml</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>"</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.end.xml</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>string.quoted.double.xml</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>#xml-entity</string>
+				</dict>
+			</array>
+		</dict>
+		<key>xml-embedded-content</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>begin</key>
+					<string>{</string>
+					<key>captures</key>
+					<dict>
+						<key>0</key>
+						<dict>
+							<key>name</key>
+							<string>meta.bracket.scala</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>}</string>
+					<key>name</key>
+					<string>meta.source.embedded.scala</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>include</key>
+							<string>#code</string>
+						</dict>
+					</array>
+				</dict>
+				<dict>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>entity.other.attribute-name.namespace.xml</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>entity.other.attribute-name.xml</string>
+						</dict>
+						<key>3</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.separator.namespace.xml</string>
+						</dict>
+						<key>4</key>
+						<dict>
+							<key>name</key>
+							<string>entity.other.attribute-name.localname.xml</string>
+						</dict>
+					</dict>
+					<key>match</key>
+					<string> (?:([-_a-zA-Z0-9]+)((:)))?([_a-zA-Z-]+)=</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#xml-doublequotedString</string>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#xml-singlequotedString</string>
+				</dict>
+			</array>
+		</dict>
+		<key>xml-entity</key>
+		<dict>
+			<key>captures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.constant.xml</string>
+				</dict>
+				<key>3</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.constant.xml</string>
+				</dict>
+			</dict>
+			<key>match</key>
+			<string>(&amp;)([:a-zA-Z_][:a-zA-Z0-9_.-]*|#[0-9]+|#x[0-9a-fA-F]+)(;)</string>
+			<key>name</key>
+			<string>constant.character.entity.xml</string>
+		</dict>
+		<key>xml-literal</key>
+		<dict>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>begin</key>
+					<string>(&lt;)((?:([_a-zA-Z0-9][_a-zA-Z0-9]*)((:)))?([_a-zA-Z0-9][-_a-zA-Z0-9:]*))(?=(\s[^&gt;]*)?&gt;&lt;/\2&gt;)</string>
+					<key>beginCaptures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.tag.xml</string>
+						</dict>
+						<key>3</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.namespace.xml</string>
+						</dict>
+						<key>4</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.xml</string>
+						</dict>
+						<key>5</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.separator.namespace.xml</string>
+						</dict>
+						<key>6</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.localname.xml</string>
+						</dict>
+					</dict>
+					<key>comment</key>
+					<string>We do not allow a tag name to start with a - since this would
+				               likely conflict with the &lt;- operator. This is not very common
+				               for tag names anyway.  Also code such as -- if (val &lt;val2 || val&gt; val3)
+				               will falsly be recognized as an xml tag.  The solution is to put a
+				               space on either side of the comparison operator</string>
+					<key>end</key>
+					<string>(&gt;(&lt;))/(?:([-_a-zA-Z0-9]+)((:)))?([-_a-zA-Z0-9:]*[_a-zA-Z0-9])(&gt;)</string>
+					<key>endCaptures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.tag.xml</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>meta.scope.between-tag-pair.xml</string>
+						</dict>
+						<key>3</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.namespace.xml</string>
+						</dict>
+						<key>4</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.xml</string>
+						</dict>
+						<key>5</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.separator.namespace.xml</string>
+						</dict>
+						<key>6</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.localname.xml</string>
+						</dict>
+						<key>7</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.tag.xml</string>
+						</dict>
+					</dict>
+					<key>name</key>
+					<string>meta.tag.no-content.xml</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>include</key>
+							<string>#xml-embedded-content</string>
+						</dict>
+					</array>
+				</dict>
+				<dict>
+					<key>begin</key>
+					<string>(&lt;/?)(?:([_a-zA-Z0-9][-_a-zA-Z0-9]*)((:)))?([_a-zA-Z0-9][-_a-zA-Z0-9:]*)(?=[^&gt;]*?&gt;)</string>
+					<key>captures</key>
+					<dict>
+						<key>1</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.definition.tag.xml</string>
+						</dict>
+						<key>2</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.namespace.xml</string>
+						</dict>
+						<key>3</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.xml</string>
+						</dict>
+						<key>4</key>
+						<dict>
+							<key>name</key>
+							<string>punctuation.separator.namespace.xml</string>
+						</dict>
+						<key>5</key>
+						<dict>
+							<key>name</key>
+							<string>entity.name.tag.localname.xml</string>
+						</dict>
+					</dict>
+					<key>end</key>
+					<string>(/?&gt;)</string>
+					<key>name</key>
+					<string>meta.tag.xml</string>
+					<key>patterns</key>
+					<array>
+						<dict>
+							<key>include</key>
+							<string>#xml-embedded-content</string>
+						</dict>
+					</array>
+				</dict>
+				<dict>
+					<key>include</key>
+					<string>#xml-entity</string>
+				</dict>
+			</array>
+		</dict>
+		<key>xml-singlequotedString</key>
+		<dict>
+			<key>begin</key>
+			<string>'</string>
+			<key>beginCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.begin.xml</string>
+				</dict>
+			</dict>
+			<key>end</key>
+			<string>'</string>
+			<key>endCaptures</key>
+			<dict>
+				<key>0</key>
+				<dict>
+					<key>name</key>
+					<string>punctuation.definition.string.end.xml</string>
+				</dict>
+			</dict>
+			<key>name</key>
+			<string>string.quoted.single.xml</string>
+			<key>patterns</key>
+			<array>
+				<dict>
+					<key>include</key>
+					<string>#xml-entity</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
+	<key>scopeName</key>
+	<string>source.scala</string>
+	<key>uuid</key>
+	<string>158C0929-299A-40C8-8D89-316BE0C446E8</string>
+</dict>
+</plist>
diff --git a/vscode-sbt-scala/client/tsconfig.json b/vscode-sbt-scala/client/tsconfig.json
new file mode 100644
index 000000000..c10ad282c
--- /dev/null
+++ b/vscode-sbt-scala/client/tsconfig.json
@@ -0,0 +1,19 @@
+{
+	"compilerOptions": {
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitAny": true,
+		"noImplicitReturns": true,		
+		"target": "es6",
+		"module": "commonjs",
+		"moduleResolution": "node",
+		"rootDir": ".",
+		"outDir": "out",
+		"lib": [ "es2016" ],
+		"sourceMap": true
+	},
+	"exclude": [
+		"node_modules",
+		"server"
+	]
+}
\ No newline at end of file
diff --git a/vscode-sbt-scala/package-lock.json b/vscode-sbt-scala/package-lock.json
new file mode 100644
index 000000000..f0c985121
--- /dev/null
+++ b/vscode-sbt-scala/package-lock.json
@@ -0,0 +1,26 @@
+{
+  "name": "vscode-sbt-scala",
+  "version": "0.0.1",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@types/mocha": {
+      "version": "2.2.48",
+      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-2.2.48.tgz",
+      "integrity": "sha512-nlK/iyETgafGli8Zh9zJVCTicvU3iajSkRwOh3Hhiva598CMqNJ4NcVCGMTGKpGpTYj/9R8RLzS9NAykSSCqGw==",
+      "dev": true
+    },
+    "@types/node": {
+      "version": "7.0.69",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-7.0.69.tgz",
+      "integrity": "sha512-S5NC8HV6HnRipg8nC0j30TPl7ktXjRTKqgyINLNe8K/64UJUI8Lq0sRopXC0hProsV2F5ibj8IqPkl1xpGggrw==",
+      "dev": true
+    },
+    "typescript": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.9.2.tgz",
+      "integrity": "sha512-Gr4p6nFNaoufRIY4NMdpQRNmgxVIGMs4Fcu/ujdYk3nAZqk7supzBE9idmvfZIlH/Cuj//dvi+019qEue9lV0w==",
+      "dev": true
+    }
+  }
+}
diff --git a/vscode-sbt-scala/package.json b/vscode-sbt-scala/package.json
new file mode 100644
index 000000000..ded6ee6d6
--- /dev/null
+++ b/vscode-sbt-scala/package.json
@@ -0,0 +1,26 @@
+{
+  "name": "vscode-sbt-scala",
+  "displayName": "Scala (sbt)",
+  "version": "0.0.1",
+  "author": "Lightbend, Inc.",
+  "license": "BSD-3-Clause",
+  "publisher": "lightbend",
+  "description": "Scala language support for Visual Studio Code using sbt",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sbt/sbt"
+  },
+  "scripts": {
+    "postinstall": "cd server && npm install && cd ../client && npm install && cd ..",
+    "compile": "tsc -p client/tsconfig.json && cd server && npm run installServer && cd .. && tsc -p server/tsconfig.json",
+    "compile:client": "tsc -p client/tsconfig.json",
+    "watch:client": "tsc -w -p client/tsconfig.json",
+    "compile:server": "cd server && npm run installServer && cd .. && tsc -p server/tsconfig.json",
+    "watch:server": "cd server && npm run installServer && cd .. && tsc -w -p server/tsconfig.json"
+  },
+  "devDependencies": {
+    "@types/mocha": "^2.2.48",
+    "@types/node": "^7.0.69",
+    "typescript": "^2.9.2"
+  }
+}
diff --git a/vscode-sbt-scala/server/package-lock.json b/vscode-sbt-scala/server/package-lock.json
new file mode 100644
index 000000000..bfe7026f9
--- /dev/null
+++ b/vscode-sbt-scala/server/package-lock.json
@@ -0,0 +1,41 @@
+{
+	"name": "vscode-sbt-scala",
+	"version": "0.0.1",
+	"lockfileVersion": 1,
+	"requires": true,
+	"dependencies": {
+		"vscode-jsonrpc": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-4.0.0.tgz",
+			"integrity": "sha512-perEnXQdQOJMTDFNv+UF3h1Y0z4iSiaN9jIlb0OqIYgosPCZGYh/MCUlkFtV2668PL69lRDO32hmvL2yiidUYg=="
+		},
+		"vscode-languageserver": {
+			"version": "5.2.1",
+			"resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-5.2.1.tgz",
+			"integrity": "sha512-GuayqdKZqAwwaCUjDvMTAVRPJOp/SLON3mJ07eGsx/Iq9HjRymhKWztX41rISqDKhHVVyFM+IywICyZDla6U3A==",
+			"requires": {
+				"vscode-languageserver-protocol": "3.14.1",
+				"vscode-uri": "^1.0.6"
+			}
+		},
+		"vscode-languageserver-protocol": {
+			"version": "3.14.1",
+			"resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.14.1.tgz",
+			"integrity": "sha512-IL66BLb2g20uIKog5Y2dQ0IiigW0XKrvmWiOvc0yXw80z3tMEzEnHjaGAb3ENuU7MnQqgnYJ1Cl2l9RvNgDi4g==",
+			"requires": {
+				"vscode-jsonrpc": "^4.0.0",
+				"vscode-languageserver-types": "3.14.0"
+			}
+		},
+		"vscode-languageserver-types": {
+			"version": "3.14.0",
+			"resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.14.0.tgz",
+			"integrity": "sha512-lTmS6AlAlMHOvPQemVwo3CezxBp0sNB95KNPkqp3Nxd5VFEnuG1ByM0zlRWos0zjO3ZWtkvhal0COgiV1xIA4A=="
+		},
+		"vscode-uri": {
+			"version": "1.0.6",
+			"resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-1.0.6.tgz",
+			"integrity": "sha512-sLI2L0uGov3wKVb9EB+vIQBl9tVP90nqRvxSoJ35vI3NjxE8jfsE5DSOhWgSunHSZmKS4OCi2jrtfxK7uyp2ww=="
+		}
+	}
+}
diff --git a/vscode-sbt-scala/server/package.json b/vscode-sbt-scala/server/package.json
new file mode 100644
index 000000000..d37750e03
--- /dev/null
+++ b/vscode-sbt-scala/server/package.json
@@ -0,0 +1,24 @@
+{
+	"name": "vscode-sbt-scala",
+	"displayName": "Scala (sbt)",
+	"version": "0.0.1",
+	"author": "Lightbend, Inc.",
+	"license": "BSD-3-Clause",
+	"publisher": "lightbend",
+	"description": "Relay server to sbt server.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/sbt/sbt"
+	},
+	"engines": {
+		"node": "*"
+	},
+	"dependencies": {
+		"vscode-languageserver": "^5.2.1"
+	},
+	"scripts": {
+		"installServer": "installServerIntoExtension ../client ./package.json ./tsconfig.json",
+		"compile": "installServerIntoExtension ../client ./package.json ./tsconfig.json && tsc -p .",
+		"watch": "installServerIntoExtension ../client ./package.json ./tsconfig.json && tsc -w -p ."
+	}
+}
diff --git a/vscode-sbt-scala/server/src/server.ts b/vscode-sbt-scala/server/src/server.ts
new file mode 100644
index 000000000..8404c7b74
--- /dev/null
+++ b/vscode-sbt-scala/server/src/server.ts
@@ -0,0 +1,48 @@
+'use strict';
+
+import * as path from 'path';
+import * as url from 'url';
+import * as net from 'net';
+let fs = require('fs'),
+  os = require('os'),
+  stdin = process.stdin,
+  stdout = process.stdout;
+
+let socket = new net.Socket();
+socket.on('data', (chunk: any) => {
+  // send it back to stdout
+  stdout.write(chunk);
+}).on('end', () => {
+  stdin.pause();
+});
+connectSocket(socket);
+
+stdin.resume();
+stdin.on('data', (chunk: any) => {
+  socket.write(chunk);
+}).on('end', () => {
+  socket.end();
+});
+
+function connectSocket(socket: net.Socket):　net.Socket {
+  let u = discoverUrl();
+  // let socket = net.Socket();
+  if (u.protocol == 'tcp:') {
+    socket.connect(+u.port, '127.0.0.1');
+  } else if (u.protocol == 'local:' && os.platform() == 'win32') {
+    let pipePath = '\\\\.\\pipe\\' + u.hostname;
+    socket.connect(pipePath);
+  } else if (u.protocol == 'local:') {
+    socket.connect(u.path);
+  } else {
+    throw 'Unknown protocol ' + u.protocol;
+  }
+  return socket;
+}
+
+// the port file is hardcoded to a particular location relative to the build.
+function discoverUrl(): url.Url {
+  let pf = path.join(process.cwd(), 'project', 'target', 'active.json');
+  let portfile = JSON.parse(fs.readFileSync(pf));
+  return url.parse(portfile.uri);
+}
diff --git a/vscode-sbt-scala/server/tsconfig.json b/vscode-sbt-scala/server/tsconfig.json
new file mode 100644
index 000000000..1ae7a021a
--- /dev/null
+++ b/vscode-sbt-scala/server/tsconfig.json
@@ -0,0 +1,17 @@
+{
+	"compilerOptions": {
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitAny": true,
+		"noImplicitReturns": true,		
+		"target": "es6",
+		"module": "commonjs",
+		"moduleResolution": "node",
+		"sourceMap": true,
+		"lib" : [ "es2016" ],
+		"outDir": "../client/server"
+	},
+	"exclude": [
+		"node_modules"
+	]
+}
\ No newline at end of file
diff --git a/zinc-lm-integration/src/main/java/xsbti/compile/ZincBridgeProvider.java b/zinc-lm-integration/src/main/java/xsbti/compile/ZincBridgeProvider.java
new file mode 100644
index 000000000..c0c1ca4e3
--- /dev/null
+++ b/zinc-lm-integration/src/main/java/xsbti/compile/ZincBridgeProvider.java
@@ -0,0 +1,83 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package xsbti.compile;
+
+import sbt.internal.inc.ZincComponentCompiler;
+import sbt.internal.inc.ZincComponentManager;
+import sbt.librarymanagement.DependencyResolution;
+import sbt.librarymanagement.Resolver;
+import scala.None$;
+import xsbti.ComponentProvider;
+import xsbti.GlobalLock;
+import xsbti.Logger;
+
+import java.io.File;
+
+public interface ZincBridgeProvider {
+  /**
+   * Returns an ivy resolver to resolve dependencies locally in the default `.ivy2/local`.
+   *
+   * <p>For those users interested in using Internet resolvers like Maven Central, you can
+   * instantiate them via {@link Resolver#mavenCentral()} et al.
+   *
+   * @return A local ivy resolver.
+   */
+  public static Resolver getLocalResolver() {
+    return ZincComponentCompiler.LocalResolver();
+  }
+
+  /**
+   * Returns a global lock that does nothing but calling the callable to synchronize across threads.
+   * The lock file is used to resolve and download dependencies via ivy.
+   *
+   * <p>This operation is necessary to invoke {@link ZincBridgeProvider#getProvider(File,
+   * GlobalLock, ComponentProvider, IvyConfiguration, Logger)}.
+   *
+   * @return A default global lock.
+   */
+  public static GlobalLock getDefaultLock() {
+    return ZincComponentCompiler.getDefaultLock();
+  }
+
+  /**
+   * Returns a default component provider that retrieves and installs component managers (like the
+   * compiled bridge sources) under a given target directory.
+   *
+   * <p>This is the most simplistic implementation of a component provider. If you need more
+   * advanced feature, like management of component via proxies (for companies) or access to other
+   * servers, you need to implement your own component provider.
+   *
+   * @param componentsRoot The directory in which components will be installed and retrieved.
+   * @return A default component provider.
+   */
+  public static ComponentProvider getDefaultComponentProvider(File componentsRoot) {
+    return ZincComponentCompiler.getDefaultComponentProvider(componentsRoot);
+  }
+
+  /**
+   * Get a compiler bridge provider that allows the user to fetch Scala and a compiled bridge.
+   *
+   * @param scalaJarsTarget The place where the downloaded Scala jars should be placed.
+   * @param lock The lock file used internally by Ivy to synchronize the dependency resolution.
+   * @param componentProvider A provider capable of retrieving existing components or installing new
+   *     ones. The component provider manages compiled bridge sources.
+   * @param dependencyResolution The library management module to use to retrieve the bridge.
+   * @param logger The logger.
+   * @return A compiler bridge provider capable of fetching scala jars and the compiler bridge.
+   */
+  public static CompilerBridgeProvider getProvider(
+      File scalaJarsTarget,
+      GlobalLock lock,
+      ComponentProvider componentProvider,
+      DependencyResolution dependencyResolution,
+      Logger logger) {
+    ZincComponentManager manager =
+        new ZincComponentManager(lock, componentProvider, None$.empty(), logger);
+    return ZincComponentCompiler.interfaceProvider(manager, dependencyResolution, scalaJarsTarget);
+  }
+}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/Errors.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/Errors.scala
new file mode 100644
index 000000000..35b344e6a
--- /dev/null
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/Errors.scala
@@ -0,0 +1,23 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.inc
+
+class InvalidComponent(msg: String, cause: Throwable) extends RuntimeException(msg, cause) {
+  def this(msg: String) = this(msg, null)
+}
+
+final class MissingScalaJar(msg: String, cause: Throwable) extends RuntimeException(msg, cause) {
+  def this(msg: String) = this(msg, null)
+}
+
+object MissingScalaJar {
+  def missingTemplate(missing: String): String =
+    s"The $missing could not be found in your cache nor downloaded from the Internet."
+  def compiler: MissingScalaJar = new MissingScalaJar(missingTemplate("Scala compiler"))
+  def library: MissingScalaJar = new MissingScalaJar(missingTemplate("Scala library"))
+}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/IfMissing.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/IfMissing.scala
new file mode 100644
index 000000000..91aeb583c
--- /dev/null
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/IfMissing.scala
@@ -0,0 +1,21 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.inc
+
+sealed trait IfMissing
+
+object IfMissing {
+  def fail: IfMissing = Fail
+
+  /** f is expected to call ZincComponentManager.define.  */
+  def define(useSecondaryCache: Boolean, f: => Unit): IfMissing = new Define(useSecondaryCache, f)
+  object Fail extends IfMissing
+  final class Define(val useSecondaryCache: Boolean, define: => Unit) extends IfMissing {
+    def run(): Unit = define
+  }
+}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala
new file mode 100644
index 000000000..d3c0f00b8
--- /dev/null
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala
@@ -0,0 +1,35 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.inc
+
+import java.util.Properties
+
+/** Defines utilities to load Java properties from the JVM. */
+private[inc] object ResourceLoader {
+  def getPropertiesFor(resource: String): Properties = {
+    val properties = new Properties
+    val propertiesStream = getClass.getResource(resource).openStream
+    try {
+      properties.load(propertiesStream)
+    } finally propertiesStream.close()
+    properties
+  }
+
+  def getSafePropertiesFor(resource: String, classLoader: ClassLoader): Properties = {
+    val properties = new Properties
+    val propertiesStream = classLoader.getResourceAsStream(resource)
+    if (propertiesStream ne null) {
+      try {
+        properties.load(propertiesStream)
+      } catch {
+        case _: Exception =>
+      } finally propertiesStream.close()
+    }
+    properties
+  }
+}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala
new file mode 100644
index 000000000..de023d3c1
--- /dev/null
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala
@@ -0,0 +1,336 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package inc
+
+import sbt.internal.inc.classpath.ClasspathUtil
+import sbt.internal.librarymanagement._
+import sbt.internal.util.{ BufferedLogger, FullLogger }
+import sbt.io.IO
+import sbt.librarymanagement._
+import sbt.librarymanagement.syntax._
+import sbt.util.InterfaceUtil.{ toSupplier => f0 }
+import xsbti.ArtifactInfo._
+import xsbti.compile.{
+  ClasspathOptionsUtil,
+  CompilerBridgeProvider,
+  ScalaInstance => XScalaInstance
+}
+import xsbti.{ ComponentProvider, GlobalLock, Logger }
+
+import java.io.File
+import java.nio.file.{ Files, Path }
+import java.util.concurrent.Callable
+
+private[sbt] object ZincComponentCompiler {
+  final val binSeparator = "-bin_"
+  final val javaClassVersion = System.getProperty("java.class.version")
+
+  private[inc] final val sbtOrgTemp = JsonUtil.sbtOrgTemp
+  private[inc] final val modulePrefixTemp = "temp-module-"
+
+  private val lock: AnyRef = new {}
+
+  /** Defines the internal implementation of a bridge provider. */
+  private class ZincCompilerBridgeProvider(
+      userProvidedBridgeSources: Option[ModuleID],
+      manager: ZincComponentManager,
+      dependencyResolution: DependencyResolution,
+      scalaJarsTarget: File
+  ) extends CompilerBridgeProvider {
+
+    /**
+     * Defines a richer interface for Scala users that want to pass in an explicit module id.
+     *
+     * Note that this method cannot be defined in [[CompilerBridgeProvider]] because [[ModuleID]]
+     * is a Scala-defined class to which the compiler bridge cannot depend on.
+     */
+    def compiledBridge(
+        bridgeSources: ModuleID,
+        scalaInstance: XScalaInstance,
+        logger: Logger,
+    ): File = lock.synchronized {
+      val raw = new RawCompiler(scalaInstance, ClasspathOptionsUtil.auto, logger)
+      val zinc =
+        new ZincComponentCompiler(raw, manager, dependencyResolution, bridgeSources, logger)
+      logger.debug(f0(s"Getting $bridgeSources for Scala ${scalaInstance.version}"))
+      zinc.compiledBridgeJar
+    }
+
+    override def fetchCompiledBridge(scalaInstance: XScalaInstance, logger: Logger): File = {
+      val scalaVersion = scalaInstance.actualVersion()
+      val bridgeSources = userProvidedBridgeSources
+        .getOrElse(ZincLmUtil.getDefaultBridgeSourceModule(scalaVersion))
+      compiledBridge(bridgeSources, scalaInstance, logger)
+    }
+
+    // internal representation of Scala artifacts
+    private case class ScalaArtifacts(
+        compilerJar: Path,
+        libraryJars: Vector[Path],
+        others: Vector[Path]
+    )
+
+    private def getScalaArtifacts(scalaVersion: String, logger: Logger): ScalaArtifacts = {
+      def isPrefixedWith(artifact: Path, prefix: String) =
+        artifact.getFileName.toString.startsWith(prefix)
+
+      val fullLogger = new FullLogger(logger)
+      val CompileConf = Some(Configurations.Compile.name)
+      val dummyModule = ModuleID(JsonUtil.sbtOrgTemp, s"tmp-scala-$scalaVersion", scalaVersion)
+      val scalaLibrary = ModuleID(ScalaOrganization, ScalaLibraryID, scalaVersion)
+      val scalaCompiler = ModuleID(ScalaOrganization, ScalaCompilerID, scalaVersion)
+      val dependencies = Vector(scalaLibrary, scalaCompiler).map(_.withConfigurations(CompileConf))
+      val wrapper = dummyModule.withConfigurations(CompileConf)
+      val moduleDescriptorConfiguration =
+        ModuleDescriptorConfiguration(wrapper, ModuleInfo(wrapper.name))
+          .withDependencies(dependencies)
+          .withConfigurations(ZincLMHelper.DefaultConfigurations)
+
+      val moduleDescriptor = dependencyResolution.moduleDescriptor(moduleDescriptorConfiguration)
+      val allArtifacts = ZincLMHelper.update(
+        dependencyResolution,
+        moduleDescriptor,
+        scalaJarsTarget,
+        noSource = true,
+        fullLogger,
+        "Scala compiler and library",
+      )
+      val isScalaCompiler = (f: Path) => isPrefixedWith(f, "scala-compiler-")
+      val isScalaLibrary = (f: Path) => isPrefixedWith(f, "scala-library-")
+      val maybeScalaCompiler = allArtifacts.find(isScalaCompiler)
+      val maybeScalaLibrary = allArtifacts.find(isScalaLibrary)
+      val others = allArtifacts.filterNot(a => isScalaCompiler(a) || isScalaLibrary(a))
+      val scalaCompilerJar = maybeScalaCompiler.getOrElse(throw MissingScalaJar.compiler)
+      val scalaLibraryJar = maybeScalaLibrary.getOrElse(throw MissingScalaJar.library)
+      ScalaArtifacts(scalaCompilerJar, Vector(scalaLibraryJar), others)
+    }
+
+    override def fetchScalaInstance(scalaVersion: String, logger: Logger): XScalaInstance = {
+      val scalaArtifacts = getScalaArtifacts(scalaVersion, logger)
+      val scalaCompilerJar = scalaArtifacts.compilerJar
+      val scalaLibraryJars = scalaArtifacts.libraryJars
+      val jarsToLoad: Vector[Path] =
+        (Vector(scalaCompilerJar) ++ scalaLibraryJars ++ scalaArtifacts.others)
+      assert(
+        jarsToLoad.forall(Files.exists(_)),
+        "One or more jar(s) in the Scala instance do not exist."
+      )
+      val loaderLibraryOnly = ClasspathUtil.toLoader(scalaLibraryJars)
+      val jarsToLoad2 = jarsToLoad diff scalaLibraryJars
+      val loader = ClasspathUtil.toLoader(jarsToLoad2, loaderLibraryOnly)
+      val properties = ResourceLoader.getSafePropertiesFor("compiler.properties", loader)
+      val loaderVersion = Option(properties.getProperty("version.number"))
+      val scalaV = loaderVersion.getOrElse("unknown")
+      val allJars = jarsToLoad.map(_.toFile).toArray
+      new ScalaInstance(
+        scalaV,
+        loader,
+        loader,
+        loaderLibraryOnly,
+        scalaLibraryJars.map(_.toFile).toArray,
+        allJars,
+        allJars,
+        loaderVersion,
+      )
+    }
+  }
+
+  // Used by ZincUtil.
+  def interfaceProvider(
+      compilerBridgeSource: ModuleID,
+      manager: ZincComponentManager,
+      dependencyResolution: DependencyResolution,
+      scalaJarsTarget: File,
+  ): CompilerBridgeProvider = {
+    val bridgeSources = Some(compilerBridgeSource)
+    new ZincCompilerBridgeProvider(bridgeSources, manager, dependencyResolution, scalaJarsTarget)
+  }
+
+  def interfaceProvider(
+      manager: ZincComponentManager,
+      dependencyResolution: DependencyResolution,
+      scalaJarsTarget: File,
+  ): CompilerBridgeProvider =
+    new ZincCompilerBridgeProvider(None, manager, dependencyResolution, scalaJarsTarget)
+
+  private final val LocalIvy =
+    (sys.props.get("sbt.ivy.home") match {
+      case Some(home) =>
+        if (home.endsWith("/")) home
+        else home + "/"
+      case _ => s"$${user.home}/.ivy2/"
+    }) + "local/" + Resolver.localBasePattern
+
+  final val LocalResolver: Resolver = {
+    val toUse = Vector(LocalIvy)
+    val ivyPatterns = Patterns().withIsMavenCompatible(false)
+    val finalPatterns = ivyPatterns.withIvyPatterns(toUse).withArtifactPatterns(toUse)
+    FileRepository("local", Resolver.defaultFileConfiguration, finalPatterns)
+  }
+
+  def getDefaultLock: GlobalLock = new GlobalLock {
+    override def apply[T](file: File, callable: Callable[T]): T = callable.call()
+  }
+
+  /** Defines a default component provider that manages the component in a given directory. */
+  private final class DefaultComponentProvider(targetDir: File) extends ComponentProvider {
+    import sbt.io.syntax._
+    private val LockFile = targetDir / "lock"
+    override def lockFile(): File = LockFile
+    override def componentLocation(id: String): File = targetDir / id
+    override def component(componentID: String): Array[File] =
+      IO.listFiles(targetDir / componentID)
+    override def defineComponent(componentID: String, files: Array[File]): Unit =
+      files.foreach(f => IO.copyFile(f, targetDir / componentID / f.getName))
+    override def addToComponent(componentID: String, files: Array[File]): Boolean = {
+      defineComponent(componentID, files)
+      true
+    }
+  }
+
+  def getDefaultComponentProvider(targetDir: File): ComponentProvider = {
+    require(targetDir.isDirectory)
+    new DefaultComponentProvider(targetDir)
+  }
+
+}
+
+/**
+ * Component compiler which is able to to retrieve the compiler bridge sources
+ * `sourceModule` using a `DependencyResolution` instance.
+ * The compiled classes are cached using the provided component manager according
+ * to the actualVersion field of the RawCompiler.
+ */
+private[inc] class ZincComponentCompiler(
+    compiler: RawCompiler,
+    manager: ZincComponentManager,
+    dependencyResolution: DependencyResolution,
+    bridgeSources: ModuleID,
+    log: sbt.util.Logger
+) {
+  private final val buffered = new BufferedLogger(FullLogger(log))
+
+  def compiledBridgeJar: File = {
+    val jarBinaryName = createBridgeSourcesID(bridgeSources)
+    manager.file(jarBinaryName)(IfMissing.define(true, compileAndInstall(jarBinaryName)))
+  }
+
+  /**
+   * Returns the id for the compiler interface component.
+   *
+   * The ID contains the following parts:
+   *   - The organization, name and revision.
+   *   - The bin separator to make clear the jar represents binaries.
+   *   - The Scala version for which the compiler interface is meant to.
+   *   - The JVM class version.
+   *
+   * Example: `"org.scala-sbt-compiler-bridge-1.0.0-bin_2.11.7__50.0"`.
+   *
+   * @param sources The moduleID representing the compiler bridge sources.
+   * @return The complete jar identifier for the bridge sources.
+   */
+  private def createBridgeSourcesID(sources: ModuleID): String = {
+    import ZincComponentCompiler.{ binSeparator, javaClassVersion }
+    val id = s"${sources.organization}-${sources.name}-${sources.revision}"
+    val scalaVersion = compiler.scalaInstance.actualVersion()
+    s"$id$binSeparator${scalaVersion}__$javaClassVersion"
+  }
+
+  /**
+   * Resolves the compiler bridge sources, compiles them and installs the sbt component
+   * in the local filesystem to make sure that it's reused the next time is required.
+   *
+   * @param compilerBridgeId The identifier for the compiler bridge sources.
+   */
+  private def compileAndInstall(compilerBridgeId: String): Unit = {
+    val moduleForBridge = dependencyResolution.wrapDependencyInModule(bridgeSources)
+    IO.withTemporaryDirectory { binaryDirectory =>
+      val target = new File(binaryDirectory, s"$compilerBridgeId.jar")
+      buffered.bufferQuietly {
+        IO.withTemporaryDirectory { retrieveDirectory =>
+          val allArtifacts = ZincLMHelper.update(
+            dependencyResolution,
+            moduleForBridge,
+            retrieveDirectory,
+            noSource = false,
+            buffered,
+            s"compiler bridge sources $moduleForBridge",
+          )
+          val (srcs, xsbtiJars) =
+            allArtifacts.partition(_.getFileName.toString.endsWith("-sources.jar"))
+          val toCompileID = bridgeSources.name
+          AnalyzingCompiler.compileSources(
+            srcs,
+            target.toPath,
+            xsbtiJars,
+            toCompileID,
+            compiler,
+            log
+          )
+          manager.define(compilerBridgeId, Seq(target))
+        }
+      }
+    }
+  }
+
+}
+
+private object ZincLMHelper {
+  private final val warningConf = UnresolvedWarningConfiguration()
+  private final val defaultRetrievePattern = Resolver.defaultRetrievePattern
+
+  private[inc] final val DefaultConfigurations: Vector[Configuration] =
+    Vector(Configurations.Component, Configurations.Compile)
+
+  private[inc] def update(
+      dependencyResolution: DependencyResolution,
+      module: ModuleDescriptor,
+      retrieveDirectory: File,
+      noSource: Boolean,
+      logger: sbt.util.Logger,
+      desc: String,
+  ): Vector[Path] = {
+    val updateConfiguration = newUpdateConfiguration(retrieveDirectory, noSource)
+    val dependencies = prettyPrintDependency(module)
+    logger.info(s"Attempting to fetch $dependencies.")
+    dependencyResolution.update(module, updateConfiguration, warningConf, logger) match {
+      case Left(uw) =>
+        logger.debug(s"couldn't retrieve module(s) ${prettyPrintDependency(module)}.")
+        val unretrievedMessage = s"The $desc could not be retrieved."
+        val unresolvedLines = UnresolvedWarning.unresolvedWarningLines.showLines(uw).mkString("\n")
+        throw new InvalidComponent(s"$unretrievedMessage\n$unresolvedLines")
+      case Right(updateReport) =>
+        val allFiles = updateReport.allFiles.map(_.toPath)
+        logger.debug(s"Files retrieved for ${prettyPrintDependency(module)}:")
+        logger.debug(allFiles.mkString(", "))
+        allFiles
+    }
+  }
+
+  private def newUpdateConfiguration(targetDir: File, noSource: Boolean): UpdateConfiguration = {
+    val retrieve = RetrieveConfiguration()
+      .withRetrieveDirectory(targetDir)
+      .withOutputPattern(defaultRetrievePattern)
+    val logLevel = UpdateLogging.DownloadOnly
+    val defaultExcluded = Set("doc")
+    val finalExcluded = if (noSource) defaultExcluded + "src" else defaultExcluded
+    val artifactFilter = ArtifactTypeFilter.forbid(finalExcluded)
+    UpdateConfiguration()
+      .withRetrieveManaged(retrieve)
+      .withLogging(logLevel)
+      .withArtifactFilter(artifactFilter)
+  }
+
+  private def prettyPrintDependency(module: ModuleDescriptor): String = {
+    module.directDependencies
+      .map(m => s"${m.organization}:${m.name}:${m.revision}") // like ModuleIDExtra.toStringImpl
+      .mkString(", ")
+  }
+}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentManager.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentManager.scala
new file mode 100644
index 000000000..db5525a1a
--- /dev/null
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincComponentManager.scala
@@ -0,0 +1,124 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt
+package internal
+package inc
+
+import java.io.File
+import java.util.concurrent.Callable
+
+import sbt.internal.util.FullLogger
+import sbt.io.IO
+import xsbti._
+import xsbti.ArtifactInfo.SbtOrganization
+
+/**
+ * A component manager provides access to the pieces of zinc that are distributed as components.
+ * Compiler bridge is distributed as a source jar so that it can be compiled against a specific
+ * version of Scala.
+ *
+ * The component manager provides services to install and retrieve components to the local
+ * filesystem. This is used for compiled source jars so that the compilation need not be repeated
+ * for other projects on the same machine.
+ */
+class ZincComponentManager(
+    globalLock: GlobalLock,
+    provider: ComponentProvider,
+    secondaryCacheDir: Option[File],
+    log0: Logger,
+) {
+  val log = new FullLogger(log0)
+
+  /** Get all of the files for component 'id', throwing an exception if no files exist for the component. */
+  def files(id: String)(ifMissing: IfMissing): Iterable[File] = {
+    def notFound = invalid(s"Could not find required component '$id'")
+    def getOrElse(orElse: => Iterable[File]): Iterable[File] = {
+      val existing = provider.component(id)
+      // log.info(s"[zinc-lm] existing = ${existing.toList}")
+      if (existing.isEmpty) orElse
+      else existing
+    }
+
+    def createAndCache = {
+      ifMissing match {
+        case IfMissing.Fail => notFound
+        case d: IfMissing.Define =>
+          d.run() // this is expected to have called define.
+          if (d.useSecondaryCache) {
+            cacheToSecondaryCache(id)
+          }
+          getOrElse(notFound)
+      }
+    }
+
+    def fromSecondary: Iterable[File] = {
+      lockSecondaryCache {
+        update(id)
+        getOrElse(createAndCache)
+      }.getOrElse(notFound)
+    }
+
+    lockLocalCache(getOrElse(fromSecondary))
+  }
+
+  /** Get the file for component 'id',
+   *  throwing an exception if no files or multiple files exist for the component. */
+  def file(id: String)(ifMissing: IfMissing): File = {
+    files(id)(ifMissing).toList match {
+      case x :: Nil => x
+      case xs       => invalid(s"Expected single file for component '$id', found: ${xs.mkString(", ")}")
+    }
+  }
+
+  /** Associate a component id to a series of jars. */
+  def define(id: String, files: Iterable[File]): Unit =
+    lockLocalCache(provider.defineComponent(id, files.toSeq.toArray))
+
+  /** This is used to lock the local cache in project/boot/.
+   *  By checking the local cache first, we can avoid grabbing a global lock. */
+  private def lockLocalCache[T](action: => T): T = lock(provider.lockFile)(action)
+
+  /** This is used to ensure atomic access to components in the global Ivy cache. */
+  private def lockSecondaryCache[T](action: => T): Option[T] =
+    secondaryCacheDir.map(dir => lock(new File(dir, ".sbt.cache.lock"))(action))
+
+  private def lock[T](file: File)(action: => T): T =
+    globalLock(file, new Callable[T] { def call = action })
+
+  private def invalid(msg: String) = throw new InvalidComponent(msg)
+
+  /** Retrieve the file for component 'id' from the secondary cache. */
+  private def update(id: String): Unit = {
+    secondaryCacheDir.foreach { dir =>
+      val file = secondaryCacheFile(id, dir)
+      if (file.exists) {
+        define(id, Seq(file))
+      }
+    }
+  }
+
+  /** Install the files for component 'id' to the secondary cache. */
+  private def cacheToSecondaryCache(id: String): Unit = {
+    val fromPrimaryCache = file(id)(IfMissing.fail)
+    secondaryCacheDir.foreach { dir =>
+      IO.copyFile(fromPrimaryCache, secondaryCacheFile(id, dir))
+    }
+  }
+
+  private def secondaryCacheFile(id: String, dir: File): File = {
+    new File(new File(dir, SbtOrganization), s"$id-${ZincComponentManager.stampedVersion}.jar")
+  }
+}
+
+object ZincComponentManager {
+  lazy val (version, timestamp) = {
+    val properties = ResourceLoader.getPropertiesFor("/incrementalcompiler.version.properties")
+    (properties.getProperty("version"), properties.getProperty("timestamp"))
+  }
+  lazy val stampedVersion = s"${version}_$timestamp"
+}
diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala
new file mode 100644
index 000000000..3205052ef
--- /dev/null
+++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala
@@ -0,0 +1,103 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.inc
+
+import java.io.File
+import sbt.internal.inc.classpath.ClassLoaderCache
+import sbt.internal.util.MessageOnlyException
+import sbt.librarymanagement.{
+  DependencyResolution,
+  ModuleID,
+  ScalaArtifacts,
+  UnresolvedWarningConfiguration,
+  UpdateConfiguration
+}
+import sbt.librarymanagement.syntax._
+import xsbti.ArtifactInfo.SbtOrganization
+import xsbti._
+import xsbti.compile.{ ClasspathOptions, ScalaInstance => XScalaInstance }
+
+object ZincLmUtil {
+
+  /**
+   * Instantiate a Scala compiler that is instrumented to analyze dependencies.
+   * This Scala compiler is useful to create your own instance of incremental
+   * compilation.
+   */
+  def scalaCompiler(
+      scalaInstance: XScalaInstance,
+      classpathOptions: ClasspathOptions,
+      globalLock: GlobalLock,
+      componentProvider: ComponentProvider,
+      secondaryCacheDir: Option[File],
+      dependencyResolution: DependencyResolution,
+      compilerBridgeSource: ModuleID,
+      scalaJarsTarget: File,
+      classLoaderCache: Option[ClassLoaderCache],
+      log: Logger
+  ): AnalyzingCompiler = {
+    val compilerBridgeProvider = ZincComponentCompiler.interfaceProvider(
+      compilerBridgeSource,
+      new ZincComponentManager(globalLock, componentProvider, secondaryCacheDir, log),
+      dependencyResolution,
+      scalaJarsTarget,
+    )
+    new AnalyzingCompiler(
+      scalaInstance,
+      compilerBridgeProvider,
+      classpathOptions,
+      _ => (),
+      classLoaderCache
+    )
+  }
+
+  def fetchDefaultBridgeModule(
+      scalaVersion: String,
+      dependencyResolution: DependencyResolution,
+      updateConfiguration: UpdateConfiguration,
+      warningConfig: UnresolvedWarningConfiguration,
+      logger: Logger
+  ): File = {
+    val bridgeModule = getDefaultBridgeModule(scalaVersion)
+    val descriptor = dependencyResolution.wrapDependencyInModule(bridgeModule)
+    dependencyResolution
+      .update(descriptor, updateConfiguration, warningConfig, logger)
+      .toOption
+      .flatMap { report =>
+        val jars = report.select(
+          configurationFilter(Compile.name),
+          moduleFilter(bridgeModule.organization, bridgeModule.name, bridgeModule.revision),
+          artifactFilter(`extension` = "jar", classifier = "")
+        )
+        if (jars.size > 1)
+          sys.error(s"There should be only one jar for $bridgeModule but found $jars")
+        else jars.headOption
+      }
+      .getOrElse(throw new MessageOnlyException(s"Missing $bridgeModule"))
+  }
+
+  def getDefaultBridgeModule(scalaVersion: String): ModuleID = {
+    if (ScalaArtifacts.isScala3(scalaVersion)) {
+      ModuleID(ScalaArtifacts.Organization, "scala3-sbt-bridge", scalaVersion)
+        .withConfigurations(Some(Compile.name))
+    } else {
+      val compilerBridgeId = scalaVersion match {
+        case sc if sc startsWith "2.10." => "compiler-bridge_2.10"
+        case sc if sc startsWith "2.11." => "compiler-bridge_2.11"
+        case sc if sc startsWith "2.12." => "compiler-bridge_2.12"
+        case "2.13.0-M1"                 => "compiler-bridge_2.12"
+        case _                           => "compiler-bridge_2.13"
+      }
+      ModuleID(SbtOrganization, compilerBridgeId, ZincComponentManager.version)
+        .withConfigurations(Some(Compile.name))
+    }
+  }
+
+  def getDefaultBridgeSourceModule(scalaVersion: String): ModuleID =
+    getDefaultBridgeModule(scalaVersion).sources()
+}
diff --git a/zinc-lm-integration/src/test/scala/sbt/internal/inc/IvyBridgeProviderSpecification.scala b/zinc-lm-integration/src/test/scala/sbt/internal/inc/IvyBridgeProviderSpecification.scala
new file mode 100644
index 000000000..a4c30bf0c
--- /dev/null
+++ b/zinc-lm-integration/src/test/scala/sbt/internal/inc/IvyBridgeProviderSpecification.scala
@@ -0,0 +1,99 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.inc
+
+import java.io.File
+import java.net.URLClassLoader
+
+import sbt.io.IO
+import sbt.io.syntax._
+import sbt.librarymanagement._
+import sbt.librarymanagement.ivy._
+import sbt.util.Logger
+import xsbti.compile.CompilerBridgeProvider
+import org.scalatest._
+
+/**
+ * Base class for test suites that must be able to fetch and compile the compiler bridge.
+ *
+ * This is a very good example on how to instantiate the compiler bridge provider.
+ */
+abstract class IvyBridgeProviderSpecification
+    extends fixture.FlatSpec
+    with fixture.TestDataFixture
+    with Matchers {
+  def currentBase: File = new File(".")
+  def currentTarget: File = currentBase / "target" / "ivyhome"
+  def currentManaged: File = currentBase / "target" / "lib_managed"
+  def secondaryCacheDirectory: File = file("target").getAbsoluteFile / "zinc-components"
+
+  val resolvers = Array(
+    ZincComponentCompiler.LocalResolver: Resolver,
+    Resolver.mavenCentral: Resolver,
+    MavenRepository(
+      "scala-integration",
+      "https://scala-ci.typesafe.com/artifactory/scala-integration/"
+    ): Resolver,
+  )
+
+  private def ivyConfiguration(log: Logger) =
+    getDefaultConfiguration(currentBase, currentTarget, resolvers, log)
+
+  def getZincProvider(bridge: ModuleID, targetDir: File, log: Logger): CompilerBridgeProvider = {
+    val lock = ZincComponentCompiler.getDefaultLock
+    val secondaryCache = Some(secondaryCacheDirectory)
+    val componentProvider = ZincComponentCompiler.getDefaultComponentProvider(targetDir)
+    val manager = new ZincComponentManager(lock, componentProvider, secondaryCache, log)
+    val dependencyResolution = IvyDependencyResolution(ivyConfiguration(log))
+    ZincComponentCompiler.interfaceProvider(bridge, manager, dependencyResolution, currentManaged)
+  }
+
+  def getCompilerBridge(
+      targetDir: File,
+      log: Logger,
+      scalaVersion: String,
+  )(implicit td: TestData): File = {
+    val zincVersion = td.configMap.get("sbt.zinc.version") match {
+      case Some(v: String) => v
+      case _               => throw new IllegalStateException("No zinc version specified")
+    }
+    val bridge0 = ZincLmUtil.getDefaultBridgeSourceModule(scalaVersion)
+    // redefine the compiler bridge version
+    // using the version of zinc used during testing
+    // this way when building with zinc as a source dependency
+    // these specs don't go looking for some SHA-suffixed compiler bridge
+    val bridge1 = bridge0.withRevision(zincVersion)
+    val provider = getZincProvider(bridge1, targetDir, log)
+    val scalaInstance = provider.fetchScalaInstance(scalaVersion, log)
+    val bridge = provider.fetchCompiledBridge(scalaInstance, log)
+    scalaInstance.loader.asInstanceOf[URLClassLoader].close()
+    scalaInstance.loaderLibraryOnly.asInstanceOf[URLClassLoader].close()
+    val target = targetDir / s"target-bridge-$scalaVersion.jar"
+    IO.copyFile(bridge, target)
+    target
+  }
+
+  private def getDefaultConfiguration(
+      baseDirectory: File,
+      ivyHome: File,
+      resolvers0: Array[Resolver],
+      log: xsbti.Logger,
+  ): InlineIvyConfiguration = {
+    val resolvers = resolvers0.toVector
+    val chainResolver = ChainedResolver("zinc-chain", resolvers)
+    InlineIvyConfiguration()
+      .withPaths(IvyPaths(baseDirectory, Some(ivyHome)))
+      .withResolvers(resolvers)
+      .withModuleConfigurations(Vector(ModuleConfiguration("*", chainResolver)))
+      .withLock(None)
+      .withChecksums(Vector.empty)
+      .withResolutionCacheDir(ivyHome / "resolution-cache")
+      .withUpdateOptions(UpdateOptions())
+      .withLog(log)
+  }
+}
diff --git a/zinc-lm-integration/src/test/scala/sbt/internal/inc/ZincComponentCompilerSpec.scala b/zinc-lm-integration/src/test/scala/sbt/internal/inc/ZincComponentCompilerSpec.scala
new file mode 100644
index 000000000..1e0875a7b
--- /dev/null
+++ b/zinc-lm-integration/src/test/scala/sbt/internal/inc/ZincComponentCompilerSpec.scala
@@ -0,0 +1,52 @@
+/*
+ * sbt
+ * Copyright 2011 - 2018, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * Licensed under Apache License 2.0 (see LICENSE)
+ */
+
+package sbt.internal.inc
+
+import sbt.internal.util.ConsoleLogger
+import sbt.io.IO
+
+class ZincComponentCompilerSpec extends IvyBridgeProviderSpecification {
+  val scala2105 = "2.10.5"
+  val scala2106 = "2.10.6"
+  val scala2118 = "2.11.8"
+  val scala21111 = "2.11.11"
+  val scala2121 = "2.12.1"
+  val scala2122 = "2.12.2"
+  val scala2123 = "2.12.3"
+  val scala2130 = "2.13.0"
+  val scala2131 = "2.13.1"
+
+  def isJava8: Boolean = sys.props("java.specification.version") == "1.8"
+
+  val logger = ConsoleLogger()
+
+  it should "compile the bridge for Scala 2.10.5 and 2.10.6" in { implicit td =>
+    if (isJava8) {
+      IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2105) should exist)
+      IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2106) should exist)
+    } else ()
+  }
+
+  it should "compile the bridge for Scala 2.11.8 and 2.11.11" in { implicit td =>
+    if (isJava8) {
+      IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2118) should exist)
+      IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala21111) should exist)
+    } else ()
+  }
+
+  it should "compile the bridge for Scala 2.12.2" in { implicit td =>
+    IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2121) should exist)
+    IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2122) should exist)
+    IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2123) should exist)
+  }
+
+  it should "compile the bridge for Scala 2.13" in { implicit td =>
+    IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2130) should exist)
+    IO.withTemporaryDirectory(t => getCompilerBridge(t, logger, scala2131) should exist)
+  }
+}