diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index 1362f1c8d..000000000
--- a/.gitmodules
+++ /dev/null
@@ -1,4 +0,0 @@
-[submodule "submodules/PSScriptAnalyzer"]
-	path = submodules/PSScriptAnalyzer
-	url = https://github.com/PowerShell/PSScriptAnalyzer.git
-	branch = master
diff --git a/PowerShellEditorServices.NoNano.sln b/PowerShellEditorServices.NoNano.sln
index 0c1275321..94d330215 100644
--- a/PowerShellEditorServices.NoNano.sln
+++ b/PowerShellEditorServices.NoNano.sln
@@ -7,12 +7,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{F594E7FD-1E7
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{422E561A-8118-4BE7-A54F-9309E4F03AAE}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "submodules", "submodules", "{AF08DA0C-B0A6-47AD-AC55-E13C687D4A91}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScriptAnalyzerEngine", "submodules\PSScriptAnalyzer\Engine\ScriptAnalyzerEngine.csproj", "{F4BDE3D0-3EEF-4157-8A3E-722DF7ADEF60}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScriptAnalyzerBuiltinRules", "submodules\PSScriptAnalyzer\Rules\ScriptAnalyzerBuiltinRules.csproj", "{C33B6B9D-E61C-45A3-9103-895FD82A5C1E}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PowerShellEditorServices", "src\PowerShellEditorServices\PowerShellEditorServices.csproj", "{81E8CBCD-6319-49E7-9662-0475BD0791F4}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PowerShellEditorServices.Host", "src\PowerShellEditorServices.Host\PowerShellEditorServices.Host.csproj", "{B2F6369A-D737-4AFD-8B81-9B094DB07DA7}"
@@ -53,14 +47,6 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{F4BDE3D0-3EEF-4157-8A3E-722DF7ADEF60}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F4BDE3D0-3EEF-4157-8A3E-722DF7ADEF60}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F4BDE3D0-3EEF-4157-8A3E-722DF7ADEF60}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F4BDE3D0-3EEF-4157-8A3E-722DF7ADEF60}.Release|Any CPU.Build.0 = Release|Any CPU
-		{C33B6B9D-E61C-45A3-9103-895FD82A5C1E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C33B6B9D-E61C-45A3-9103-895FD82A5C1E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{C33B6B9D-E61C-45A3-9103-895FD82A5C1E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{C33B6B9D-E61C-45A3-9103-895FD82A5C1E}.Release|Any CPU.Build.0 = Release|Any CPU
 		{81E8CBCD-6319-49E7-9662-0475BD0791F4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{81E8CBCD-6319-49E7-9662-0475BD0791F4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{81E8CBCD-6319-49E7-9662-0475BD0791F4}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -102,8 +88,6 @@ Global
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{F4BDE3D0-3EEF-4157-8A3E-722DF7ADEF60} = {AF08DA0C-B0A6-47AD-AC55-E13C687D4A91}
-		{C33B6B9D-E61C-45A3-9103-895FD82A5C1E} = {AF08DA0C-B0A6-47AD-AC55-E13C687D4A91}
 		{81E8CBCD-6319-49E7-9662-0475BD0791F4} = {EE0A010C-E246-49AE-92E7-AD4320C45086}
 		{B2F6369A-D737-4AFD-8B81-9B094DB07DA7} = {EE0A010C-E246-49AE-92E7-AD4320C45086}
 		{3A5DDD20-5BD0-42F4-89F4-ACC0CE554028} = {422E561A-8118-4BE7-A54F-9309E4F03AAE}
diff --git a/src/PowerShellEditorServices.Protocol/Client/DebugAdapterClientBase.cs b/src/PowerShellEditorServices.Protocol/Client/DebugAdapterClientBase.cs
index 5e6a1758b..5476edbe4 100644
--- a/src/PowerShellEditorServices.Protocol/Client/DebugAdapterClientBase.cs
+++ b/src/PowerShellEditorServices.Protocol/Client/DebugAdapterClientBase.cs
@@ -22,7 +22,7 @@ public async Task LaunchScript(string scriptFilePath)
             await this.SendRequest(
                 LaunchRequest.Type,
                 new LaunchRequestArguments {
-                    Program = scriptFilePath
+                    Script = scriptFilePath
                 });
 
             await this.SendRequest(ConfigurationDoneRequest.Type, null);
diff --git a/src/PowerShellEditorServices.Protocol/DebugAdapter/InitializeRequest.cs b/src/PowerShellEditorServices.Protocol/DebugAdapter/InitializeRequest.cs
index 16c99544e..c0c843fe4 100644
--- a/src/PowerShellEditorServices.Protocol/DebugAdapter/InitializeRequest.cs
+++ b/src/PowerShellEditorServices.Protocol/DebugAdapter/InitializeRequest.cs
@@ -47,10 +47,22 @@ public class InitializeResponseBody
         /// </summary>
         public bool SupportsConditionalBreakpoints { get; set; }
 
+        /// <summary>
+        /// Gets or sets a boolean value that determines whether the debug adapter 
+        /// supports breakpoints that break execution after a specified number of hits.
+        /// </summary>
+        public bool SupportsHitConditionalBreakpoints { get; set; }
+
         /// <summary>
         /// Gets or sets a boolean value that determines whether the debug adapter 
         /// supports a (side effect free) evaluate request for data hovers.
         /// </summary>
         public bool SupportsEvaluateForHovers { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean value that determines whether the debug adapter
+        /// supports allowing the user to set a variable from the Variables debug windows.
+        /// </summary>
+        public bool SupportsSetVariable { get; set; }
     }
 }
diff --git a/src/PowerShellEditorServices.Protocol/DebugAdapter/LaunchRequest.cs b/src/PowerShellEditorServices.Protocol/DebugAdapter/LaunchRequest.cs
index 5fa1cb10e..b81e56f8d 100644
--- a/src/PowerShellEditorServices.Protocol/DebugAdapter/LaunchRequest.cs
+++ b/src/PowerShellEditorServices.Protocol/DebugAdapter/LaunchRequest.cs
@@ -3,6 +3,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
+using System;
 using System.Collections.Generic;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 
@@ -20,8 +21,14 @@ public class LaunchRequestArguments
         /// <summary>
         /// Gets or sets the absolute path to the program to debug.
         /// </summary>
+        [Obsolete("This property has been deprecated in favor of the Script property.")]
         public string Program { get; set; }
 
+        /// <summary>
+        /// Gets or sets the absolute path to the script to debug.
+        /// </summary>
+        public string Script { get; set; }
+
         /// <summary>
         /// Gets or sets a boolean value that indicates whether the script should be
         /// run with (false) or without (true) debugging support.
diff --git a/src/PowerShellEditorServices.Protocol/DebugAdapter/SetBreakpointsRequest.cs b/src/PowerShellEditorServices.Protocol/DebugAdapter/SetBreakpointsRequest.cs
index a4993291d..5b0f88bf2 100644
--- a/src/PowerShellEditorServices.Protocol/DebugAdapter/SetBreakpointsRequest.cs
+++ b/src/PowerShellEditorServices.Protocol/DebugAdapter/SetBreakpointsRequest.cs
@@ -34,6 +34,8 @@ public class SourceBreakpoint
         public int? Column { get; set; }
 
         public string Condition { get; set; }
+
+        public string HitCondition { get; set; }
     }
 
     public class SetBreakpointsResponseBody
diff --git a/src/PowerShellEditorServices.Protocol/DebugAdapter/SetFunctionBreakpointsRequest.cs b/src/PowerShellEditorServices.Protocol/DebugAdapter/SetFunctionBreakpointsRequest.cs
index 434c6dd59..73b75f82e 100644
--- a/src/PowerShellEditorServices.Protocol/DebugAdapter/SetFunctionBreakpointsRequest.cs
+++ b/src/PowerShellEditorServices.Protocol/DebugAdapter/SetFunctionBreakpointsRequest.cs
@@ -27,5 +27,7 @@ public class FunctionBreakpoint
         public string Name { get; set; }
 
         public string Condition { get; set; }
+
+        public string HitCondition { get; set; }
     }
 }
diff --git a/src/PowerShellEditorServices.Protocol/DebugAdapter/SetVariableRequest.cs b/src/PowerShellEditorServices.Protocol/DebugAdapter/SetVariableRequest.cs
new file mode 100644
index 000000000..333327454
--- /dev/null
+++ b/src/PowerShellEditorServices.Protocol/DebugAdapter/SetVariableRequest.cs
@@ -0,0 +1,36 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Diagnostics;
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter
+{
+    /// <summary>
+    /// SetVariable request; value of command field is "setVariable".
+    /// Request is initiated when user uses the debugger Variables UI to change the value of a variable.
+    /// </summary>
+    public class SetVariableRequest
+    {
+        public static readonly
+            RequestType<SetVariableRequestArguments, SetVariableResponseBody> Type =
+            RequestType<SetVariableRequestArguments, SetVariableResponseBody>.Create("setVariable");
+    }
+
+    [DebuggerDisplay("VariablesReference = {VariablesReference}")]
+    public class SetVariableRequestArguments
+    {
+        public int VariablesReference { get; set; }
+
+        public string Name { get; set; }
+
+        public string Value { get; set; }
+    }
+
+    public class SetVariableResponseBody
+    {
+        public string Value { get; set; }
+    }
+}
diff --git a/src/PowerShellEditorServices.Protocol/LanguageServer/CodeAction.cs b/src/PowerShellEditorServices.Protocol/LanguageServer/CodeAction.cs
new file mode 100644
index 000000000..deb0cb17f
--- /dev/null
+++ b/src/PowerShellEditorServices.Protocol/LanguageServer/CodeAction.cs
@@ -0,0 +1,32 @@
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+using Newtonsoft.Json.Linq;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.LanguageServer
+{
+    public class CodeActionRequest
+    {
+        public static readonly
+            RequestType<CodeActionRequest, CodeActionCommand[]> Type =
+            RequestType<CodeActionRequest, CodeActionCommand[]>.Create("textDocument/codeAction");
+
+        public TextDocumentIdentifier TextDocument { get; set; }
+
+        public Range Range { get; set; }
+
+        public CodeActionContext Context { get; set; }
+    }
+
+    public class CodeActionContext
+    {
+        public Diagnostic[] Diagnostics { get; set; }
+    }
+
+    public class CodeActionCommand
+    {
+        public string Title { get; set; }
+
+        public string Command { get; set; }
+
+        public JArray Arguments { get; set; }
+    }
+}
diff --git a/src/PowerShellEditorServices.Protocol/LanguageServer/EditorCommands.cs b/src/PowerShellEditorServices.Protocol/LanguageServer/EditorCommands.cs
index cdd128135..f97b26ee1 100644
--- a/src/PowerShellEditorServices.Protocol/LanguageServer/EditorCommands.cs
+++ b/src/PowerShellEditorServices.Protocol/LanguageServer/EditorCommands.cs
@@ -107,5 +107,40 @@ public static readonly
             RequestType<string, EditorCommandResponse> Type =
             RequestType<string, EditorCommandResponse>.Create("editor/openFile");
     }
+
+    public class ShowInformationMessageRequest
+    {
+        public static readonly
+            RequestType<string, EditorCommandResponse> Type =
+            RequestType<string, EditorCommandResponse>.Create("editor/showInformationMessage");
+    }
+
+    public class ShowWarningMessageRequest
+    {
+        public static readonly
+            RequestType<string, EditorCommandResponse> Type =
+            RequestType<string, EditorCommandResponse>.Create("editor/showWarningMessage");
+    }
+
+    public class ShowErrorMessageRequest
+    {
+        public static readonly
+            RequestType<string, EditorCommandResponse> Type =
+            RequestType<string, EditorCommandResponse>.Create("editor/showErrorMessage");
+    }
+
+    public class SetStatusBarMessageRequest
+    {
+        public static readonly
+            RequestType<StatusBarMessageDetails, EditorCommandResponse> Type =
+            RequestType<StatusBarMessageDetails, EditorCommandResponse>.Create("editor/setStatusBarMessage");
+    }
+
+    public class StatusBarMessageDetails
+    {
+        public string Message { get; set; }
+
+        public int? Timeout { get; set; }
+    }
 }
 
