diff --git a/src/goEnvironmentStatus.ts b/src/goEnvironmentStatus.ts
index 554fa0f..b52c1f2 100644
--- a/src/goEnvironmentStatus.ts
+++ b/src/goEnvironmentStatus.ts
@@ -277,6 +277,16 @@
 // PATH value cached before addGoRuntimeBaseToPath modified.
 let defaultPathEnv = '';
 
+function pathEnvVarName(): string|undefined {
+	if (process.env.hasOwnProperty('PATH')) {
+		return 'PATH';
+	} else if (process.platform === 'win32' && process.env.hasOwnProperty('Path')) {
+		return 'Path';
+	} else {
+		return;
+	}
+}
+
 // addGoRuntimeBaseToPATH adds the given path to the front of the PATH environment variable.
 // It removes duplicates.
 // TODO: can we avoid changing PATH but utilize toolExecutionEnv?
@@ -285,12 +295,8 @@
 		return;
 	}
 
-	let pathEnvVar: string;
-	if (process.env.hasOwnProperty('PATH')) {
-		pathEnvVar = 'PATH';
-	} else if (process.platform === 'win32' && process.env.hasOwnProperty('Path')) {
-		pathEnvVar = 'Path';
-	} else {
+	const pathEnvVar = pathEnvVarName();
+	if (!pathEnvVar) {
 		return;
 	}
 
@@ -331,14 +337,32 @@
 	process.env[pathEnvVar] = pathVars.join(path.delimiter);
 }
 
+// Clear terminal PATH environment modification previously installed
+// using addGoRuntimeBaseToPATH.
+// In particular, changes to vscode.EnvironmentVariableCollection persist across
+// vscode sessions, so when we decide not to mutate PATH, we need to clear
+// the preexisting changes.
+export function clearGoRuntimeBaseFromPATH() {
+	if (terminalCreationListener) {
+		const l = terminalCreationListener;
+		terminalCreationListener = undefined;
+		l.dispose();
+	}
+	const pathEnvVar = pathEnvVarName();
+	if (!pathEnvVar) {
+		return;
+	}
+	environmentVariableCollection?.delete(pathEnvVar);
+}
+
 /**
  * update the PATH variable in the given terminal to default to the currently selected Go
  */
 export async function updateIntegratedTerminal(terminal: vscode.Terminal): Promise<void> {
 	if (!terminal) { return; }
 	const gorootBin = path.join(getCurrentGoRoot(), 'bin');
-	const defaultGoRuntimeBin = path.dirname(getBinPathFromEnvVar('go', defaultPathEnv, false));
-	if (gorootBin === defaultGoRuntimeBin) {
+	const defaultGoRuntime = getBinPathFromEnvVar('go', defaultPathEnv, false);
+	if (defaultGoRuntime && gorootBin === path.dirname(defaultGoRuntime)) {
 		return;
 	}
 
diff --git a/src/goInstallTools.ts b/src/goInstallTools.ts
index 759cd3b..25ddfe1 100644
--- a/src/goInstallTools.ts
+++ b/src/goInstallTools.ts
@@ -12,7 +12,7 @@
 import util = require('util');
 import vscode = require('vscode');
 import { toolExecutionEnvironment, toolInstallationEnvironment } from './goEnv';
-import { addGoRuntimeBaseToPATH, initGoStatusBar } from './goEnvironmentStatus';
+import { addGoRuntimeBaseToPATH, clearGoRuntimeBaseFromPATH, initGoStatusBar } from './goEnvironmentStatus';
 import { getLanguageServerToolPath } from './goLanguageServer';
 import { restartLanguageServer } from './goMain';
 import { hideGoStatus, outputChannel, showGoStatus } from './goStatus';
@@ -389,6 +389,9 @@
 				// version of go than the system default found from PATH (or Path).
 				if (why !== 'path') {
 					addGoRuntimeBaseToPATH(path.join(getCurrentGoRoot(), 'bin'));
+				} else {
+					// clear pre-existing terminal PATH mutation logic set up by this extension.
+					clearGoRuntimeBaseFromPATH();
 				}
 				initGoStatusBar();
 				// TODO: restart language server or synchronize with language server update.
diff --git a/src/utils/pathUtils.ts b/src/utils/pathUtils.ts
index 3f1f59a..f67d8b5 100644
--- a/src/utils/pathUtils.ts
+++ b/src/utils/pathUtils.ts
@@ -18,7 +18,8 @@
 
 export const envPath = process.env['PATH'] || (process.platform === 'win32' ? process.env['Path'] : null);
 
-export function getBinPathFromEnvVar(toolName: string, envVarValue: string, appendBinToPath: boolean): string {
+// find the tool's path from the given PATH env var, or null if the tool is not found.
+export function getBinPathFromEnvVar(toolName: string, envVarValue: string, appendBinToPath: boolean): string|null {
 	toolName = correctBinname(toolName);
 	if (envVarValue) {
 		const paths = envVarValue.split(path.delimiter);
@@ -44,7 +45,7 @@
 	return r.binPath;
 }
 
-// Is same as getBinPAthWithPreferredGopathGoroot, but returns why the
+// Is same as getBinPathWithPreferredGopathGoroot, but returns why the
 // returned path was chosen.
 export function getBinPathWithPreferredGopathGorootWithExplanation(
 	toolName: string,
@@ -64,10 +65,11 @@
 	}
 
 	const binname = alternateTool && !path.isAbsolute(alternateTool) ? alternateTool : toolName;
+	const found = (why: string) => binname === toolName ? why : 'alternateTool';
 	const pathFromGoBin = getBinPathFromEnvVar(binname, process.env['GOBIN'], false);
 	if (pathFromGoBin) {
 		binPathCache[toolName] = pathFromGoBin;
-		return {binPath: pathFromGoBin, why: 'gobin'};
+		return {binPath: pathFromGoBin, why: binname === toolName ? 'gobin' : 'alternateTool'};
 	}
 
 	for (const preferred of preferredGopaths) {
@@ -76,7 +78,7 @@
 			const pathFrompreferredGoPath = getBinPathFromEnvVar(binname, preferred, true);
 			if (pathFrompreferredGoPath) {
 				binPathCache[toolName] = pathFrompreferredGoPath;
-				return {binPath: pathFrompreferredGoPath, why: 'gopath'};
+				return {binPath: pathFrompreferredGoPath, why: found('gopath')};
 			}
 		}
 	}
@@ -85,14 +87,14 @@
 	const pathFromGoRoot = getBinPathFromEnvVar(binname, preferredGoroot || getCurrentGoRoot(), true);
 	if (pathFromGoRoot) {
 		binPathCache[toolName] = pathFromGoRoot;
-		return {binPath: pathFromGoRoot, why: 'goroot'};
+		return {binPath: pathFromGoRoot, why: found('goroot')};
 	}
 
 	// Finally search PATH parts
 	const pathFromPath = getBinPathFromEnvVar(binname, envPath, false);
 	if (pathFromPath) {
 		binPathCache[toolName] = pathFromPath;
-		return {binPath: pathFromPath, why: 'path'};
+		return {binPath: pathFromPath, why: found('path')};
 	}
 
 	// Check default path for go