diff --git a/src/PowerShellEditorServices.Protocol/LanguageServer/PowerShellVersionRequest.cs b/src/PowerShellEditorServices.Protocol/LanguageServer/PowerShellVersionRequest.cs
new file mode 100644
index 000000000..37f7ce1b0
--- /dev/null
+++ b/src/PowerShellEditorServices.Protocol/LanguageServer/PowerShellVersionRequest.cs
@@ -0,0 +1,52 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+using Microsoft.PowerShell.EditorServices.Session;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.LanguageServer
+{
+    public class PowerShellVersionRequest
+    {
+        public static readonly
+            RequestType<object, PowerShellVersionResponse> Type =
+            RequestType<object, PowerShellVersionResponse>.Create("powerShell/getVersion");
+    }
+
+    public class PowerShellVersionResponse
+    {
+        public string Version { get; set; }
+
+        public string DisplayVersion { get; set; }
+
+        public string Edition { get; set; }
+
+        public string Architecture { get; set; }
+
+        public PowerShellVersionResponse()
+        {
+        }
+
+        public PowerShellVersionResponse(PowerShellVersionDetails versionDetails)
+        {
+            this.Version = versionDetails.VersionString;
+            this.DisplayVersion =  $"{versionDetails.Version.Major}.{versionDetails.Version.Minor}";
+            this.Edition = versionDetails.Edition;
+
+            switch (versionDetails.Architecture)
+            {
+                case PowerShellProcessArchitecture.X64:
+                    this.Architecture = "x64";
+                    break;
+                case PowerShellProcessArchitecture.X86:
+                    this.Architecture = "x86";
+                    break;
+                default:
+                    this.Architecture = "Architecture Unknown";
+                    break;
+            }
+        }
+    }
+}
diff --git a/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs b/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs
index 34ba312f8..aeebb411d 100644
--- a/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs
+++ b/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs
@@ -24,6 +24,8 @@ public class ServerCapabilities
         public bool? DocumentSymbolProvider { get; set; }
 
         public bool? WorkspaceSymbolProvider { get; set; }
+
+        public bool? CodeActionProvider { get; set; }
     }
 
     /// <summary>
diff --git a/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj b/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj
index ea0bc7f84..c26ab8381 100644
--- a/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj
+++ b/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj
@@ -54,9 +54,12 @@
     <Compile Include="DebugAdapter\ConfigurationDoneRequest.cs" />
     <Compile Include="DebugAdapter\ContinueRequest.cs" />
     <Compile Include="DebugAdapter\SetFunctionBreakpointsRequest.cs" />
+    <Compile Include="DebugAdapter\SetVariableRequest.cs" />
     <Compile Include="LanguageServer\EditorCommands.cs" />
+    <Compile Include="LanguageServer\CodeAction.cs" />
     <Compile Include="LanguageServer\FindModuleRequest.cs" />
     <Compile Include="LanguageServer\InstallModuleRequest.cs" />
+    <Compile Include="LanguageServer\PowerShellVersionRequest.cs" />
     <Compile Include="MessageProtocol\Channel\NamedPipeClientChannel.cs" />
     <Compile Include="MessageProtocol\Channel\NamedPipeServerChannel.cs" />
     <Compile Include="MessageProtocol\Channel\TcpSocketClientChannel.cs" />
@@ -153,7 +156,7 @@
     </PropertyGroup>
     <Error Condition="!Exists('$(SolutionDir)\.nuget\NuGet.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)\.nuget\NuGet.targets'))" />
   </Target>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
   </Target>
diff --git a/src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs b/src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs
index 70f5c8999..86a87cc9b 100644
--- a/src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs
+++ b/src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs
@@ -3,6 +3,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
+using Microsoft.PowerShell.EditorServices.Debugging;
 using Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
@@ -67,6 +68,7 @@ protected override void Initialize()
             this.SetRequestHandler(StackTraceRequest.Type, this.HandleStackTraceRequest);
             this.SetRequestHandler(ScopesRequest.Type, this.HandleScopesRequest);
             this.SetRequestHandler(VariablesRequest.Type, this.HandleVariablesRequest);
+            this.SetRequestHandler(SetVariableRequest.Type, this.HandleSetVariablesRequest);
             this.SetRequestHandler(SourceRequest.Type, this.HandleSourceRequest);
             this.SetRequestHandler(EvaluateRequest.Type, this.HandleEvaluateRequest);
         }
@@ -77,7 +79,10 @@ protected Task LaunchScript(RequestContext<object> requestContext)
                     .ExecuteScriptAtPath(this.scriptPathToLaunch, this.arguments)
                     .ContinueWith(
                         async (t) => {
-                            Logger.Write(LogLevel.Verbose, "Execution completed, terminating...");
+                            Logger.Write(LogLevel.Verbose, "Execution completed, flushing output then terminating...");
+
+                            // Make sure remaining output is flushed before exiting
+                            await this.outputDebouncer.Flush();
 
                             await requestContext.SendEvent(
                                 TerminatedEvent.Type,
@@ -128,7 +133,7 @@ protected async Task HandleLaunchRequest(
             // Set the working directory for the PowerShell runspace to the cwd passed in via launch.json. 
             // In case that is null, use the the folder of the script to be executed.  If the resulting 
             // working dir path is a file path then extract the directory and use that.
-            string workingDir = launchParams.Cwd ?? launchParams.Program;
+            string workingDir = launchParams.Cwd ?? launchParams.Script ?? launchParams.Program;
             workingDir = PowerShellContext.UnescapePath(workingDir);
             try
             {
@@ -165,7 +170,7 @@ protected async Task HandleLaunchRequest(
             // params so that the subsequent configurationDone request handler 
             // can launch the script. 
             this.noDebug = launchParams.NoDebug;
-            this.scriptPathToLaunch = launchParams.Program;
+            this.scriptPathToLaunch = launchParams.Script ?? launchParams.Program;
             this.arguments = arguments;
 
             // The order of debug protocol messages apparently isn't as guaranteed as we might like.
@@ -260,7 +265,8 @@ await requestContext.SendResult(
                     scriptFile.FilePath, 
                     srcBreakpoint.Line, 
                     srcBreakpoint.Column, 
-                    srcBreakpoint.Condition);
+                    srcBreakpoint.Condition,
+                    srcBreakpoint.HitCondition);
             }
 
             // If this is a "run without debugging (Ctrl+F5)" session ignore requests to set breakpoints.
@@ -292,7 +298,8 @@ protected async Task HandleSetFunctionBreakpointsRequest(
                 FunctionBreakpoint funcBreakpoint = setBreakpointsParams.Breakpoints[i];
                 breakpointDetails[i] = CommandBreakpointDetails.Create(
                     funcBreakpoint.Name,
-                    funcBreakpoint.Condition);
+                    funcBreakpoint.Condition,
+                    funcBreakpoint.HitCondition);
             }
 
             // If this is a "run without debugging (Ctrl+F5)" session ignore requests to set breakpoints.
@@ -466,6 +473,42 @@ protected async Task HandleVariablesRequest(
             await requestContext.SendResult(variablesResponse);
         }
 
+        protected async Task HandleSetVariablesRequest(
+            SetVariableRequestArguments setVariableParams,
+            RequestContext<SetVariableResponseBody> requestContext)
+        {
+            try
+            {
+                string updatedValue =
+                    await editorSession.DebugService.SetVariable(
+                        setVariableParams.VariablesReference,
+                        setVariableParams.Name,
+                        setVariableParams.Value);
+
+                var setVariableResponse = new SetVariableResponseBody
+                {
+                    Value = updatedValue
+                };
+
+                await requestContext.SendResult(setVariableResponse);
+            }
+            catch (Exception ex) when (ex is ArgumentTransformationMetadataException ||
+                                       ex is InvalidPowerShellExpressionException ||
+                                       ex is SessionStateUnauthorizedAccessException)
+            {
+                // Catch common, innocuous errors caused by the user supplying a value that can't be converted or the variable is not settable.
+                Logger.Write(LogLevel.Verbose, $"Failed to set variable: {ex.Message}");
+                await requestContext.SendError(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                Logger.Write(LogLevel.Error, $"Unexpected error setting variable: {ex.Message}");
+                string msg =
+                    $"Unexpected error: {ex.GetType().Name} - {ex.Message}  Please report this error to the PowerShellEditorServices project on GitHub.";
+                await requestContext.SendError(msg);
+            }
+        }
+
         protected Task HandleSourceRequest(
             SourceRequestArguments sourceParams,
             RequestContext<SourceResponseBody> requestContext)
diff --git a/src/PowerShellEditorServices.Protocol/Server/DebugAdapterBase.cs b/src/PowerShellEditorServices.Protocol/Server/DebugAdapterBase.cs
index f84ebb9d7..4f324d269 100644
--- a/src/PowerShellEditorServices.Protocol/Server/DebugAdapterBase.cs
+++ b/src/PowerShellEditorServices.Protocol/Server/DebugAdapterBase.cs
@@ -58,8 +58,10 @@ private async Task HandleInitializeRequest(
             await requestContext.SendResult(
                 new InitializeResponseBody {
                     SupportsConfigurationDoneRequest = true,
+                    SupportsFunctionBreakpoints = true,
                     SupportsConditionalBreakpoints = true,
-                    SupportsFunctionBreakpoints = true
+                    SupportsHitConditionalBreakpoints = true,
+                    SupportsSetVariable = true
                 });
 
             // Send the Initialized event so that we get breakpoints
diff --git a/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs b/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
index 38a12a5d7..fcdf34f10 100644
--- a/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
+++ b/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
@@ -9,6 +9,7 @@
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
 using Microsoft.PowerShell.EditorServices.Session;
 using Microsoft.PowerShell.EditorServices.Utility;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -30,6 +31,8 @@ public class LanguageServer : LanguageServerBase
         private OutputDebouncer outputDebouncer;
         private LanguageServerEditorOperations editorOperations;
         private LanguageServerSettings currentSettings = new LanguageServerSettings();
+        private Dictionary<string, Dictionary<string, MarkerCorrection>> codeActionsPerFile =
+            new Dictionary<string, Dictionary<string, MarkerCorrection>>();
 
         /// <param name="hostDetails">
         /// Provides details about the host application.
@@ -92,6 +95,7 @@ protected override void Initialize()
             this.SetRequestHandler(HoverRequest.Type, this.HandleHoverRequest);
             this.SetRequestHandler(DocumentSymbolRequest.Type, this.HandleDocumentSymbolRequest);
             this.SetRequestHandler(WorkspaceSymbolRequest.Type, this.HandleWorkspaceSymbolRequest);
+            this.SetRequestHandler(CodeActionRequest.Type, this.HandleCodeActionRequest);
 
             this.SetRequestHandler(ShowOnlineHelpRequest.Type, this.HandleShowOnlineHelpRequest);
             this.SetRequestHandler(ExpandAliasRequest.Type, this.HandleExpandAliasRequest);
@@ -101,6 +105,8 @@ protected override void Initialize()
 
             this.SetRequestHandler(InvokeExtensionCommandRequest.Type, this.HandleInvokeExtensionCommandRequest);
 
+            this.SetRequestHandler(PowerShellVersionRequest.Type, this.HandlePowerShellVersionRequest);
+
             this.SetRequestHandler(DebugAdapterMessages.EvaluateRequest.Type, this.HandleEvaluateRequest);
 
             // Initialize the extension service
@@ -144,6 +150,7 @@ await requestContext.SendResult(
                         DocumentSymbolProvider = true,
                         WorkspaceSymbolProvider = true,
                         HoverProvider = true,
+                        CodeActionProvider = true,
                         CompletionProvider = new CompletionOptions
                         {
                             ResolveProvider = true,
@@ -224,17 +231,17 @@ function __Expand-Alias {
     param($targetScript)
 
     [ref]$errors=$null
-    
-    $tokens = [System.Management.Automation.PsParser]::Tokenize($targetScript, $errors).Where({$_.type -eq 'command'}) | 
+
+    $tokens = [System.Management.Automation.PsParser]::Tokenize($targetScript, $errors).Where({$_.type -eq 'command'}) |
                     Sort Start -Descending
 
     foreach ($token in  $tokens) {
         $definition=(Get-Command ('`'+$token.Content) -CommandType Alias -ErrorAction SilentlyContinue).Definition
 
-        if($definition) {        
+        if($definition) {
             $lhs=$targetScript.Substring(0, $token.Start)
             $rhs=$targetScript.Substring($token.Start + $token.Length)
-            
+
             $targetScript=$lhs + $definition + $rhs
        }
     }
@@ -344,13 +351,13 @@ protected async Task HandleDidChangeConfigurationNotification(
             EventContext eventContext)
         {
             bool oldLoadProfiles = this.currentSettings.EnableProfileLoading;
-            bool oldScriptAnalysisEnabled = 
+            bool oldScriptAnalysisEnabled =
                 this.currentSettings.ScriptAnalysis.Enable.HasValue;
             string oldScriptAnalysisSettingsPath =
                 this.currentSettings.ScriptAnalysis.SettingsPath;
 
             this.currentSettings.Update(
-                configChangeParams.Settings.Powershell, 
+                configChangeParams.Settings.Powershell,
                 this.editorSession.Workspace.WorkspacePath);
 
             if (!this.profilesLoaded &&
@@ -384,6 +391,7 @@ protected async Task HandleDidChangeConfigurationNotification(
                         await PublishScriptDiagnostics(
                             scriptFile,
                             emptyAnalysisDiagnostics,
+                            this.codeActionsPerFile,
                             eventContext);
                     }
                 }
@@ -799,11 +807,49 @@ protected async Task HandleWorkspaceSymbolRequest(
             await requestContext.SendResult(symbols.ToArray());
         }
 
+        protected async Task HandlePowerShellVersionRequest(
+            object noParams,
+            RequestContext<PowerShellVersionResponse> requestContext)
+        {
+            await requestContext.SendResult(
+                new PowerShellVersionResponse(
+                    this.editorSession.PowerShellContext.PowerShellVersionDetails));
+        }
+
         private bool IsQueryMatch(string query, string symbolName)
         {
             return symbolName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
         }
 
+        protected async Task HandleCodeActionRequest(
+            CodeActionRequest codeActionParams,
+            RequestContext<CodeActionCommand[]> requestContext)
+        {
+            MarkerCorrection correction = null;
+            Dictionary<string, MarkerCorrection> markerIndex = null;
+            List<CodeActionCommand> codeActionCommands = new List<CodeActionCommand>();
+
+            if (this.codeActionsPerFile.TryGetValue(codeActionParams.TextDocument.Uri, out markerIndex))
+            {
+                foreach (var diagnostic in codeActionParams.Context.Diagnostics)
+                {
+                    if (markerIndex.TryGetValue(diagnostic.Code, out correction))
+                    {
+                        codeActionCommands.Add(
+                            new CodeActionCommand
+                            {
+                                Title = correction.Name,
+                                Command = "PowerShell.ApplyCodeActionEdits",
+                                Arguments = JArray.FromObject(correction.Edits)
+                            });
+                    }
+                }
+            }
+
+            await requestContext.SendResult(
+                codeActionCommands.ToArray());
+        }
+
         protected Task HandleEvaluateRequest(
             DebugAdapterMessages.EvaluateRequestArguments evaluateParams,
             RequestContext<DebugAdapterMessages.EvaluateResponseBody> requestContext)
@@ -963,6 +1009,7 @@ private Task RunScriptDiagnostics(
                     DelayThenInvokeDiagnostics(
                         750,
                         filesToAnalyze,
+                        this.codeActionsPerFile,
                         editorSession,
                         eventContext,
                         existingRequestCancellation.Token),
@@ -976,6 +1023,7 @@ private Task RunScriptDiagnostics(
         private static async Task DelayThenInvokeDiagnostics(
             int delayMilliseconds,
             ScriptFile[] filesToAnalyze,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
             EditorSession editorSession,
             EventContext eventContext,
             CancellationToken cancellationToken)
@@ -1023,6 +1071,7 @@ private static async Task DelayThenInvokeDiagnostics(
                 await PublishScriptDiagnostics(
                     scriptFile,
                     semanticMarkers,
+                    correctionIndex,
                     eventContext);
             }
         }
@@ -1030,21 +1079,37 @@ await PublishScriptDiagnostics(
         private static async Task PublishScriptDiagnostics(
             ScriptFile scriptFile,
             ScriptFileMarker[] semanticMarkers,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
             EventContext eventContext)
         {
-            var allMarkers = scriptFile.SyntaxMarkers.Concat(semanticMarkers);
+            List<Diagnostic> diagnostics = new List<Diagnostic>();
+
+            // Hold on to any corrections that may need to be applied later
+            Dictionary<string, MarkerCorrection> fileCorrections =
+                new Dictionary<string, MarkerCorrection>();
+
+            foreach (var marker in scriptFile.SyntaxMarkers.Concat(semanticMarkers))
+            {
+                // Does the marker contain a correction?
+                Diagnostic markerDiagnostic = GetDiagnosticFromMarker(marker);
+                if (marker.Correction != null)
+                {
+                    fileCorrections.Add(markerDiagnostic.Code, marker.Correction);
+                }
+
+                diagnostics.Add(markerDiagnostic);
+            }
+
+            correctionIndex[scriptFile.ClientFilePath] = fileCorrections;
 
-            // Always send syntax and semantic errors.  We want to 
+            // Always send syntax and semantic errors.  We want to
             // make sure no out-of-date markers are being displayed.
             await eventContext.SendEvent(
                 PublishDiagnosticsNotification.Type,
                 new PublishDiagnosticsNotification
                 {
                     Uri = scriptFile.ClientFilePath,
-                    Diagnostics =
-                       allMarkers
-                            .Select(GetDiagnosticFromMarker)
-                            .ToArray()
+                    Diagnostics = diagnostics.ToArray()
                 });
         }
 
@@ -1054,6 +1119,7 @@ private static Diagnostic GetDiagnosticFromMarker(ScriptFileMarker scriptFileMar
             {
                 Severity = MapDiagnosticSeverity(scriptFileMarker.Level),
                 Message = scriptFileMarker.Message,
+                Code = Guid.NewGuid().ToString(),
                 Range = new Range
                 {
                     // TODO: What offsets should I use?
@@ -1134,7 +1200,7 @@ private static CompletionItem CreateCompletionItem(
                     if (!completionDetails.ListItemText.Equals(
                             completionDetails.ToolTipText,
                             StringComparison.OrdinalIgnoreCase) &&
-                        !Regex.IsMatch(completionDetails.ToolTipText, 
+                        !Regex.IsMatch(completionDetails.ToolTipText,
                             @"^\s*" + escapedToolTipText + @"\s+\["))
                     {
                         detailString = completionDetails.ToolTipText;
@@ -1147,7 +1213,7 @@ private static CompletionItem CreateCompletionItem(
             // default (with common params at the end). We just need to make sure the default
             // order also be the lexicographical order which we do by prefixig the ListItemText
             // with a leading 0's four digit index.  This would not sort correctly for a list
-            // > 999 parameters but surely we won't have so many items in the "parameter name" 
+            // > 999 parameters but surely we won't have so many items in the "parameter name"
             // completion list. Technically we don't need the ListItemText at all but it may come
             // in handy during debug.
             var sortText = (completionDetails.CompletionType == CompletionType.ParameterName)
diff --git a/src/PowerShellEditorServices.Protocol/Server/LanguageServerEditorOperations.cs b/src/PowerShellEditorServices.Protocol/Server/LanguageServerEditorOperations.cs
index 11f9089a6..f60772527 100644
--- a/src/PowerShellEditorServices.Protocol/Server/LanguageServerEditorOperations.cs
+++ b/src/PowerShellEditorServices.Protocol/Server/LanguageServerEditorOperations.cs
@@ -7,6 +7,7 @@
 using Microsoft.PowerShell.EditorServices.Protocol.LanguageServer;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using System.Threading.Tasks;
+using System;
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.Server
 {
@@ -109,5 +110,45 @@ public Task OpenFile(string filePath)
                     filePath,
                     true);
         }
+
+        public Task ShowInformationMessage(string message)
+        {
+            return
+                this.messageSender.SendRequest(
+                    ShowInformationMessageRequest.Type,
+                    message,
+                    true);
+        }
+
+        public Task ShowErrorMessage(string message)
+        {
+            return
+                this.messageSender.SendRequest(
+                    ShowErrorMessageRequest.Type,
+                    message,
+                    true);
+        }
+
+        public Task ShowWarningMessage(string message)
+        {
+            return
+                this.messageSender.SendRequest(
+                    ShowWarningMessageRequest.Type,
+                    message,
+                    true);
+        }
+
+        public Task SetStatusBarMessage(string message, int? timeout)
+        {
+            return
+                this.messageSender.SendRequest(
+                    SetStatusBarMessageRequest.Type,
+                    new StatusBarMessageDetails
+                    {
+                        Message = message,
+                        Timeout = timeout
+                    },
+                    true);
+        }
     }
 }
diff --git a/src/PowerShellEditorServices/Analysis/AnalysisService.cs b/src/PowerShellEditorServices/Analysis/AnalysisService.cs
index 375af91e9..8bdaffb86 100644
--- a/src/PowerShellEditorServices/Analysis/AnalysisService.cs
+++ b/src/PowerShellEditorServices/Analysis/AnalysisService.cs
@@ -17,7 +17,7 @@
 namespace Microsoft.PowerShell.EditorServices
 {
     /// <summary>
-    /// Provides a high-level service for performing semantic analysis  
+    /// Provides a high-level service for performing semantic analysis
     /// of PowerShell scripts.
     /// </summary>
     public class AnalysisService : IDisposable
@@ -31,8 +31,13 @@ public class AnalysisService : IDisposable
         /// Defines the list of Script Analyzer rules to include by default if
         /// no settings file is specified.
         /// </summary>
-        private static readonly string[] IncludedRules = {
+        private static readonly string[] IncludedRules = new string[]
+        {
+            "PSUseToExportFieldsInManifest",
+            "PSMisleadingBacktick",
+            "PSAvoidUsingCmdletAliases",
             "PSUseApprovedVerbs",
+            "PSAvoidUsingPlainTextForPassword",
             "PSReservedCmdletChar",
             "PSReservedParams",
             "PSShouldProcess",
@@ -63,7 +68,7 @@ public string SettingsPath
         /// <summary>
         /// Creates an instance of the AnalysisService class.
         /// </summary>
-        /// <param name="consoleHost">An object that implements IConsoleHost in which to write errors/warnings 
+        /// <param name="consoleHost">An object that implements IConsoleHost in which to write errors/warnings
         /// from analyzer.</param>
         /// <param name="settingsPath">Path to a PSScriptAnalyzer settings file.</param>
         public AnalysisService(IConsoleHost consoleHost, string settingsPath = null)
@@ -106,8 +111,8 @@ public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file)
                     Task.Factory.StartNew<ScriptFileMarker[]>(
                         () =>
                         {
-                                return 
-                                     GetDiagnosticRecords(file) 
+                                return
+                                     GetDiagnosticRecords(file)
                                     .Select(ScriptFileMarker.FromDiagnosticRecord)
                                     .ToArray();
                         },
diff --git a/src/PowerShellEditorServices/Debugging/BreakpointDetails.cs b/src/PowerShellEditorServices/Debugging/BreakpointDetails.cs
index f8b16117e..0adaecaed 100644
--- a/src/PowerShellEditorServices/Debugging/BreakpointDetails.cs
+++ b/src/PowerShellEditorServices/Debugging/BreakpointDetails.cs
@@ -42,12 +42,14 @@ private BreakpointDetails()
         /// <param name="line"></param>
         /// <param name="column"></param>
         /// <param name="condition"></param>
+        /// <param name="hitCondition"></param>
         /// <returns></returns>
         public static BreakpointDetails Create(
             string source, 
             int line, 
             int? column = null, 
-            string condition = null)
+            string condition = null,
+            string hitCondition = null)
         {
             Validate.IsNotNull("source", source);
 
@@ -57,7 +59,8 @@ public static BreakpointDetails Create(
                 Source = source,
                 LineNumber = line,
                 ColumnNumber = column,
-                Condition = condition
+                Condition = condition,
+                HitCondition = hitCondition
             };
         }
 
diff --git a/src/PowerShellEditorServices/Debugging/BreakpointDetailsBase.cs b/src/PowerShellEditorServices/Debugging/BreakpointDetailsBase.cs
index 3fa718782..9fa83c23e 100644
--- a/src/PowerShellEditorServices/Debugging/BreakpointDetailsBase.cs
+++ b/src/PowerShellEditorServices/Debugging/BreakpointDetailsBase.cs
@@ -27,5 +27,10 @@ public abstract class BreakpointDetailsBase
         /// Gets the breakpoint condition string.
         /// </summary>
         public string Condition { get; protected set; }
+
+        /// <summary>
+        /// Gets the breakpoint hit condition string.
+        /// </summary>
+        public string HitCondition { get; protected set; }
     }
 }
diff --git a/src/PowerShellEditorServices/Debugging/CommandBreakpointDetails.cs b/src/PowerShellEditorServices/Debugging/CommandBreakpointDetails.cs
index 1d9468df4..8197480c9 100644
--- a/src/PowerShellEditorServices/Debugging/CommandBreakpointDetails.cs
+++ b/src/PowerShellEditorServices/Debugging/CommandBreakpointDetails.cs
@@ -29,10 +29,12 @@ private CommandBreakpointDetails()
         /// </summary>
         /// <param name="name">The name of the command to break on.</param>
         /// <param name="condition">Condition string that would be applied to the breakpoint Action parameter.</param>
+        /// <param name="hitCondition">Hit condition string that would be applied to the breakpoint Action parameter.</param>
         /// <returns></returns>
         public static CommandBreakpointDetails Create(
             string name,
-            string condition = null)
+            string condition = null,
+            string hitCondition = null)
         {
             Validate.IsNotNull(nameof(name), name);
 
diff --git a/src/PowerShellEditorServices/Debugging/DebugService.cs b/src/PowerShellEditorServices/Debugging/DebugService.cs
index 73c8e5a8e..9b7df6e61 100644
--- a/src/PowerShellEditorServices/Debugging/DebugService.cs
+++ b/src/PowerShellEditorServices/Debugging/DebugService.cs
@@ -8,7 +8,9 @@
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Language;
+using System.Text;
 using System.Threading.Tasks;
+using Microsoft.PowerShell.EditorServices.Debugging;
 using Microsoft.PowerShell.EditorServices.Utility;
 
 namespace Microsoft.PowerShell.EditorServices
@@ -33,6 +35,8 @@ public class DebugService
         private VariableContainerDetails scriptScopeVariables;
         private StackFrameDetails[] stackFrameDetails;
 
+        private static int breakpointHitCounter = 0;
+
         #endregion
 
         #region Constructors
@@ -100,7 +104,8 @@ public async Task<BreakpointDetails[]> SetLineBreakpoints(
                     }
 
                     // Check if this is a "conditional" line breakpoint.
-                    if (breakpoint.Condition != null)
+                    if (!String.IsNullOrWhiteSpace(breakpoint.Condition) ||
+                        !String.IsNullOrWhiteSpace(breakpoint.HitCondition))
                     {
                         ScriptBlock actionScriptBlock =
                             GetBreakpointActionScriptBlock(breakpoint);
@@ -155,7 +160,8 @@ public async Task<CommandBreakpointDetails[]> SetCommandBreakpoints(
                     psCommand.AddParameter("Command", breakpoint.Name);
 
                     // Check if this is a "conditional" command breakpoint.
-                    if (breakpoint.Condition != null)
+                    if (!String.IsNullOrWhiteSpace(breakpoint.Condition) ||
+                        !String.IsNullOrWhiteSpace(breakpoint.HitCondition))
                     {
                         ScriptBlock actionScriptBlock = GetBreakpointActionScriptBlock(breakpoint);
 
@@ -278,7 +284,7 @@ public VariableDetailsBase[] GetVariables(int variableReferenceId)
         /// </summary>
         /// <param name="variableExpression">The variable expression string to evaluate.</param>
         /// <param name="stackFrameId">The ID of the stack frame in which the expression should be evaluated.</param>
-        /// <returns>A VariableDetails object containing the result.</returns>
+        /// <returns>A VariableDetailsBase object containing the result.</returns>
         public VariableDetailsBase GetVariableFromExpression(string variableExpression, int stackFrameId)
         {
             // Break up the variable path
@@ -314,6 +320,154 @@ public VariableDetailsBase GetVariableFromExpression(string variableExpression,
             return resolvedVariable;
         }
 
+        /// <summary>
+        /// Sets the specified variable by container variableReferenceId and variable name to the
+        /// specified new value.  If the variable cannot be set or converted to that value this
+        /// method will throw InvalidPowerShellExpressionException, ArgumentTransformationMetadataException, or 
+        /// SessionStateUnauthorizedAccessException.
+        /// </summary>
+        /// <param name="variableContainerReferenceId">The container (Autos, Local, Script, Global) that holds the variable.</param>
+        /// <param name="name">The name of the variable prefixed with $.</param>
+        /// <param name="value">The new string value.  This value must not be null.  If you want to set the variable to $null
+        /// pass in the string "$null".</param>
+        /// <returns>The string representation of the value the variable was set to.</returns>
+        public async Task<string> SetVariable(int variableContainerReferenceId, string name, string value)
+        {
+            Validate.IsNotNull(nameof(name), name);
+            Validate.IsNotNull(nameof(value), value);
+
+            Logger.Write(LogLevel.Verbose, $"SetVariableRequest for '{name}' to value string (pre-quote processing): '{value}'");
+
+            // An empty or whitespace only value is not a valid expression for SetVariable.
+            if (value.Trim().Length == 0)
+            {
+                throw new InvalidPowerShellExpressionException("Expected an expression.");
+            }
+
+            // Evaluate the expression to get back a PowerShell object from the expression string.
+            PSCommand psCommand = new PSCommand();
+            psCommand.AddScript(value);
+            var errorMessages = new StringBuilder();
+            var results = 
+                await this.powerShellContext.ExecuteCommand<object>(
+                    psCommand, 
+                    errorMessages, 
+                    false, 
+                    false);
+
+            // Check if PowerShell's evaluation of the expression resulted in an error.
+            object psobject = results.FirstOrDefault();
+            if ((psobject == null) && (errorMessages.Length > 0))
+            {
+                throw new InvalidPowerShellExpressionException(errorMessages.ToString());
+            }
+
+            // If PowerShellContext.ExecuteCommand returns an ErrorRecord as output, the expression failed evaluation.  
+            // Ideally we would have a separate means from communicating error records apart from normal output. 
+            ErrorRecord errorRecord = psobject as ErrorRecord;
+            if (errorRecord != null)
+            {
+                throw new InvalidPowerShellExpressionException(errorRecord.ToString());
+            }
+
+            // OK, now we have a PS object from the supplied value string (expression) to assign to a variable.
+            // Get the variable referenced by variableContainerReferenceId and variable name.
+            VariableContainerDetails variableContainer = (VariableContainerDetails)this.variables[variableContainerReferenceId];
+            VariableDetailsBase variable = variableContainer.Children[name];
+
+            // Determine scope in which the variable lives. This is required later for the call to Get-Variable -Scope.
+            string scope = null;
+            if (variableContainerReferenceId == this.scriptScopeVariables.Id)
+            {
+                scope = "Script";
+            }
+            else if (variableContainerReferenceId == this.globalScopeVariables.Id)
+            {
+                scope = "Global";
+            }
+            else
+            {
+                // Determine which stackframe's local scope the variable is in.
+                for (int i = 0; i < this.stackFrameDetails.Length; i++)
+                {
+                    var stackFrame = this.stackFrameDetails[i];
+                    if (stackFrame.LocalVariables.ContainsVariable(variable.Id))
+                    {
+                        scope = i.ToString();
+                        break;
+                    }
+                }
+            }
+
+            if (scope == null)
+            {
+                // Hmm, this would be unexpected.  No scope means do not pass GO, do not collect $200.
+                throw new Exception("Could not find the scope for this variable.");
+            }
+
+            // Now that we have the scope, get the associated PSVariable object for the variable to be set.
+            psCommand.Commands.Clear();
+            psCommand = new PSCommand();
+            psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Get-Variable");
+            psCommand.AddParameter("Name", name.TrimStart('$'));
+            psCommand.AddParameter("Scope", scope);
+
+            IEnumerable<PSVariable> result = await this.powerShellContext.ExecuteCommand<PSVariable>(psCommand, sendErrorToHost: false);
+            PSVariable psVariable = result.FirstOrDefault();
+            if (psVariable == null)
+            {
+                throw new Exception($"Failed to retrieve PSVariable object for '{name}' from scope '{scope}'.");
+            }
+
+            // We have the PSVariable object for the variable the user wants to set and an object to assign to that variable.
+            // The last step is to determine whether the PSVariable is "strongly typed" which may require a conversion.
+            // If it is not strongly typed, we simply assign the object directly to the PSVariable potentially changing its type.
+            // Turns out ArgumentTypeConverterAttribute is not public. So we call the attribute through it's base class - 
+            // ArgumentTransformationAttribute.
+            var argTypeConverterAttr = 
+                psVariable.Attributes
+                          .OfType<ArgumentTransformationAttribute>()
+                          .FirstOrDefault(a => a.GetType().Name.Equals("ArgumentTypeConverterAttribute"));
+
+            if (argTypeConverterAttr != null)
+            {
+                // PSVariable is strongly typed. Need to apply the conversion/transform to the new value.
+                psCommand.Commands.Clear();
+                psCommand = new PSCommand();
+                psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Get-Variable");
+                psCommand.AddParameter("Name", "ExecutionContext");
+                psCommand.AddParameter("ValueOnly");
+
+                errorMessages.Clear();
+
+                var getExecContextResults = 
+                    await this.powerShellContext.ExecuteCommand<object>(
+                        psCommand, 
+                        errorMessages, 
+                        sendErrorToHost: false);
+
+                EngineIntrinsics executionContext = getExecContextResults.OfType<EngineIntrinsics>().FirstOrDefault();
+
+                var msg = $"Setting variable '{name}' using conversion to value: {psobject ?? "<null>"}";
+                Logger.Write(LogLevel.Verbose, msg);
+
+                psVariable.Value = argTypeConverterAttr.Transform(executionContext, psobject);
+            }
+            else
+            {
+                // PSVariable is *not* strongly typed. In this case, whack the old value with the new value.
+                var msg = $"Setting variable '{name}' directly to value: {psobject ?? "<null>"} - previous type was {psVariable.Value?.GetType().Name ?? "<unknown>"}";
+                Logger.Write(LogLevel.Verbose, msg);
+                psVariable.Value = psobject;
+            }
+
+            // Use the VariableDetails.ValueString functionality to get the string representation for client debugger.
+            // This makes the returned string consistent with the strings normally displayed for variables in the debugger.
+            var tempVariable = new VariableDetails(psVariable);
+            Logger.Write(LogLevel.Verbose, $"Set variable '{name}' to: {tempVariable.ValueString ?? "<null>"}");
+            return tempVariable.ValueString;
+        }
+
         /// <summary>
         /// Evaluates an expression in the context of the stopped
         /// debugger.  This method will execute the specified expression
@@ -569,32 +723,85 @@ private ScriptBlock GetBreakpointActionScriptBlock(
         {
             try
             {
-                ScriptBlock actionScriptBlock = ScriptBlock.Create(breakpoint.Condition);
+                ScriptBlock actionScriptBlock;
+                int? hitCount = null;
 
-                // Check for simple, common errors that ScriptBlock parsing will not catch 
-                // e.g. $i == 3 and $i > 3
-                string message;
-                if (!ValidateBreakpointConditionAst(actionScriptBlock.Ast, out message))
+                // If HitCondition specified, parse and verify it.
+                if (!(String.IsNullOrWhiteSpace(breakpoint.HitCondition)))
                 {
-                    breakpoint.Verified = false;
-                    breakpoint.Message = message;
-                    return null;
+                    int parsedHitCount;
+
+                    if (Int32.TryParse(breakpoint.HitCondition, out parsedHitCount))
+                    {
+                        hitCount = parsedHitCount;
+                    }
+                    else
+                    {
+                        breakpoint.Verified = false;
+                        breakpoint.Message = $"The specified HitCount '{breakpoint.HitCondition}' is not valid. " +
+                                              "The HitCount must be an integer number.";
+                        return null;
+                    }
                 }
 
-                // Check for "advanced" condition syntax i.e. if the user has specified
-                // a "break" or  "continue" statement anywhere in their scriptblock,
-                // pass their scriptblock through to the Action parameter as-is.
-                Ast breakOrContinueStatementAst =
-                    actionScriptBlock.Ast.Find(
-                        ast => (ast is BreakStatementAst || ast is ContinueStatementAst), true);
-
-                // If this isn't advanced syntax then the conditions string should be a simple
-                // expression that needs to be wrapped in a "if" test that conditionally executes
-                // a break statement.
-                if (breakOrContinueStatementAst == null)
+                // Create an Action scriptblock based on condition and/or hit count passed in.
+                if (hitCount.HasValue && String.IsNullOrWhiteSpace(breakpoint.Condition))
+                {
+                    // In the HitCount only case, this is simple as we can just use the HitCount 
+                    // property on the breakpoint object which is represented by $_.
+                    string action = $"if ($_.HitCount -eq {hitCount}) {{ break }}";
+                    actionScriptBlock = ScriptBlock.Create(action);
+                }
+                else if (!String.IsNullOrWhiteSpace(breakpoint.Condition))
+                {
+                    // Must be either condition only OR condition and hit count.
+                    actionScriptBlock = ScriptBlock.Create(breakpoint.Condition);
+
+                    // Check for simple, common errors that ScriptBlock parsing will not catch 
+                    // e.g. $i == 3 and $i > 3
+                    string message;
+                    if (!ValidateBreakpointConditionAst(actionScriptBlock.Ast, out message))
+                    {
+                        breakpoint.Verified = false;
+                        breakpoint.Message = message;
+                        return null;
+                    }
+
+                    // Check for "advanced" condition syntax i.e. if the user has specified
+                    // a "break" or  "continue" statement anywhere in their scriptblock,
+                    // pass their scriptblock through to the Action parameter as-is.
+                    Ast breakOrContinueStatementAst =
+                        actionScriptBlock.Ast.Find(
+                            ast => (ast is BreakStatementAst || ast is ContinueStatementAst), true);
+
+                    // If this isn't advanced syntax then the conditions string should be a simple
+                    // expression that needs to be wrapped in a "if" test that conditionally executes
+                    // a break statement.
+                    if (breakOrContinueStatementAst == null)
+                    {
+                        string wrappedCondition;
+
+                        if (hitCount.HasValue)
+                        {
+                            string globalHitCountVarName =
+                                $"$global:__psEditorServices_BreakHitCounter_{breakpointHitCounter++}";
+
+                            wrappedCondition =
+                                $"if ({breakpoint.Condition}) {{ if (++{globalHitCountVarName} -eq {hitCount}) {{ break }} }}";
+                        }
+                        else
+                        {
+                            wrappedCondition = $"if ({breakpoint.Condition}) {{ break }}";
+                        }
+
+                        actionScriptBlock = ScriptBlock.Create(wrappedCondition);
+                    }
+                }
+                else
                 {
-                    string wrappedCondition = $"if ({breakpoint.Condition}) {{ break }}";
-                    actionScriptBlock = ScriptBlock.Create(wrappedCondition);
+                    // Shouldn't get here unless someone called this with no condition and no hit count.
+                    actionScriptBlock = ScriptBlock.Create("break");
+                    Logger.Write(LogLevel.Warning, "No condition and no hit count specified by caller.");
                 }
 
                 return actionScriptBlock;
diff --git a/src/PowerShellEditorServices/Debugging/InvalidPowerShellExpressionException.cs b/src/PowerShellEditorServices/Debugging/InvalidPowerShellExpressionException.cs
new file mode 100644
index 000000000..fd6b13caf
--- /dev/null
+++ b/src/PowerShellEditorServices/Debugging/InvalidPowerShellExpressionException.cs
@@ -0,0 +1,24 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+
+namespace Microsoft.PowerShell.EditorServices.Debugging
+{
+    /// <summary>
+    /// Represents the exception that is thrown when an invalid expression is provided to the DebugService's SetVariable method.
+    /// </summary>
+    public class InvalidPowerShellExpressionException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the SetVariableExpressionException class.
+        /// </summary>
+        /// <param name="message">Message indicating why the expression is invalid.</param>
+        public InvalidPowerShellExpressionException(string message) 
+            : base(message)
+        {
+        }
+    }
+}
diff --git a/src/PowerShellEditorServices/Debugging/VariableContainerDetails.cs b/src/PowerShellEditorServices/Debugging/VariableContainerDetails.cs
index 6b98c53c9..8f60dccfe 100644
--- a/src/PowerShellEditorServices/Debugging/VariableContainerDetails.cs
+++ b/src/PowerShellEditorServices/Debugging/VariableContainerDetails.cs
@@ -77,5 +77,23 @@ public override VariableDetailsBase[] GetChildren()
             this.children.Values.CopyTo(variablesArray, 0);
             return variablesArray;
         }
+
+        /// <summary>
+        /// Determines whether this variable container contains the specified variable by its referenceId.
+        /// </summary>
+        /// <param name="variableReferenceId">The variableReferenceId to search for.</param>
+        /// <returns>Returns true if this variable container directly contains the specified variableReferenceId, false otherwise.</returns>
+        public bool ContainsVariable(int variableReferenceId)
+        {
+            foreach (VariableDetailsBase value in this.children.Values)
+            {
+                if (value.Id == variableReferenceId)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
     }
 }
diff --git a/src/PowerShellEditorServices/Debugging/VariableDetails.cs b/src/PowerShellEditorServices/Debugging/VariableDetails.cs
index 33ed94ab3..8a76e0899 100644
--- a/src/PowerShellEditorServices/Debugging/VariableDetails.cs
+++ b/src/PowerShellEditorServices/Debugging/VariableDetails.cs
@@ -145,7 +145,13 @@ private static string GetValueString(object value, bool isExpandable)
 
             if (value == null)
             {
-                valueString = "null";
+                // Set to identifier recognized by PowerShell to make setVariable from the debug UI more natural.
+                valueString = "$null";
+            }
+            else if (value is bool)
+            {
+                // Set to identifier recognized by PowerShell to make setVariable from the debug UI more natural.
+                valueString = (bool) value ? "$true" : "$false";
             }
             else if (isExpandable)
             {
diff --git a/src/PowerShellEditorServices/Extensions/EditorObject.cs b/src/PowerShellEditorServices/Extensions/EditorObject.cs
index c81088ea2..4a1cce908 100644
--- a/src/PowerShellEditorServices/Extensions/EditorObject.cs
+++ b/src/PowerShellEditorServices/Extensions/EditorObject.cs
@@ -37,6 +37,11 @@ public Version EditorServicesVersion
         /// </summary>
         public EditorWorkspace Workspace { get; private set; }
 
+        /// <summary>
+        /// Gets the window interface for the editor API.
+        /// </summary>
+        public EditorWindow Window { get; private set; }
+
         #endregion
 
         /// <summary>
@@ -53,6 +58,7 @@ public EditorObject(
 
             // Create API area objects
             this.Workspace = new EditorWorkspace(this.editorOperations);
+            this.Window = new EditorWindow(this.editorOperations);
         }
 
         /// <summary>
@@ -82,7 +88,7 @@ public void UnregisterCommand(string commandName)
         public EditorContext GetEditorContext()
         {
             return this.editorOperations.GetEditorContext().Result;
-       }
+        }
     }
 }
 
diff --git a/src/PowerShellEditorServices/Extensions/EditorWindow.cs b/src/PowerShellEditorServices/Extensions/EditorWindow.cs
new file mode 100644
index 000000000..0ffd125f0
--- /dev/null
+++ b/src/PowerShellEditorServices/Extensions/EditorWindow.cs
@@ -0,0 +1,83 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.PowerShell.EditorServices.Extensions
+{
+    /// <summary>
+    /// Provides a PowerShell-facing API which allows scripts to
+    /// interact with the editor's window.
+    /// </summary>
+    public class EditorWindow
+    {
+        #region Private Fields
+
+        private IEditorOperations editorOperations;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new instance of the EditorWindow class.
+        /// </summary>
+        /// <param name="editorOperations">An IEditorOperations implementation which handles operations in the host editor.</param>
+        internal EditorWindow(IEditorOperations editorOperations)
+        {
+            this.editorOperations = editorOperations;
+        }
+
+        #endregion 
+
+        #region Public Methods
+
+        /// <summary>
+        /// Shows an informational message to the user.
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        public void ShowInformationMessage(string message)
+        {
+            this.editorOperations.ShowInformationMessage(message).Wait();
+        }
+
+        /// <summary>
+        /// Shows an error message to the user.
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        public void ShowErrorMessage(string message)
+        {
+            this.editorOperations.ShowErrorMessage(message).Wait();
+        }
+
+        /// <summary>
+        /// Shows a warning message to the user.
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        public void ShowWarningMessage(string message)
+        {
+            this.editorOperations.ShowWarningMessage(message).Wait();
+        }
+
+        /// <summary>
+        /// Sets the status bar message in the editor UI (if applicable).
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        public void SetStatusBarMessage(string message)
+        {
+            this.editorOperations.SetStatusBarMessage(message, null).Wait();
+        }
+
+        /// <summary>
+        /// Sets the status bar message in the editor UI (if applicable).
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        /// <param name="timeout">A timeout in milliseconds for how long the message should remain visible.</param>
+        public void SetStatusBarMessage(string message, int timeout)
+        {
+            this.editorOperations.SetStatusBarMessage(message, timeout).Wait();
+        }
+
+        #endregion 
+    }
+}
diff --git a/src/PowerShellEditorServices/Extensions/IEditorOperations.cs b/src/PowerShellEditorServices/Extensions/IEditorOperations.cs
index 80da54774..7f6845d6e 100644
--- a/src/PowerShellEditorServices/Extensions/IEditorOperations.cs
+++ b/src/PowerShellEditorServices/Extensions/IEditorOperations.cs
@@ -43,6 +43,35 @@ public interface IEditorOperations
         /// <param name="selectionRange">The range over which the selection will be made.</param>
         /// <returns>A Task that can be tracked for completion.</returns>
         Task SetSelection(BufferRange selectionRange);
+
+        /// <summary>
+        /// Shows an informational message to the user.
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        /// <returns>A Task that can be tracked for completion.</returns>
+        Task ShowInformationMessage(string message);
+
+        /// <summary>
+        /// Shows an error message to the user.
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        /// <returns>A Task that can be tracked for completion.</returns>
+        Task ShowErrorMessage(string message);
+
+        /// <summary>
+        /// Shows a warning message to the user.
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        /// <returns>A Task that can be tracked for completion.</returns>
+        Task ShowWarningMessage(string message);
+
+        /// <summary>
+        /// Sets the status bar message in the editor UI (if applicable).
+        /// </summary>
+        /// <param name="message">The message to be shown.</param>
+        /// <param name="timeout">If non-null, a timeout in milliseconds for how long the message should remain visible.</param>
+        /// <returns>A Task that can be tracked for completion.</returns>
+        Task SetStatusBarMessage(string message, int? timeout);
     }
 }
 
diff --git a/src/PowerShellEditorServices/Nano.PowerShellEditorServices.csproj b/src/PowerShellEditorServices/Nano.PowerShellEditorServices.csproj
index 674cf0070..a5377a016 100644
--- a/src/PowerShellEditorServices/Nano.PowerShellEditorServices.csproj
+++ b/src/PowerShellEditorServices/Nano.PowerShellEditorServices.csproj
@@ -51,6 +51,7 @@
     <Compile Include="Debugging\BreakpointDetailsBase.cs" />
     <Compile Include="Debugging\DebugService.cs" />
     <Compile Include="Debugging\CommandBreakpointDetails.cs" />
+    <Compile Include="Debugging\InvalidPowerShellExpressionException.cs" />
     <Compile Include="Debugging\StackFrameDetails.cs" />
     <Compile Include="Debugging\VariableDetails.cs" />
     <Compile Include="Debugging\VariableDetailsBase.cs" />
@@ -58,6 +59,7 @@
     <Compile Include="Debugging\VariableContainerDetails.cs" />
     <Compile Include="Extensions\EditorContext.cs" />
     <Compile Include="Extensions\EditorObject.cs" />
+    <Compile Include="Extensions\EditorWindow.cs" />
     <Compile Include="Extensions\EditorWorkspace.cs" />
     <Compile Include="Extensions\EditorCommand.cs" />
     <Compile Include="Extensions\ExtensionService.cs" />
@@ -96,6 +98,7 @@
     <Compile Include="Session\PowerShellExecutionResult.cs" />
     <Compile Include="Session\PowerShellContext.cs" />
     <Compile Include="Session\PowerShellContextState.cs" />
+    <Compile Include="Session\PowerShellVersionDetails.cs" />
     <Compile Include="Session\ProfilePaths.cs" />
     <Compile Include="Session\ProgressDetails.cs" />
     <Compile Include="Session\RunspaceHandle.cs" />
@@ -136,6 +139,7 @@
     <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\EditorCommands.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\FindModuleRequest.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\InstallModuleRequest.cs" />
+    <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\PowerShellVersionRequest.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\MessageProtocol\Channel\NamedPipeClientChannel.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\MessageProtocol\Channel\NamedPipeServerChannel.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\MessageProtocol\Channel\TcpSocketClientChannel.cs" />
@@ -158,6 +162,7 @@
     <Compile Include="..\PowerShellEditorServices.Protocol\DebugAdapter\Scope.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\DebugAdapter\ScopesRequest.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\DebugAdapter\SetBreakpointsRequest.cs" />
+    <Compile Include="..\PowerShellEditorServices.Protocol\DebugAdapter\SetVariableRequest.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\DebugAdapter\SetExceptionBreakpointsRequest.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\DebugAdapter\Source.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\DebugAdapter\SourceRequest.cs" />
@@ -188,6 +193,7 @@
     <Compile Include="..\PowerShellEditorServices.Protocol\MessageProtocol\Channel\StdioClientChannel.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\MessageProtocol\EventContext.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\MessageProtocol\EventType.cs" />
+    <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\CodeAction.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\ClientCapabilities.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\Completion.cs" />
     <Compile Include="..\PowerShellEditorServices.Protocol\LanguageServer\Diagnostics.cs" />
diff --git a/src/PowerShellEditorServices/PowerShellEditorServices.csproj b/src/PowerShellEditorServices/PowerShellEditorServices.csproj
index 16d278f3c..e1ab2ea27 100644
--- a/src/PowerShellEditorServices/PowerShellEditorServices.csproj
+++ b/src/PowerShellEditorServices/PowerShellEditorServices.csproj
@@ -71,6 +71,7 @@
     <Compile Include="Debugging\BreakpointDetailsBase.cs" />
     <Compile Include="Debugging\DebugService.cs" />
     <Compile Include="Debugging\CommandBreakpointDetails.cs" />
+    <Compile Include="Debugging\InvalidPowerShellExpressionException.cs" />
     <Compile Include="Debugging\StackFrameDetails.cs" />
     <Compile Include="Debugging\VariableDetails.cs" />
     <Compile Include="Debugging\VariableDetailsBase.cs" />
@@ -78,6 +79,7 @@
     <Compile Include="Debugging\VariableContainerDetails.cs" />
     <Compile Include="Extensions\EditorContext.cs" />
     <Compile Include="Extensions\EditorObject.cs" />
+    <Compile Include="Extensions\EditorWindow.cs" />
     <Compile Include="Extensions\EditorWorkspace.cs" />
     <Compile Include="Extensions\EditorCommand.cs" />
     <Compile Include="Extensions\ExtensionService.cs" />
@@ -116,6 +118,7 @@
     <Compile Include="Session\PowerShellExecutionResult.cs" />
     <Compile Include="Session\PowerShellContext.cs" />
     <Compile Include="Session\PowerShellContextState.cs" />
+    <Compile Include="Session\PowerShellVersionDetails.cs" />
     <Compile Include="Session\ProfilePaths.cs" />
     <Compile Include="Session\ProgressDetails.cs" />
     <Compile Include="Session\RunspaceHandle.cs" />
diff --git a/src/PowerShellEditorServices/Session/PowerShellContext.cs b/src/PowerShellEditorServices/Session/PowerShellContext.cs
index 78c13798c..280220372 100644
--- a/src/PowerShellEditorServices/Session/PowerShellContext.cs
+++ b/src/PowerShellEditorServices/Session/PowerShellContext.cs
@@ -75,12 +75,20 @@ public PowerShellContextState SessionState
             private set;
         }
 
+        /// <summary>
+        /// Gets the PowerShell version details for the current runspace.
+        /// </summary>
+        public PowerShellVersionDetails PowerShellVersionDetails
+        {
+            get; private set;
+        }
+
         /// <summary>
         /// Gets the PowerShell version of the current runspace.
         /// </summary>
         public Version PowerShellVersion
         {
-            get; private set;
+            get { return this.PowerShellVersionDetails.Version; }
         }
 
         /// <summary>
@@ -88,7 +96,7 @@ public Version PowerShellVersion
         /// </summary>
         public string PowerShellEdition
         {
-            get; private set;
+            get { return this.PowerShellVersionDetails.Edition; }
         }
 
         /// <summary>
@@ -188,9 +196,7 @@ private void Initialize(ProfilePaths profilePaths, Runspace initialRunspace)
             this.powerShell.Runspace = this.currentRunspace;
 
             // Get the PowerShell runtime version
-            Tuple<Version, string> versionEditionTuple = GetPowerShellVersion();
-            this.PowerShellVersion = versionEditionTuple.Item1;
-            this.PowerShellEdition = versionEditionTuple.Item2;
+            this.PowerShellVersionDetails = GetPowerShellVersion();
 
             // Write out the PowerShell version for tracking purposes
             Logger.Write(
@@ -246,27 +252,57 @@ private void Initialize(ProfilePaths profilePaths, Runspace initialRunspace)
             this.runspaceWaitQueue.EnqueueAsync(runspaceHandle).Wait();
         }
 
-        private Tuple<Version, string> GetPowerShellVersion()
+        private PowerShellVersionDetails GetPowerShellVersion()
         {
             Version powerShellVersion = new Version(5, 0);
+            string versionString = null;
             string powerShellEdition = "Desktop";
+            var architecture = PowerShellProcessArchitecture.Unknown;
 
             try
             {
                 var psVersionTable = this.currentRunspace.SessionStateProxy.GetVariable("PSVersionTable") as Hashtable;
                 if (psVersionTable != null)
                 {
-                    var version = psVersionTable["PSVersion"] as Version;
-                    if (version != null)
-                    {
-                        powerShellVersion = version;
-                    }
-
                     var edition = psVersionTable["PSEdition"] as string;
                     if (edition != null)
                     {
                         powerShellEdition = edition;
                     }
+
+                    // The PSVersion value will either be of Version or SemanticVersion.
+                    // In the former case, take the value directly.  In the latter case,
+                    // generate a Version from its string representation.
+                    var version = psVersionTable["PSVersion"];
+                    if (version is Version)
+                    {
+                        powerShellVersion = (Version)version;
+                    }
+                    else if (string.Equals(powerShellEdition, "Core", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        // Expected version string format is 6.0.0-alpha so build a simpler version from that
+                        powerShellVersion = new Version(version.ToString().Split('-')[0]);
+                    }
+
+                    var gitCommitId = psVersionTable["GitCommitId"] as string;
+                    if (gitCommitId != null)
+                    {
+                        versionString = gitCommitId;
+                    }
+                    else
+                    {
+                        versionString = powerShellVersion.ToString();
+                    }
+
+                    var arch = this.currentRunspace.SessionStateProxy.GetVariable("env:PROCESSOR_ARCHITECTURE") as string;
+                    if (string.Equals(arch, "AMD64", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        architecture = PowerShellProcessArchitecture.X64;
+                    }
+                    else if (string.Equals(arch, "x86", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        architecture = PowerShellProcessArchitecture.X86;
+                    }
                 }
             }
             catch (Exception ex)
@@ -274,7 +310,11 @@ private Tuple<Version, string> GetPowerShellVersion()
                 Logger.Write(LogLevel.Warning, "Failed to look up PowerShell version. Defaulting to version 5. " + ex.Message);
             }
 
-            return new Tuple<Version, string>(powerShellVersion, powerShellEdition);
+            return new PowerShellVersionDetails(
+                powerShellVersion,
+                versionString,
+                powerShellEdition,
+                architecture);
         }
 
         #endregion
@@ -324,6 +364,33 @@ public async Task<IEnumerable<TResult>> ExecuteCommand<TResult>(
             PSCommand psCommand,
             bool sendOutputToHost = false,
             bool sendErrorToHost = true)
+        {
+            return await ExecuteCommand<TResult>(psCommand, null, sendOutputToHost, sendErrorToHost);
+        }
+
+        /// <summary>
+        /// Executes a PSCommand against the session's runspace and returns
+        /// a collection of results of the expected type.
+        /// </summary>
+        /// <typeparam name="TResult">The expected result type.</typeparam>
+        /// <param name="psCommand">The PSCommand to be executed.</param>
+        /// <param name="errorMessages">Error messages from PowerShell will be written to the StringBuilder. 
+        /// You must set sendErrorToHost to false for errors to be written to the StringBuilder. This value can be null.</param>
+        /// <param name="sendOutputToHost">
+        /// If true, causes any output written during command execution to be written to the host.
+        /// </param>
+        /// <param name="sendErrorToHost">
+        /// If true, causes any errors encountered during command execution to be written to the host.
+        /// </param>
+        /// <returns>
+        /// An awaitable Task which will provide results once the command
+        /// execution completes.
+        /// </returns>
+        public async Task<IEnumerable<TResult>> ExecuteCommand<TResult>(
+            PSCommand psCommand,
+            StringBuilder errorMessages,
+            bool sendOutputToHost = false,
+            bool sendErrorToHost = true)
         {
             RunspaceHandle runspaceHandle = null;
             IEnumerable<TResult> executionResult = Enumerable.Empty<TResult>();
@@ -337,7 +404,7 @@ public async Task<IEnumerable<TResult>> ExecuteCommand<TResult>(
 
                 PipelineExecutionRequest<TResult> executionRequest =
                     new PipelineExecutionRequest<TResult>(
-                        this, psCommand, sendOutputToHost);
+                        this, psCommand, errorMessages, sendOutputToHost);
 
                 // Send the pipeline execution request to the pipeline thread
                 this.pipelineResultTask = new TaskCompletionSource<IPipelineExecutionRequest>();
@@ -415,6 +482,7 @@ await Task.Factory.StartNew<IEnumerable<TResult>>(
                                 errorMessage += error.ToString() + "\r\n";
                             }
 
+                            errorMessages?.Append(errorMessage);
                             Logger.Write(LogLevel.Error, errorMessage);
                         }
                         else
@@ -433,6 +501,8 @@ await Task.Factory.StartNew<IEnumerable<TResult>>(
                         LogLevel.Error,
                         "Runtime exception occurred while executing command:\r\n\r\n" + e.ToString());
 
+                    errorMessages?.Append(e.Message);
+
                     if (sendErrorToHost)
                     {
                         // Write the error to the host
@@ -1211,6 +1281,7 @@ private class PipelineExecutionRequest<TResult> : IPipelineExecutionRequest
         {
             PowerShellContext powerShellContext;
             PSCommand psCommand;
+            StringBuilder errorMessages;
             bool sendOutputToHost;
 
             public IEnumerable<TResult> Results { get; private set; }
@@ -1218,10 +1289,12 @@ private class PipelineExecutionRequest<TResult> : IPipelineExecutionRequest
             public PipelineExecutionRequest(
                 PowerShellContext powerShellContext,
                 PSCommand psCommand,
+                StringBuilder errorMessages,
                 bool sendOutputToHost)
             {
                 this.powerShellContext = powerShellContext;
                 this.psCommand = psCommand;
+                this.errorMessages = errorMessages;
                 this.sendOutputToHost = sendOutputToHost;
             }
 
@@ -1230,6 +1303,7 @@ public async Task Execute()
                 this.Results =
                     await this.powerShellContext.ExecuteCommand<TResult>(
                         psCommand,
+                        errorMessages,
                         sendOutputToHost);
 
                 // TODO: Deal with errors?
diff --git a/src/PowerShellEditorServices/Session/PowerShellVersionDetails.cs b/src/PowerShellEditorServices/Session/PowerShellVersionDetails.cs
new file mode 100644
index 000000000..9f8a596e0
--- /dev/null
+++ b/src/PowerShellEditorServices/Session/PowerShellVersionDetails.cs
@@ -0,0 +1,76 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+
+namespace Microsoft.PowerShell.EditorServices.Session
+{
+    /// <summary>
+    /// Defines the possible enumeration values for the PowerShell process architecture.
+    /// </summary>
+    public enum PowerShellProcessArchitecture
+    {
+        /// <summary>
+        /// The processor architecture is unknown or wasn't accessible.
+        /// </summary>
+        Unknown,
+
+        /// <summary>
+        /// The processor architecture is 32-bit.
+        /// </summary>
+        X86,
+
+        /// <summary>
+        /// The processor architecture is 64-bit.
+        /// </summary>
+        X64
+    }
+
+    /// <summary>
+    /// Provides details about the version of the PowerShell runtime.
+    /// </summary>
+    public class PowerShellVersionDetails
+    {
+        /// <summary>
+        /// Gets the version of the PowerShell runtime.
+        /// </summary>
+        public Version Version { get; private set; }
+        
+        /// <summary>
+        /// Gets the full version string, either the ToString of the Version
+        /// property or the GitCommitId for open-source PowerShell releases.
+        /// </summary>
+        public string VersionString { get; private set; }
+
+        /// <summary>
+        /// Gets the PowerShell edition (generally Desktop or Core).
+        /// </summary>
+        public string Edition { get; private set; }
+
+        /// <summary>
+        /// Gets the architecture of the PowerShell process.
+        /// </summary>
+        public PowerShellProcessArchitecture Architecture { get; private set; }
+
+        /// <summary>
+        /// Creates an instance of the PowerShellVersionDetails class.
+        /// </summary>
+        /// <param name="version">The version of the PowerShell runtime.</param>
+        /// <param name="versionString">A string representation of the PowerShell version.</param>
+        /// <param name="editionString">The string representation of the PowerShell edition.</param>
+        /// <param name="architecture">The processor architecture.</param>
+        public PowerShellVersionDetails(
+            Version version,
+            string versionString,
+            string editionString,
+            PowerShellProcessArchitecture architecture)
+        {
+            this.Version = version;
+            this.VersionString = versionString;
+            this.Edition = editionString;
+            this.Architecture = architecture;
+        }
+    }
+}
diff --git a/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs b/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs
index 1d195729a..d6677e2bd 100644
--- a/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs
+++ b/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs
@@ -6,10 +6,28 @@
 using Microsoft.PowerShell.EditorServices.Utility;
 using System;
 using System.Management.Automation;
+using System.Collections.Generic;
+using System.Linq;
 using System.Management.Automation.Language;
 
 namespace Microsoft.PowerShell.EditorServices
 {
+    /// <summary>
+    /// Contains details for a code correction which can be applied from a ScriptFileMarker.
+    /// </summary>
+    public class MarkerCorrection
+    {
+        /// <summary>
+        /// Gets or sets the display name of the code correction.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the list of ScriptRegions that define the edits to be made by the correction.
+        /// </summary>
+        public ScriptRegion[] Edits { get; set; }
+    }
+
     /// <summary>
     /// Defines the message level of a script file marker.
     /// </summary>
@@ -55,6 +73,11 @@ public class ScriptFileMarker
         /// </summary>
         public ScriptRegion ScriptRegion { get; set; }
 
+        /// <summary>
+        /// Gets or sets an optional code correction that can be applied based on this marker.
+        /// </summary>
+        public MarkerCorrection Correction { get; set; }
+
         #endregion
 
         #region Public Methods
@@ -72,7 +95,7 @@ internal static ScriptFileMarker FromParseError(
             };
         }
         private static string GetIfExistsString(PSObject psobj, string memberName)
-        {            
+        {
             if (psobj.Members.Match(memberName).Count > 0)
             {
                 return psobj.Members[memberName].Value != null ? (string)psobj.Members[memberName].Value : "";
@@ -80,18 +103,60 @@ private static string GetIfExistsString(PSObject psobj, string memberName)
             else
             {
                 return "";
-            }            
+            }
         }
 
         internal static ScriptFileMarker FromDiagnosticRecord(PSObject psObject)
         {
             Validate.IsNotNull("psObject", psObject);
+            MarkerCorrection correction = null;
+
+            // make sure psobject is of type DiagnosticRecord
+            if (!psObject.TypeNames.Contains(
+                    "Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic.DiagnosticRecord",
+                    StringComparer.OrdinalIgnoreCase))
+            {
+                throw new ArgumentException("Input PSObject must of DiagnosticRecord type.");
+            }
+
+            // casting psobject to dynamic allows us to access
+            // the diagnostic record's properties directly i.e. <instance>.<propertyName>
+            // without having to go through PSObject's Members property.
+            var diagnosticRecord = psObject as dynamic;
+            string ruleName = diagnosticRecord.RuleName as string;
+
+            if (diagnosticRecord.SuggestedCorrections != null)
+            {
+                var suggestedCorrections = diagnosticRecord.SuggestedCorrections as dynamic;
+                List<ScriptRegion> editRegions = new List<ScriptRegion>();
+                string correctionMessage = null;
+                foreach (var suggestedCorrection in suggestedCorrections)
+                {
+                    editRegions.Add(new ScriptRegion
+                    {
+                        File = diagnosticRecord.ScriptPath,
+                        Text = suggestedCorrection.Text,
+                        StartLineNumber = suggestedCorrection.StartLineNumber,
+                        StartColumnNumber = suggestedCorrection.StartColumnNumber,
+                        EndLineNumber = suggestedCorrection.EndLineNumber,
+                        EndColumnNumber = suggestedCorrection.EndColumnNumber
+                    });
+                    correctionMessage = suggestedCorrection.Description;
+                }
+
+                correction = new MarkerCorrection
+                {
+                    Name = correctionMessage == null ? diagnosticRecord.Message : correctionMessage,
+                    Edits = editRegions.ToArray()
+                };
+            }
+
             return new ScriptFileMarker
             {
-                Message = GetIfExistsString(psObject, "Message"),
-                //Level = GetMarkerLevelFromDiagnosticSeverity(GetIfExistsString(psObject, "Severity")),
-                Level = GetMarkerLevelFromDiagnosticSeverity("Warning"),
-                ScriptRegion = ScriptRegion.Create((IScriptExtent)psObject.Members["Extent"].Value)
+                Message = diagnosticRecord.Message as string,
+                Level = GetMarkerLevelFromDiagnosticSeverity((diagnosticRecord.Severity as Enum).ToString()),
+                ScriptRegion = ScriptRegion.Create(diagnosticRecord.Extent as IScriptExtent),
+                Correction = correction
             };
         }
 
diff --git a/submodules/PSScriptAnalyzer b/submodules/PSScriptAnalyzer
deleted file mode 160000
index e19af12de..000000000
--- a/submodules/PSScriptAnalyzer
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e19af12de15d9c8c6ec3defe307e37a8a89d0993
diff --git a/test/PowerShellEditorServices.Test.Host/LanguageServerTests.cs b/test/PowerShellEditorServices.Test.Host/LanguageServerTests.cs
index 1381a4fa2..d2e037265 100644
--- a/test/PowerShellEditorServices.Test.Host/LanguageServerTests.cs
+++ b/test/PowerShellEditorServices.Test.Host/LanguageServerTests.cs
@@ -702,6 +702,21 @@ await this.languageServiceClient.SendEvent(
             Assert.Equal("PROFILE: True", outputString);
         }
 
+        [Fact]
+        public async Task ServiceReturnsPowerShellVersionDetails()
+        {
+            PowerShellVersionResponse versionDetails =
+                await this.SendRequest(
+                    PowerShellVersionRequest.Type,
+                    new PowerShellVersionRequest());
+
+            // TODO: This should be more robust and predictable.
+            Assert.StartsWith("5.", versionDetails.Version);
+            Assert.StartsWith("5.", versionDetails.DisplayVersion);
+            Assert.Equal("Desktop", versionDetails.Edition);
+            Assert.Equal("x86", versionDetails.Architecture);
+        }
+
         private async Task SendOpenFileEvent(string filePath, bool waitForDiagnostics = true)
         {
             string fileContents = string.Join(Environment.NewLine, File.ReadAllLines(filePath));
diff --git a/test/PowerShellEditorServices.Test.Shared/Debugging/VariableTest.ps1 b/test/PowerShellEditorServices.Test.Shared/Debugging/VariableTest.ps1
index 32e238dab..7398d8c01 100644
--- a/test/PowerShellEditorServices.Test.Shared/Debugging/VariableTest.ps1
+++ b/test/PowerShellEditorServices.Test.Shared/Debugging/VariableTest.ps1
@@ -1,11 +1,11 @@
 class MyClass {
 	[String] $Name;
-	[Int32] $Number;
-}
-
-function Test-Variables
-{
-	$strVar = "Hello"
+	[Int32] $Number; }
+[bool]$scriptBool = $false
+$scriptInt = 42
+function Test-Variables {
+    $strVar = "Hello"
+	[string]$strVar2 = "Hello2"
 	$arrVar = @(1, 2, $strVar, $objVar)
 	$assocArrVar = @{ firstChild = "Child"; secondChild = 42 }
 	$classVar = [MyClass]::new();
diff --git a/test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs b/test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs
index e9a220a06..4e8aa6ec4 100644
--- a/test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs
+++ b/test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs
@@ -336,6 +336,79 @@ await this.debugService.SetLineBreakpoints(
             await executeTask;
         }
 
+        [Fact]
+        public async Task DebuggerStopsOnHitConditionBreakpoint()
+        {
+            const int hitCount = 5;
+
+            BreakpointDetails[] breakpoints =
+                await this.debugService.SetLineBreakpoints(
+                    this.debugScriptFile,
+                    new[] {
+                        BreakpointDetails.Create("", 6, null, null, $"{hitCount}"),
+                    });
+
+            await this.AssertStateChange(PowerShellContextState.Ready);
+
+            Task executeTask =
+                this.powerShellContext.ExecuteScriptAtPath(
+                    this.debugScriptFile.FilePath);
+
+            // Wait for conditional breakpoint to hit
+            await this.AssertDebuggerStopped(this.debugScriptFile.FilePath, 6);
+
+            StackFrameDetails[] stackFrames = debugService.GetStackFrames();
+            VariableDetailsBase[] variables =
+                debugService.GetVariables(stackFrames[0].LocalVariables.Id);
+
+            // Verify the breakpoint only broke at the condition ie. $i -eq breakpointValue1
+            var i = variables.FirstOrDefault(v => v.Name == "$i");
+            Assert.NotNull(i);
+            Assert.False(i.IsExpandable);
+            Assert.Equal($"{hitCount}", i.ValueString);
+
+            // Abort script execution early and wait for completion
+            this.debugService.Abort();
+            await executeTask;
+        }
+
+        [Fact]
+        public async Task DebuggerStopsOnConditionalAndHitConditionBreakpoint()
+        {
+            const int hitCount = 5;
+
+            BreakpointDetails[] breakpoints =
+                await this.debugService.SetLineBreakpoints(
+                    this.debugScriptFile,
+                    new[] {
+                        BreakpointDetails.Create("", 6, null, $"$i % 2 -eq 0", $"{hitCount}"),
+                    });
+
+            await this.AssertStateChange(PowerShellContextState.Ready);
+
+            Task executeTask =
+                this.powerShellContext.ExecuteScriptAtPath(
+                    this.debugScriptFile.FilePath);
+
+            // Wait for conditional breakpoint to hit
+            await this.AssertDebuggerStopped(this.debugScriptFile.FilePath, 6);
+
+            StackFrameDetails[] stackFrames = debugService.GetStackFrames();
+            VariableDetailsBase[] variables =
+                debugService.GetVariables(stackFrames[0].LocalVariables.Id);
+
+            // Verify the breakpoint only broke at the condition ie. $i -eq breakpointValue1
+            var i = variables.FirstOrDefault(v => v.Name == "$i");
+            Assert.NotNull(i);
+            Assert.False(i.IsExpandable);
+            // Condition is even numbers ($i starting at 1) should end up on 10 with a hit count of 5.
+            Assert.Equal("10", i.ValueString);
+
+            // Abort script execution early and wait for completion
+            this.debugService.Abort();
+            await executeTask;
+        }
+
         [Fact]
         public async Task DebuggerProvidesMessageForInvalidConditionalBreakpoint()
         {
@@ -504,6 +577,146 @@ await this.debugService.SetLineBreakpoints(
             this.powerShellContext.AbortExecution();
         }
 
+        [Fact]
+        public async Task DebuggerSetsVariablesNoConversion()
+        {
+            await this.debugService.SetLineBreakpoints(
+                this.variableScriptFile,
+                new[] { BreakpointDetails.Create("", 14) });
+
+            // Execute the script and wait for the breakpoint to be hit
+            Task executeTask =
+                this.powerShellContext.ExecuteScriptString(
+                    this.variableScriptFile.FilePath);
+
+            await this.AssertDebuggerStopped(this.variableScriptFile.FilePath);
+
+            StackFrameDetails[] stackFrames = debugService.GetStackFrames();
+
+            VariableDetailsBase[] variables =
+                debugService.GetVariables(stackFrames[0].LocalVariables.Id);
+
+            // Test set of a local string variable (not strongly typed)
+            string newStrValue = "\"Goodbye\"";
+            string setStrValue = await debugService.SetVariable(stackFrames[0].LocalVariables.Id, "$strVar", newStrValue);
+            Assert.Equal(newStrValue, setStrValue);
+
+            VariableScope[] scopes = this.debugService.GetVariableScopes(0);
+            
+            // Test set of script scope int variable (not strongly typed)
+            VariableScope scriptScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.ScriptScopeName);
+            string newIntValue = "49";
+            string newIntExpr = "7 * 7";
+            string setIntValue = await debugService.SetVariable(scriptScope.Id, "$scriptInt", newIntExpr);
+            Assert.Equal(newIntValue, setIntValue);
+
+            // Test set of global scope int variable (not strongly typed)
+            VariableScope globalScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.GlobalScopeName);
+            string newGlobalIntValue = "4242";
+            string setGlobalIntValue = await debugService.SetVariable(globalScope.Id, "$MaximumAliasCount", newGlobalIntValue);
+            Assert.Equal(newGlobalIntValue, setGlobalIntValue);
+
+            // The above just tests that the debug service returns the correct new value string.
+            // Let's step the debugger and make sure the values got set to the new values.
+            this.debugService.StepOver();
+            await this.AssertDebuggerStopped(this.variableScriptFile.FilePath);
+
+            stackFrames = debugService.GetStackFrames();
+
+            // Test set of a local string variable (not strongly typed)
+            variables = debugService.GetVariables(stackFrames[0].LocalVariables.Id);
+            var strVar = variables.FirstOrDefault(v => v.Name == "$strVar");
+            Assert.Equal(newStrValue, strVar.ValueString);
+
+            scopes = this.debugService.GetVariableScopes(0);
+
+            // Test set of script scope int variable (not strongly typed)
+            scriptScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.ScriptScopeName);
+            variables = debugService.GetVariables(scriptScope.Id);
+            var intVar = variables.FirstOrDefault(v => v.Name == "$scriptInt");
+            Assert.Equal(newIntValue, intVar.ValueString);
+
+            // Test set of global scope int variable (not strongly typed)
+            globalScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.GlobalScopeName);
+            variables = debugService.GetVariables(globalScope.Id);
+            var intGlobalVar = variables.FirstOrDefault(v => v.Name == "$MaximumAliasCount");
+            Assert.Equal(newGlobalIntValue, intGlobalVar.ValueString);
+
+            // Abort execution of the script
+            this.powerShellContext.AbortExecution();
+        }
+
+        [Fact]
+        public async Task DebuggerSetsVariablesWithConversion()
+        {
+            await this.debugService.SetLineBreakpoints(
+                this.variableScriptFile,
+                new[] { BreakpointDetails.Create("", 14) });
+
+            // Execute the script and wait for the breakpoint to be hit
+            Task executeTask =
+                this.powerShellContext.ExecuteScriptString(
+                    this.variableScriptFile.FilePath);
+
+            await this.AssertDebuggerStopped(this.variableScriptFile.FilePath);
+
+            StackFrameDetails[] stackFrames = debugService.GetStackFrames();
+
+            VariableDetailsBase[] variables =
+                debugService.GetVariables(stackFrames[0].LocalVariables.Id);
+
+            // Test set of a local string variable (not strongly typed but force conversion)
+            string newStrValue = "\"False\"";
+            string newStrExpr = "$false";
+            string setStrValue = await debugService.SetVariable(stackFrames[0].LocalVariables.Id, "$strVar2", newStrExpr);
+            Assert.Equal(newStrValue, setStrValue);
+
+            VariableScope[] scopes = this.debugService.GetVariableScopes(0);
+
+            // Test set of script scope bool variable (strongly typed)
+            VariableScope scriptScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.ScriptScopeName);
+            string newBoolValue = "$true";
+            string newBoolExpr = "1";
+            string setBoolValue = await debugService.SetVariable(scriptScope.Id, "$scriptBool", newBoolExpr);
+            Assert.Equal(newBoolValue, setBoolValue);
+
+            // Test set of global scope ActionPreference variable (strongly typed)
+            VariableScope globalScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.GlobalScopeName);
+            string newGlobalValue = "Continue";
+            string newGlobalExpr = "'Continue'";
+            string setGlobalValue = await debugService.SetVariable(globalScope.Id, "$VerbosePreference", newGlobalExpr);
+            Assert.Equal(newGlobalValue, setGlobalValue);
+
+            // The above just tests that the debug service returns the correct new value string.
+            // Let's step the debugger and make sure the values got set to the new values.
+            this.debugService.StepOver();
+            await this.AssertDebuggerStopped(this.variableScriptFile.FilePath);
+
+            stackFrames = debugService.GetStackFrames();
+
+            // Test set of a local string variable (not strongly typed but force conversion)
+            variables = debugService.GetVariables(stackFrames[0].LocalVariables.Id);
+            var strVar = variables.FirstOrDefault(v => v.Name == "$strVar2");
+            Assert.Equal(newStrValue, strVar.ValueString);
+
+            scopes = this.debugService.GetVariableScopes(0);
+
+            // Test set of script scope bool variable (strongly typed)
+            scriptScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.ScriptScopeName);
+            variables = debugService.GetVariables(scriptScope.Id);
+            var boolVar = variables.FirstOrDefault(v => v.Name == "$scriptBool");
+            Assert.Equal(newBoolValue, boolVar.ValueString);
+
+            // Test set of global scope ActionPreference variable (strongly typed)
+            globalScope = scopes.FirstOrDefault(s => s.Name == VariableContainerDetails.GlobalScopeName);
+            variables = debugService.GetVariables(globalScope.Id);
+            var globalVar = variables.FirstOrDefault(v => v.Name == "$VerbosePreference");
+            Assert.Equal(newGlobalValue, globalVar.ValueString);
+
+            // Abort execution of the script
+            this.powerShellContext.AbortExecution();
+        }
+
         [Fact]
         public async Task DebuggerVariableEnumDisplaysCorrectly()
         {
diff --git a/test/PowerShellEditorServices.Test/Extensions/ExtensionServiceTests.cs b/test/PowerShellEditorServices.Test/Extensions/ExtensionServiceTests.cs
index d967dfff8..84475829a 100644
--- a/test/PowerShellEditorServices.Test/Extensions/ExtensionServiceTests.cs
+++ b/test/PowerShellEditorServices.Test/Extensions/ExtensionServiceTests.cs
@@ -187,6 +187,26 @@ public Task<EditorContext> GetEditorContext()
         {
             throw new NotImplementedException();
         }
+
+        public Task ShowInformationMessage(string message)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task ShowErrorMessage(string message)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task ShowWarningMessage(string message)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task SetStatusBarMessage(string message, int? timeout)
+        {
+            throw new NotImplementedException();
+        }
     }
 }