Migrate OSS up to 4793541c

.github/actions/spelling/allow/allow.txt

@@ -1,6 +1,7 @@
 apc
 calt
 ccmp
+cybersecurity
 Apc
 clickable
 clig

.github/actions/spelling/allow/apis.txt

@@ -66,6 +66,7 @@ iosfwd
 IPackage
 IPeasant
 isspace
+ISetup
 IStorage
 istream
 IStringable
@@ -180,6 +181,7 @@ xlocmes
 xlocmon
 xlocnum
 xloctime
+XMax
 xmemory
 XParse
 xpath
@@ -188,3 +190,4 @@ xstring
 xtree
 xutility
 YIcon
+YMax

.github/actions/spelling/expect/expect.txt

@@ -536,6 +536,7 @@ DECRC
 DECREQTPARM
 DECRLM
 DECRQM
+DECRQSS
 DECRST
 DECSASD
 DECSC
@@ -2577,6 +2578,7 @@ VREDRAW
 vsc
 vscprintf
 VSCROLL
+vsdevshell
 vsinfo
 vsnprintf
 vso

.github/actions/spelling/expect/web.txt

@@ -11,6 +11,7 @@ leonerd
 fixterms
 winui
 appshellintegration
+mdtauk
 cppreference
 gfycat
 Guake

build/Helix/OutputTestResults.ps1

@@ -21,7 +21,7 @@ Write-Host "Checking test results..."
 $queryUri = GetQueryTestRunsUri -CollectionUri $CollectionUri -TeamProject $TeamProject -BuildUri $BuildUri -IncludeRunDetails
 Write-Host "queryUri = $queryUri"
 
-$testRuns = Invoke-RestMethod -Uri $queryUri -Method Get -Headers $azureDevOpsRestApiHeaders
+$testRuns = Invoke-RestMethodWithRetries $queryUri -Headers $azureDevOpsRestApiHeaders
 [System.Collections.Generic.List[string]]$failingTests = @()
 [System.Collections.Generic.List[string]]$unreliableTests = @()
 [System.Collections.Generic.List[string]]$unexpectedResultTest = @()
@@ -50,7 +50,7 @@ foreach ($testRun in ($testRuns.value | Sort-Object -Property "completedDate" -D
     $totalTestsExecutedCount += $testRun.totalTests
 
     $testRunResultsUri = "$($testRun.url)/results?api-version=5.0"
-    $testResults = Invoke-RestMethod -Uri "$($testRun.url)/results?api-version=5.0" -Method Get -Headers $azureDevOpsRestApiHeaders
+    $testResults = Invoke-RestMethodWithRetries "$($testRun.url)/results?api-version=5.0" -Headers $azureDevOpsRestApiHeaders
         
     foreach ($testResult in $testResults.value)
     {

build/Helix/ProcessHelixFiles.ps1

@@ -20,13 +20,31 @@ function Generate-File-Links
         Out-File -FilePath $helixLinkFile -Append -InputObject "<ul>"
         foreach($file in $files)
         {
-            Out-File -FilePath $helixLinkFile -Append -InputObject "<li><a href=$($file.Link)>$($file.Name)</a></li>"
+            $url = Append-HelixAccessTokenToUrl $file.Link "{Your-Helix-Access-Token-Here}"
+            Out-File -FilePath $helixLinkFile -Append -InputObject "<li>$($url)</li>"
         }
         Out-File -FilePath $helixLinkFile -Append -InputObject "</ul>"
         Out-File -FilePath $helixLinkFile -Append -InputObject "</div>"
     }
 }
 
+function Append-HelixAccessTokenToUrl
+{
+    Param ([string]$url, [string]$token)
+    if($token)
+    {
+        if($url.Contains("?"))
+        {
+            $url = "$($url)&access_token=$($token)"
+        }
+        else
+        {
+            $url = "$($url)?access_token=$($token)"
+        }
+    }
+    return $url
+}
+
 #Create output directory
 New-Item $OutputFolder -ItemType Directory
 
@@ -63,7 +81,8 @@ foreach ($testRun in $testRuns.value)
         if (-not $workItems.Contains($workItem))
         {
             $workItems.Add($workItem)
-            $filesQueryUri = "https://helix.dot.net/api/2019-06-17/jobs/$helixJobId/workitems/$helixWorkItemName/files$accessTokenParam"
+            $filesQueryUri = "https://helix.dot.net/api/2019-06-17/jobs/$helixJobId/workitems/$helixWorkItemName/files"
+            $filesQueryUri = Append-HelixAccessTokenToUrl $filesQueryUri $helixAccessToken
             $files = Invoke-RestMethodWithRetries $filesQueryUri
 
             $screenShots = $files | where { $_.Name.EndsWith(".jpg") }
@@ -102,6 +121,7 @@ foreach ($testRun in $testRuns.value)
 
                     Write-Host "Downloading $link to $destination"
 
+                    $link = Append-HelixAccessTokenToUrl $link $HelixAccessToken
                     Download-FileWithRetries $link $destination
                 }
             }

build/Helix/UpdateUnreliableTests.ps1

@@ -23,7 +23,7 @@ Write-Host "queryUri = $queryUri"
 # To account for unreliable tests, we'll iterate through all of the tests associated with this build, check to see any tests that were unreliable
 # (denoted by being marked as "skipped"), and if so, we'll instead mark those tests with a warning and enumerate all of the attempted runs
 # with their pass/fail states as well as any relevant error messages for failed attempts.
-$testRuns = Invoke-RestMethod -Uri $queryUri -Method Get -Headers $azureDevOpsRestApiHeaders
+$testRuns = Invoke-RestMethodWithRetries $queryUri -Headers $azureDevOpsRestApiHeaders
 
 $timesSeenByRunName = @{}
       
@@ -32,10 +32,10 @@ foreach ($testRun in $testRuns.value)
     $testRunResultsUri = "$($testRun.url)/results?api-version=5.0"
         
     Write-Host "Marking test run `"$($testRun.name)`" as in progress so we can change its results to account for unreliable tests."
-    Invoke-RestMethod -Uri "$($testRun.url)?api-version=5.0" -Method Patch -Body (ConvertTo-Json @{ "state" = "InProgress" }) -Headers $azureDevOpsRestApiHeaders -ContentType "application/json" | Out-Null
+    Invoke-RestMethod "$($testRun.url)?api-version=5.0" -Method Patch -Body (ConvertTo-Json @{ "state" = "InProgress" }) -Headers $azureDevOpsRestApiHeaders -ContentType "application/json" | Out-Null
 
     Write-Host "Retrieving test results..."
-    $testResults = Invoke-RestMethod -Uri $testRunResultsUri -Method Get -Headers $azureDevOpsRestApiHeaders
+    $testResults = Invoke-RestMethodWithRetries $testRunResultsUri -Headers $azureDevOpsRestApiHeaders
         
     foreach ($testResult in $testResults.value)
     {
@@ -54,7 +54,8 @@ foreach ($testRun in $testRuns.value)
             Write-Host "  Test $($testResult.testCaseTitle) was detected as unreliable. Updating..."
             
             # The errorMessage field contains a link to the JSON-encoded rerun result data.
-            $rerunResults = ConvertFrom-Json (New-Object System.Net.WebClient).DownloadString($testResult.errorMessage)
+            $resultsJson = Download-StringWithRetries "Error results" $testResult.errorMessage
+            $rerunResults = ConvertFrom-Json $resultsJson
             [System.Collections.Generic.List[System.Collections.Hashtable]]$rerunDataList = @()
             $attemptCount = 0
             $passCount = 0

build/pipelines/release.yml

@@ -152,7 +152,7 @@ jobs:
       inputs:
         solution: '**\OpenConsole.sln'
         vsVersion: 16.0
-        msbuildArgs: /p:WindowsTerminalOfficialBuild=true /p:WindowsTerminalBranding=${{ parameters.branding }} /t:Terminal\CascadiaPackage;Terminal\WindowsTerminalUniversal /p:WindowsTerminalReleaseBuild=true /bl:$(Build.SourcesDirectory)\msbuild.binlog
+        msbuildArgs: /p:WindowsTerminalOfficialBuild=true /p:WindowsTerminalBranding=${{ parameters.branding }};PGOBuildMode=${{ parameters.pgoBuildMode }} /t:Terminal\CascadiaPackage;Terminal\WindowsTerminalUniversal /p:WindowsTerminalReleaseBuild=true /bl:$(Build.SourcesDirectory)\msbuild.binlog
         platform: $(BuildPlatform)
         configuration: $(BuildConfiguration)
         clean: true
@@ -194,7 +194,7 @@ jobs:
       inputs:
         solution: '**\OpenConsole.sln'
         vsVersion: 16.0
-        msbuildArgs: /p:WindowsTerminalOfficialBuild=true /p:WindowsTerminalBranding=${{ parameters.branding }} /p:WindowsTerminalReleaseBuild=true /t:Terminal\wpf\PublicTerminalCore
+        msbuildArgs: /p:WindowsTerminalOfficialBuild=true /p:WindowsTerminalBranding=${{ parameters.branding }};PGOBuildMode=${{ parameters.pgoBuildMode }} /p:WindowsTerminalReleaseBuild=true /t:Terminal\wpf\PublicTerminalCore
         platform: $(BuildPlatform)
         configuration: $(BuildConfiguration)
   - task: PowerShell@2

build/pipelines/templates/build-console-pgo.yml

@@ -3,7 +3,7 @@ parameters:
   platform: ''
   additionalBuildArguments: ''
   minimumExpectedTestsExecutedCount: 1  # Sanity check for minimum expected tests to be reported
-  rerunPassesRequiredToAvoidFailure: 0
+  rerunPassesRequiredToAvoidFailure: 5
 
 jobs:
 - job: Build${{ parameters.platform }}${{ parameters.configuration }}

build/pipelines/templates/check-formatting.yml

@@ -11,7 +11,7 @@ jobs:
     clean: true
 
   - task: PowerShell@2
-    displayName: 'Code Formattting Check'
+    displayName: 'Code Formatting Check'
     inputs:
       targetType: filePath
       filePath: '.\build\scripts\Invoke-FormattingCheck.ps1'

build/pipelines/templates/helix-processtestresults-job.yml

@@ -22,6 +22,7 @@ jobs:
     condition: succeededOrFailed()
     env:
       SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      HelixAccessToken: $(HelixApiAccessToken)
     inputs:
       targetType: filePath
       filePath: build\Helix\UpdateUnreliableTests.ps1
@@ -32,6 +33,7 @@ jobs:
     condition: succeededOrFailed()
     env:
       SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      HelixAccessToken: $(HelixApiAccessToken)
     inputs:
       targetType: filePath
       filePath: build\Helix\OutputTestResults.ps1

build/pipelines/templates/helix-runtests-job.yml

@@ -15,6 +15,7 @@ parameters:
   # if 'useBuildOutputFromBuildId' is set, we will default to using a build from this pipeline:
   useBuildOutputFromPipeline: $(System.DefinitionId)
   openHelixTargetQueues: 'windows.10.amd64.client19h1.open.xaml'
+  closedHelixTargetQueues: 'windows.10.amd64.client19h1.xaml'
 
 jobs:
 - job: ${{ parameters.name }}
@@ -29,11 +30,11 @@ jobs:
     buildConfiguration: ${{ parameters.configuration }}
     buildPlatform: ${{ parameters.platform }}
     openHelixTargetQueues: ${{ parameters.openHelixTargetQueues }}
+    closedHelixTargetQueues: ${{ parameters.closedHelixTargetQueues }}
     artifactsDir: $(Build.SourcesDirectory)\Artifacts
     taefPath: $(Build.SourcesDirectory)\build\Helix\packages\Microsoft.Taef.10.60.210621002\build\Binaries\$(buildPlatform)
     helixCommonArgs: '/binaryLogger:$(Build.SourcesDirectory)/${{parameters.name}}.$(buildPlatform).$(buildConfiguration).binlog /p:HelixBuild=$(Build.BuildId).$(buildPlatform).$(buildConfiguration) /p:Platform=$(buildPlatform) /p:Configuration=$(buildConfiguration) /p:HelixType=${{parameters.helixType}} /p:TestSuite=${{parameters.testSuite}} /p:ProjFilesPath=$(Build.ArtifactStagingDirectory) /p:rerunPassesRequiredToAvoidFailure=${{parameters.rerunPassesRequiredToAvoidFailure}}'
 
-
   steps:
   - task: CmdLine@1
     displayName: 'Display build machine environment variables'
@@ -140,6 +141,7 @@ jobs:
 
   - task: DotNetCoreCLI@2
     displayName: 'Run tests in Helix (open queues)'
+    condition: and(succeeded(),eq(variables['System.CollectionUri'],'https://dev.azure.com/ms/'))
     env:
       SYSTEM_ACCESSTOKEN: $(System.AccessToken)
     inputs:
@@ -147,3 +149,15 @@ jobs:
       projects: build\Helix\RunTestsInHelix.proj
       custom: msbuild
       arguments: '$(helixCommonArgs) /p:IsExternal=true /p:Creator=Terminal /p:HelixTargetQueues=$(openHelixTargetQueues)'
+
+  - task: DotNetCoreCLI@2
+    displayName: 'Run tests in Helix (closed queues)'
+    condition: and(succeeded(),ne(variables['System.CollectionUri'],'https://dev.azure.com/ms/'))
+    env:
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      HelixAccessToken: $(HelixApiAccessToken)
+    inputs:
+      command: custom
+      projects: build\Helix\RunTestsInHelix.proj
+      custom: msbuild
+      arguments: '$(helixCommonArgs) /p:HelixTargetQueues=$(closedHelixTargetQueues)'

build/pipelines/templates/pgo-build-and-publish-nuget-job.yml

@@ -20,11 +20,15 @@ jobs:
     inputs:
       artifactName: ${{ parameters.pgoArtifact }}
       downloadPath: $(artifactsPath)
-  
-  - task: NuGetToolInstaller@0
-    displayName: 'Use NuGet 5.2.0'
+
+  - task: NuGetAuthenticate@0
     inputs:
-      versionSpec: 5.2.0
+      nuGetServiceConnections: 'Terminal Public Artifact Feed'
+
+  - task: NuGetToolInstaller@0
+    displayName: 'Use NuGet 5.8.0'
+    inputs:
+      versionSpec: 5.8.0
 
   - task: CopyFiles@2
     displayName: 'Copy pgd files to NuGet build directory'
@@ -58,5 +62,11 @@ jobs:
     displayName: 'NuGet push'
     inputs:
       command: push
-      publishVstsFeed: Terminal/TerminalDependencies
-      packagesToPush: $(Build.ArtifactStagingDirectory)/*.nupkg
+      nuGetFeedType: external
+      packagesToPush: $(Build.ArtifactStagingDirectory)/*.nupkg
+      # The actual URL and PAT for this feed is configured at
+      # https://microsoft.visualstudio.com/Dart/_settings/adminservices
+      # This is the name of that connection
+      publishFeedCredentials: 'Terminal Public Artifact Feed'
+      feedsToUse: config
+      nugetConfigPath: '$(Build.SourcesDirectory)/NuGet.config'

custom.props

@@ -5,7 +5,7 @@
     <XesUseOneStoreVersioning>true</XesUseOneStoreVersioning>
     <XesBaseYearForStoreVersion>2021</XesBaseYearForStoreVersion>
     <VersionMajor>1</VersionMajor>
-    <VersionMinor>11</VersionMinor>
+    <VersionMinor>12</VersionMinor>
     <VersionInfoProductName>Windows Terminal</VersionInfoProductName>
   </PropertyGroup>
 </Project>

doc/cascadia/profiles.schema.json

@@ -215,6 +215,22 @@
               "type": "integer"
             }
           ]
+        },
+        "features": {
+          "description": "Sets the DWrite font features for the given font. For example, { \"ss01\": 1, \"liga\":0 } will enable ss01 and disable ligatures.",
+          "type": "object",
+          "patternProperties": {
+            "^(([A-Za-z0-9]){4})$": { "type": "integer" }
+          },
+          "additionalProperties": false
+        },
+        "axes": {
+          "description": "Sets the DWrite font axes for the given font. For example, { \"wght\": 200 } will set the font weight to 200.",
+          "type": "object",
+          "patternProperties": {
+            "^([A-Za-z]{4})$": { "type": "number" }
+          },
+          "additionalProperties": false
         }
       },
       "type": "object"
@@ -252,6 +268,7 @@
         "movePane",
         "swapPane",
         "moveTab",
+        "multipleActions",
         "newTab",
         "newWindow",
         "nextTab",
@@ -262,6 +279,7 @@
         "paste",
         "prevTab",
         "renameTab",
+        "openSystemMenu",
         "openTabRenamer",
         "quakeMode",
         "resetFontSize",
@@ -287,6 +305,7 @@
         "toggleReadOnlyMode",
         "toggleShaderEffects",
         "wt",
+        "quit",
         "unbound"
       ],
       "type": "string"
@@ -299,7 +318,8 @@
         "down",
         "previous",
         "nextInOrder",
-        "previousInOrder"
+        "previousInOrder",
+        "first"
       ],
       "type": "string"
     },
@@ -326,11 +346,13 @@
       ],
       "type": "string"
     },
-    "SplitState": {
+    "SplitDirection": {
       "enum": [
-        "vertical",
-        "horizontal",
-        "auto"
+        "auto",
+        "up",
+        "right",
+        "down",
+        "left"
       ],
       "type": "string"
     },
@@ -609,9 +631,9 @@
           "properties": {
             "action": { "type": "string", "pattern": "splitPane" },
             "split": {
-              "$ref": "#/definitions/SplitState",
+              "$ref": "#/definitions/SplitDirection",
               "default": "auto",
-              "description": "The orientation to split the pane in. Possible values:\n -\"auto\" (splits pane based on remaining space)\n -\"horizontal\" (think [-])\n -\"vertical\" (think [|])"
+              "description": "The orientation to split the pane in. Possible values:\n -\"auto\" (splits pane based on remaining space)\n -\"up\" (think [-] and above)\n -\"down\" (think [-] and below)\n -\"left\" (think [|] and to the left)\n -\"right\"(think [|] and to the right)"
             },
             "splitMode": {
               "default": "duplicate",
@@ -808,6 +830,24 @@
       ],
       "required": [ "direction" ]
     },
+    "MultipleActionsAction": {
+      "description": "Arguments for the multiple actions command",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "multipleActions" },
+            "actions" : {
+              "$ref": "#/definitions/ShortcutAction",
+              "type": "array",
+              "minItems": 1,
+              "description": "A list of other actions."
+            }
+          }
+        }
+      ],
+      "required": [ "actions" ]
+    }, 
     "CommandPaletteAction": {
       "description": "Arguments for a commandPalette action",
       "allOf": [
@@ -1195,6 +1235,15 @@
           "description": "When set to true, this enables the launch of Windows Terminal at startup. Setting this to false will disable the startup task entry. If the Windows Terminal startup task entry is disabled either by org policy or by user action this setting will have no effect.",
           "type": "boolean"
         },
+        "firstWindowPreference": {
+          "default": "defaultProfile",
+          "description": "Defines what behavior the terminal takes when it starts. \"defaultProfile\" will have the terminal launch with one tab of the default profile, and \"persistedWindowLayout\" will cause the terminal to save its layout on close and reload it on open.",
+          "enum": [
+            "defaultProfile",
+            "persistedWindowLayout"
+          ],
+          "type": "string"
+        },
         "launchMode": {
           "default": "default",
           "description": "Defines whether the terminal will launch as maximized, full screen, or in a window. Setting this to \"focus\" is equivalent to launching the terminal in the \"default\" mode, but with the focus mode enabled. Similar, setting this to \"maximizedFocus\" will result in launching the terminal in a maximized window with the focus mode enabled.",
@@ -1215,14 +1264,19 @@
           "type": [ "integer", "string" ],
           "deprecated": true
         },
-        "minimizeToTray": {
+        "minimizeToNotificationArea": {
           "default": "false",
-          "description": "When set to true, minimizing a Terminal window will no longer appear in the taskbar. Instead, a Terminal icon will appear in the system tray through which the user can access their windows.",
+          "description": "When set to true, minimizing a Terminal window will no longer appear in the taskbar. Instead, a Terminal icon will appear in the notification area through which the user can access their windows.",
           "type": "boolean"
         },
-        "alwaysShowTrayIcon": {
+        "alwaysShowNotificationIcon": {
           "default": "false",
-          "description": "When set to true, the Terminal's tray icon will always be shown in the system tray.",
+          "description": "When set to true, the Terminal's notification icon will always be shown in the notification area.",
+          "type": "boolean"
+        },
+        "useAcrylicInTabRow": {
+          "default": "false",
+          "description": "When set to true, the tab row will have an acrylic background with 50% opacity.",
           "type": "boolean"
         },
 		"actions": {

doc/specs/#5000 - Process Model 2.0/#1032 - Elevation Quality of Life Improvements.md

@@ -0,0 +1,619 @@
+---
+author: Mike Griese @zadjii-msft
+created on: 2020-11-20
+last updated: 2021-08-17
+issue id: #1032
+---
+
+# Elevation Quality of Life Improvements
+
+## Abstract
+
+For a long time, we've been researching adding support to the Windows Terminal
+for running both unelevated and elevated (admin) tabs side-by-side, in the same
+window. However, after much research, we've determined that there isn't a safe
+way to do this without opening the Terminal up as a potential
+escalation-of-privilege vector.
+
+Instead, we'll be adding a number of features to the Terminal to improve the
+user experience of working in elevated scenarios. These improvements include:
+
+* A visible indicator that the Terminal window is elevated ([#1939])
+* Configuring the Terminal to always run elevated ([#632])
+* Configuring a specific profile to always open elevated ([#632])
+* Allowing new tabs, panes to be opened elevated directly from an unelevated
+  window
+* Dynamic profile appearance that changes depending on if the Terminal is
+  elevated or not. ([#1939], [#8311])
+
+## Background
+
+_This section was originally authored in the [Process Model 2.0 Spec]. Please
+refer to it there for its original context._
+
+Let's presume that you're a user who wants to be able to open an elevated tab
+within an otherwise unelevated Terminal window. We call this scenario "mixed
+elevation" - the tabs within the Terminal can be running either unelevated _or_
+elevated client applications.
+
+It wouldn't be terribly difficult for the unelevated Terminal to request the
+permission of the user to spawn an elevated client application. The user would
+see a UAC prompt, they'd accept, and then they'd be able to have an elevated
+shell alongside their unelevated tabs.
+
+However, this creates an escalation of privilege vector. Now, there's an
+unelevated window which is connected directly to an elevated process. At this
+point, **any other unelevated application could send input to the Terminal's
+`HWND`**. This would make it possible for another unelevated process to "drive"
+the Terminal window, and send commands to the elevated client application.
+
+It was initially theorized that the window/content model architecture would also
+help enable "mixed elevation". With mixed elevation, tabs could run at different
+integrity levels within the same terminal window. However, after investigation
+and research, it has become apparent that this scenario is not possible to do
+safely after all. There are numerous technical difficulties involved, and each
+with their own security risks. At the end of the day, the team wouldn't be
+comfortable shipping a mixed-elevation solution, because there's simply no way
+for us to be confident that we haven't introduced an escalation-of-privilege
+vector utilizing the Terminal. No matter how small the attack surface might be,
+we wouldn't be confident that there are _no_ vectors for an attack.
+
+Some things we considered during this investigation:
+
+* If a user requests a new elevated tab from an otherwise unelevated window, we
+  could use UAC to create a new, elevated window process, and "move" all the
+  current tabs to that window process, as well as the new elevated client. Now,
+  the window process would be elevated, preventing it from input injection, and
+  it would still contains all the previously existing tabs. The original window
+  process could now be discarded, as the new elevated window process will
+  pretend to be the original window.
+  - However, it is unfortunately not possible with COM to have an elevated
+    client attach to an unelevated server that's registered at runtime. Even in
+    a packaged environment, the OS will reject the attempt to `CoCreateInstance`
+    the content process object. this will prevent elevated windows from
+    re-connecting to unelevated client processes.
+  - We could theoretically build an RPC tunnel between content and window
+    processes, and use the RPC connection to marshal the content process to the
+    elevated window. However, then _we_ would need to be responsible for
+    securing access the the RPC endpoint, and we feel even less confident doing
+    that.
+  - Attempts were also made to use a window-broker-content architecture, with
+    the broker process having a static CLSID in the registry, and having the
+    window and content processes at mixed elevation levels `CoCreateInstance`
+    that broker. This however _also_ did not work across elevation levels. This
+    may be due to a lack of Packaged COM support for mixed elevation levels.
+
+    It's also possible that the author forgot that packaged WinRT doesn't play
+    nicely with creating objects in an elevated context. The Terminal has
+    previously needed to manually manifest all its classes in a SxS manifest for
+    Unpackaged WinRT to allow the classes to be activated, rather than relying
+    on the packaged catalog. It's theoretically possible that doing that would
+    have allowed the broker to be activated across integrity levels.
+
+    Even if this approach did end up working, we would still need to be
+    responsible for securing the elevated windows so that an unelevated attacker
+    couldn't hijack a content process and trigger unexpected code in the window
+    process. We didn't feel confident that we could properly secure this channel
+    either.
+
+We also considered allowing mixed content in windows that were _originally_
+elevated. If the window is already elevated, then it can launch new unelevated
+processes. We could allow elevated windows to still create unelevated
+connections. However, we'd want to indicate per-pane what the elevation state
+of each connection is. The user would then need to keep track themselves of
+which terminal instances are elevated, and which are not.
+
+This also marks a departure from the current behavior, where everything in an
+elevated window would be elevated by default. The user would need to specify for
+each thing in the elevated window that they'd want to create it elevated. Or the
+Terminal would need to provide some setting like
+`"autoElevateEverythingInAnElevatedWindow"`.
+
+We cannot support mixed elevation when starting in a unelevated window.
+Therefore, it doesn't make a lot of UX sense to support it in the other
+direction. It's a cleaner UX story to just have everything in a single window at
+the same elevation level.
+
+## Solution Design
+
+Instead of supporting mixed elevation in the same window, we'll introduce the
+following features to the Terminal. These are meant as a way of improving the
+quality of life for users who work in mixed-elevation (or even just elevated)
+environments.
+
+### Visible indicator for elevated windows
+
+As requested in [#1939], it would be nice if it was easy to visibly identify if
+a Terminal window was elevated or not.
+
+One easy way of doing this is by adding a simple UAC shield to the left of the
+tabs for elevated windows. This shield could be configured by the theme (see
+[#3327]). We could provide the following states:
+* Colored (the default)
+* Monochrome
+* Hidden, to hide the shield even on elevated windows. This is the current
+  behavior.
+
+![UAC-shield-in-titlebar](UAC-shield-in-titlebar.png)
+_figure 1: a monochrome UAC shield in the titlebar of the window, courtesy of @mdtauk_
+
+We could also simplify this to only allow a boolean true/false for displaying
+the shield. As we do often with other enums, we could define `true` to be the
+same as the default appearance, and `false` to be the hidden option. As always,
+the development of the Terminal is an iterative process, where we can
+incrementally improve from no setting, to a boolean setting, to a enum-backed
+one.
+
+### Configuring a profile to always run elevated
+
+Oftentimes, users might have a particular tool chain that only works when
+running elevated. In these scenarios, it would be convenient for the user to be
+able to identify that the profile should _always_ run elevated. That way, they
+could open the profile from the dropdown menu of an otherwise unelevated window
+and have the elevated window open with the profile automatically.
+
+We'll be adding the `"elevate": true|false` setting as a per-profile setting,
+with a default value of `false`. When set to `true`, we'll try to auto-elevate
+the profile whenever it's launched. We'll check to see if this window is
+elevated before creating the connection for this profile. If the window is not
+elevated, then we'll create a new window with the requested elevation level to
+handle the new connection.
+
+`"elevate": false` will do nothing. If the window is already elevated, then the
+profile won't open an un-elevated window.
+
+If the user tries to open an `"elevate": true` profile in a window that's
+already elevated, then a new tab/split will open in the existing window, rather
+than spawning an additional elevated window.
+
+There are three situations where we're creating new terminal instances: new
+tabs, new splits, and new windows. Currently, these are all actions that are
+also exposed in the `wt` commandline as subcommands. We can convert from the
+commandline arguments into these actions already. Therefore, it shouldn't be too
+challenging to convert these actions back into the equal commandline arguments.
+
+For the following examples, let's assume the user is currently in an unelevated
+Terminal window.
+
+When the user tries to create a new elevated **tab**, we'll need to create a new
+process, elevated, with the following commandline:
+
+```
+wt new-tab [args...]
+```
+
+When we create this new `wt` instance, it will obey the glomming rules as
+specified in [Session Management Spec]. It might end up glomming to another
+existing window at that elevation level, or possibly create its own window.
+
+Similarly, for a new elevated **window**, we can make sure to pass the `-w new`
+arguments to `wt`. These parameters indicate that we definitely want this
+command to run in a new window, regardless of the current glomming settings.
+
+```
+wt -w new new-tab [args...]
+```
+
+However, creating a new **pane** is a little trickier. Invoking the `wt
+split-pane [args...]` is straightforward enough.
+
+<!-- Discussion notes follow:
+If the current window doesn't have the same elevation level as the
+requested profile, do we always want to just create a new split? If the command
+ends up glomming to an existing window, does that even make sense? That invoking
+an elevated split in an unelevated window would end up splitting the elevated
+window? It's very possible that the user wanted a split in the tab they're
+currently in, in the unelevated window, but they don't want a split in the
+elevated window.
+
+What if there's not space in the elevated window to create the split (but there
+would be in the current window)? That would sure make it seem like nothing
+happened, silently.
+
+We could alternatively have cross-elevation splits default to always opening a
+new tab. That might mitigate some of the odd behaviors. Until we actually have
+support for running commands in existing windows, we'll always need to make a
+new window when running elevated. We'll need to make the new window for new tabs
+and splits, because there's no way to invoke another existing window.
+
+A third proposal is to pop a warning dialog at the user when they try to open an
+elevated split from and unelevated window. This dialog could be something like
+
+> What you requested couldn't be completed. Do you want to:
+> A. Make me a new tab instead.
+> B. Forget it and cancel. I'll go fix my config.
+
+I'm certainly leaning towards proposal 2 - always create a new tab. This is how
+it's implemented in [#8514]. In that PR, this seems to work sensibly.
+-->
+
+After discussing with the team, we have decided that the most sensible approach
+for handling a cross-elevation `split-pane` is to just create a new tab in the
+elevated window. The user can always re-attach the pane as a split with the
+`move-pane` command once the new pane in the elevated window.
+
+#### Configure the Terminal to _always_ run elevated
+
+`elevate` is a per-profile property, not a global property. If a user
+wants to always have all instances of the Terminal run elevated, they
+could set `"elevate": true` in their profile defaults. That would cause _all_
+profiles they launch to always spawn as elevated windows.
+
+#### `elevate` in Actions
+
+Additionally, we'll add the `elevate` property to the `NewTerminalArgs` used in
+the `newTab`, `splitPane`, and `newWindow` actions. This is similar to how other
+properties of profiles can be overridden at launch time. This will allow
+windows, tabs and panes to all be created specifically as elevated windows.
+
+In the `NewTerminalArgs`, `elevate` will be an optional boolean, with the
+following behavior:
+* `null` (_default_): Don't modify the `elevate` property for this profile
+* `true`: This launch should act like the profile had `"elevate": true` in its
+  properties.
+* `false`: This launch should act like the profile had `"elevate": false` in its
+  properties.
+
+We'll also add an iterable command for opening a profile in an
+elevated tab, with the following json:
+
+```jsonc
+{
+    // New elevated tab...
+    "name": { "key": "NewElevatedTabParentCommandName", "icon": "UAC-Shield.png" },
+    "commands": [
+        {
+            "iterateOn": "profiles",
+            "icon": "${profile.icon}",
+            "name": "${profile.name}",
+            "command": { "action": "newTab", "profile": "${profile.name}", "elevated": true }
+        }
+    ]
+},
+```
+
+#### Elevation from the dropdown
+
+Currently, the new tab dropdown supports opening a new pane by
+<kbd>Alt+click</kbd>ing on a profile. We could similarly add support to open a
+tab elevated with <kbd>Ctrl+click</kbd>. This is similar to the behavior of the
+Windows taskbar. It supports creating an elevated instance of a program by
+<kbd>Ctrl+click</kbd>ing on entries as well.
+
+## Implementation Details
+
+### Starting an elevated process from an unelevated process
+
+It seems that we're able to create an elevated process by passing the `"runas"`
+verb to
+[`ShellExecute`](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shellexecutea).
+So we could use something like
+
+```c++
+ShellExecute(nullptr,
+             L"runas",
+             L"wt.exe",
+             L"-w new new-tab [args...]",
+             nullptr,
+             SW_SHOWNORMAL);
+```
+
+This will ask the shell to perform a UAC prompt before spawning `wt.exe` as an
+elevated process.
+
+> 👉 NOTE: This mechanism won't always work on non-Desktop SKUs of Windows. For
+> more discussion, see [Elevation on OneCore SKUs](#Elevation-on-OneCore-SKUs).
+
+## Potential Issues
+
+<table>
+<tr>
+<td><strong>Accessibility</strong></td>
+<td>
+
+The set of changes proposed here are not expected to introduce any new
+accessibility issues. Users can already create elevated Terminal windows. Making
+it easier to create these windows doesn't really change our accessibility story.
+
+</td>
+</tr>
+<tr>
+<td><strong>Security</strong></td>
+<td>
+
+We won't be doing anything especially unique, so there aren't expected to be any
+substantial security risks associated with these changes. Users can already
+create elevated Terminal windows, so we're not really introducing any new
+functionality, from a security perspective.
+
+We're relying on the inherent security of the `runas` verb of `ShellExecute` to
+prevent any sort of unexpected escalation-of-privilege.
+
+<hr>
+
+One security concern is the fact that the `settings.json` file is currently a
+totally unsecured file. It's completely writable by any medium-IL process. That
+means it's totally possible for a malicious program to change the file. The
+malicious program could find a user's "Elevated PowerShell" profile, and change
+the commandline to `malicious.exe`. The user might then think that their
+"Elevated PowerShell" will run `powershell.exe` elevated, but will actually
+auto-elevate this attacker.
+
+If all we expose to the user is the name of the profile in the UAC dialog, then
+there's no way for the user to be sure that the program that's about to be
+launched is actually what they expect.
+
+To help mitigate this, we should _always_ pass the evaluated `commandline` as a
+part of the call to `ShellExecute`. the arguments that are passed to
+`ShellExecute` are visible to the user, though they need to click the "More
+Details" dropdown to reveal them.
+
+We will need to mitigate this vulnerability regardless of adding support for the
+auto-elevation of individual terminal tabs/panes. If a user is launching the
+Terminal elevated (i.e. from the Win+X menu in Windows 11), then it's possible
+for a malicious program to overwrite the `commandline` of their default profile.
+The user may now unknowingly invoke this malicious program while thinking they
+are simply launching the Terminal.
+
+To deal with this more broadly, we will display a dialog within the Terminal
+window before creating **any** elevated terminal instance. In that dialog, we'll
+display the commandline that will be executed, so the user can very easily
+confirm the commandline.
+
+This will need to happen for all elevated terminal instances. For an elevated
+Windows Terminal window, this means _all_ connections made by the Terminal.
+Every time the user opens a new profile or a new commandline in a pane, we'll
+need to prompt them first to confirm the commandline. This dialog within the
+elevated window will also prevent an attacker from editing the `settings.json`
+file while the user already has an elevated Terminal window open and hijacking a
+profile.
+
+The dialog options will certainly be annoying to users who don't want to be
+taken out of their flow to confirm the commandline that they wish to launch.
+There's precedent for a similar warning being implemented by VSCode, with their
+[Workspace Trust] feature. They too faced a similar backlash when the feature
+first shipped. However, in light of recent global cybersecurity attacks, this is
+seen as an acceptable UX degradation in the name of application trust. We don't
+want to provide an avenue that's too easy to abuse.
+
+When the user confirms the commandline of this profile as something safe to run,
+we'll add it to an elevated-only version of `state.json`. (see [#7972] for more
+details). This elevated version of the file will only be accessible by the
+elevated Terminal, so an attacker cannot hijack the contents of the file. This
+will help mitigate the UX discomfort caused by prompting on every commandline
+launched. This should mean that the discomfort is only limited to the first
+elevated launch of a particular profile. Subsequent launches (without modifying
+the `commandline`) will work as they always have.
+
+The dialog for confirming these commandlines should have a link to the docs for
+"Learn more...". Transparency in the face of this dialog should
+mitigate some dissatisfaction.
+
+The dialog will _not_ appear if the user does not have a split token - if the
+user's PC does not have UAC enabled, then they're _already_ running as an
+Administrator. Everything they do is elevated, so they shouldn't be prompted in
+this way.
+
+The Settings UI should also expose a way of viewing and removing these cached
+entries. This page should only be populated in the elevated version of the
+Terminal.
+
+</td>
+</tr>
+<tr>
+<td><strong>Reliability</strong></td>
+<td>
+
+No changes to our reliability are expected as a part of this change.
+
+</td>
+</tr>
+<tr>
+<td><strong>Compatibility</strong></td>
+<td>
+
+There are no serious compatibility concerns expected with this changelist. The
+new `elevate` property will be unset by default, so users will heed to opt-in
+to the new auto-elevating behavior.
+
+There is one minor concern regarding introducing the UAC shield on the window.
+We're planning on using themes to configure the appearance of the shield. That
+means we'll need to ship themes before the user will be able to hide the shield
+again.
+
+</td>
+</tr>
+<tr>
+<td><strong>Performance, Power, and Efficiency</strong></td>
+<td>
+
+No changes to our performance are expected as a part of this change.
+
+</td>
+</tr>
+</table>
+
+### Centennial Applications
+
+In the past, we've had a notoriously rough time with the Centennial app
+infrastructure and running the Terminal elevated. Notably, we've had to list all
+our WinRT classes in our SxS manifest so they could be activated using
+unpackaged WinRT while running elevated. Additionally, there are plenty of
+issues running the Terminal in an "over the shoulder" elevation (OTS) scenario.
+
+Specifically, we're concerned with the following scenario:
+  * the current user account has the Terminal installed,
+  * but they aren't an Administrator,
+  * the Administrator account doesn't have the Terminal installed.
+
+In that scenario, the user can run into issues launching the Terminal in an
+elevated context (even after entering the Admin's credentials in the UAC
+prompt).
+
+This spec proposes no new mitigations for dealing with these issues. It may in
+fact make them more prevalent, by making elevated contexts more easily
+accessible.
+
+Unfortunately, these issues are OS bugs that are largely out of our own control.
+We will continue to apply pressure to the centennial app team internally as we
+encounter these issues. They are are team best equipped to resolve these issues.
+
+### Default Terminal & auto-elevation
+
+In the future, when we support setting the Terminal as the "default terminal
+emulator" on Windows. When that lands, we will use the `profiles.defaults`
+settings to create the tab where we'll be hosting the commandline client. If the user has
+`"elevate": true` in their `profiles.defaults`, we'd usually try to
+auto-elevate the profile. In this scenario, however, we can't do that. The
+Terminal is being invoked on behalf of the client app launching, instead of the
+Terminal invoking the client application.
+
+**2021-08-17 edit**: Now that "defterm" has shipped, we're a little more aware
+of some of the limitations with packaged COM and elevation boundaries. Defterm
+cannot be used with elevated processes _at all_ currently (see [#10276]). When
+an elevated commandline application is launched, it will always just appear in
+`conhost.exe`. Furthermore, An unelevated peasant can't communicate with an
+elevated monarch so we can't toss the connection to the elevated monarch and
+have them handle it.
+
+The simplest solution here is to just _always_ ignore the `elevate` property for
+incoming defterm connections. This is not an ideal solution, and one that we're
+willing to revisit if/when [#10276] is ever fixed.
+
+### Elevation on OneCore SKUs
+
+This spec proposes using `ShellExecute` to elevate the Terminal window. However,
+not all Windows SKUs have support for `ShellExecute`. Notably, the non-Desktop
+SKUs, which are often referred to as "OneCore" SKUs. On these platforms, we
+won't be able to use `ShellExecute` to elevate the Terminal. There might not
+even be the concept of multiple elevation levels, or different users, depending
+on the SKU.
+
+Fortunately, this is a mostly hypothetical concern for the moment. Desktop is
+the only publicly supported SKU for the Terminal currently. If the Terminal ever
+does become available on those SKUs, we can use these proposals as mitigations.
+
+* If elevation is supported, there must be some other way of elevating a
+  process. We could always use that mechanism instead.
+* If elevation isn't supported (I'm thinking 10X is one of these), then we could
+  instead display a warning dialog whenever a user tries to open an elevated
+  profile.
+  - We could take the warning a step further. We could add another settings
+    validation step. This would warn the user if they try to mark any profiles
+    or actions as `"elevate":true`
+
+## Future considerations
+
+* If we wanted to go even further down the visual differentiation route, we
+  could consider allowing the user to set an entirely different theme ([#3327])
+  based on the elevation state. Something like `elevatedTheme`, to pick another
+  theme from the set of themes. This would allow them to force elevated windows
+  to have a red titlebar, for example.
+* Over the course of discussion concerning appearance objects ([#8345]), it
+  became clear that having separate "elevated" appearances defined for
+  `profile`s was overly complicated. This is left as a consideration for a
+  possible future extension that could handle this scenario in a cleaner way.
+* Similarly, we're going to leave [#3637] "different profiles when elevated vs
+  unelevated" for the future. This also plays into the design of "configure the
+  new tab dropdown" ([#1571]), and reconciling those two designs is out-of-scope
+  for this particular release.
+* Tangentially, we may want to have a separate Terminal icon we ship with the
+  UAC shield present on it. This would be especially useful for the tray icon.
+  Since there will be different tray icon instances for elevated and unelevated
+  windows, having unique icons may help users identify which is which.
+
+### De-elevating a Terminal
+
+the original version of this spec proposed that `"elevated":false` from an
+elevated Terminal window should create a new unelevated Terminal instance. The
+mechanism for doing this is described in [The Old New Thing: How can I launch an
+unelevated process from my elevated process, redux].
+
+This works well when the Terminal is running unpackaged. However, de-elevating a
+process does not play well with packaged centennial applications. When asking
+the OS to run the packaged application from an elevated context, the system will
+still create the child process _elevated_. This means the packaged version of
+the Terminal won't be able to create a new unelevated Terminal instance.
+
+From an internal mail thread:
+
+> App model intercepts the `CreateProcess` call and redirects it to a COM
+> service. The parent of a packaged app is not the launching app, it’s some COM
+> service. So none of the parent process nonsense will work because the
+> parameters you passed to `CreateProcess` aren’t being used to create the
+> process.
+
+If this is fixed in the future, we could theoretically re-introduce de-elevating
+a profile. The original spec proposed a `"elevated": bool?` setting, with the
+following behaviors:
+* `null` (_default_): Don't modify the elevation level when running this profile
+* `true`: If the current window is unelevated, try to create a new elevated
+  window to host this connection.
+* `false`: If the current window is elevated, try to create a new unelevated
+  window to host this connection.
+
+We could always re-introduce this setting, to supercede `elevate`.
+
+### Change profile appearance for elevated windows
+
+In [#3062] and [#8345], we're planning on allowing users to set different
+appearances for a profile whether it's focused or not. We could do similar thing
+to enable a profile to have a different appearance when elevated. In the
+simplest case, this could allow the user to set `"background": "#ff0000"`. This
+would make a profile always appear to have a red background when in an elevated
+window.
+
+The more specific details of this implementation are left to the spec
+[Configuration object for profiles].
+
+In discussion of that spec, we decided that it would be far too complicated to
+try and overload the `unfocusedAppearance` machinery for differentiating between
+elevated and unelevated versions of the same profile. Already, that would lead
+to 4 states: [`appearance`, `unfocusedAppearance`, `elevatedAppearance`,
+`elevatedUnfocusedAppearance`]. This would lead to a combinatorial explosion if
+we decided in the future that there should also be other states for a profile.
+
+This particular QoL improvement is currently being left as a future
+consideration, should someone come up with a clever way of defining
+elevated-specific settings.
+
+<!--
+Brainstorming notes for future readers:
+
+You could have a profile that layers on an existing profile, with elevated-specific settings:
+
+{
+  "name": "foo",
+  "background": "#0000ff",
+  "commandline": "cmd.exe /k echo I am unelevated"
+},
+{
+  "inheritsFrom": "foo",
+  "background": "#ff0000",
+  "elevate": true,
+  "commandline": "cmd.exe /k echo I am ELEVATED"
+}
+-->
+
+<!-- Footnotes -->
+
+[#632]: https://github.com/microsoft/terminal/issues/632
+[#1032]: https://github.com/microsoft/terminal/issues/1032
+[#1571]: https://github.com/microsoft/terminal/issues/1571
+[#1939]: https://github.com/microsoft/terminal/issues/1939
+[#3062]: https://github.com/microsoft/terminal/issues/3062
+[#3327]: https://github.com/microsoft/terminal/issues/3327
+[#3637]: https://github.com/microsoft/terminal/issues/3637
+[#4472]: https://github.com/microsoft/terminal/issues/4472
+[#5000]: https://github.com/microsoft/terminal/issues/5000
+[#7972]: https://github.com/microsoft/terminal/pull/7972
+[#8311]: https://github.com/microsoft/terminal/issues/8311
+[#8345]: https://github.com/microsoft/terminal/issues/8345
+[#8514]: https://github.com/microsoft/terminal/issues/8514
+[#10276]: https://github.com/microsoft/terminal/issues/10276
+
+[Process Model 2.0 Spec]: https://github.com/microsoft/terminal/blob/main/doc/specs/%235000%20-%20Process%20Model%202.0.md
+[Configuration object for profiles]: https://github.com/microsoft/terminal/blob/main/doc/specs/Configuration%20object%20for%20profiles.md
+[Session Management Spec]: https://github.com/microsoft/terminal/blob/main/doc/specs/%234472%20-%20Windows%20Terminal%20Session%20Management.md
+[The Old New Thing: How can I launch an unelevated process from my elevated process, redux]: https://devblogs.microsoft.com/oldnewthing/20190425-00/?p=102443
+[Workspace Trust]: https://code.visualstudio.com/docs/editor/workspace-trust

doc/specs/#6900 - Actions Page/spec.md

@@ -0,0 +1,130 @@
+---
+author: Kayla Cinnamon - cinnamon-msft
+created on: 2021-03-04
+last updated: 2021-03-09
+issue id: 6900
+---
+
+# Actions Page
+
+## Abstract
+
+We need to represent actions inside the settings UI. This spec goes through the possible use cases and reasoning for including specific features for actions inside the settings UI.
+
+## Background
+
+### Inspiration
+
+It would be ideal if we could get the settings UI to have parity with the JSON file. This will take some design work if we want every feature possible in relation to actions. There is also the option of not having parity with the JSON file in order to present a simpler UX.
+
+### User Stories
+
+All of these features are possible with the JSON file. This spec will go into discussion of which (possibly all) of these user stories need to be handled by the settings UI.
+
+- Add key bindings to an action that does not already have keys assigned
+- Edit key bindings for an action
+- Remove key bindings from an action
+- Add multiple key bindings for the same action
+- Create an iterable action
+- Create a nested action
+- Choose which actions appear inside the command palette
+- See all possible actions, regardless of keys
+
+Commands with properties:
+- sendInput has "input"
+- closeOtherTabs has "index"
+- closeTabsAfter has "index"
+- renameTab has "title"*
+- setTabColor has "color"*
+- newWindow has "commandline", "startingDirectory", "tabTitle", "index", "profile"
+- splitPane has "split", "commandline", "startingDirectory", "tabTitle", "index", "profile", "splitMode", "size"
+- copy has "singleLine", "copyFormatting"
+- scrollUp has "rowsToScroll"
+- scrollDown has "rowsToScroll"
+- setColorScheme has "colorScheme"
+
+Majority of these commands listed above are intended for the command palette, so they wouldn't make much sense with keys assigned to them anyway.
+
+### Future Considerations
+
+One day we'll have actions that can be invoked by items in the dropdown menu. This setting will have to live somewhere. Also, once we get a status bar, people may want to invoke actions from there.
+
+## Solution Design
+
+### Proposal 1: Keyboard and Command Palette pages
+
+Implement a Keyboard page in place of the Actions page. Also plan for a Command Palette page in the future if it's something that's heavily requested. The Command Palette page would cover the missing use cases listed below.
+
+When users want to add a new key binding, the dropdown will list every action, regardless if it already has keys assigned. This page should show every key binding assigned to an action, even if there are multiple bindings to the same action.
+
+Users will be able to view every possible action from the command palette if they'd like.
+
+Use cases covered:
+- Add key bindings to an action that does not already have keys assigned
+- Edit key bindings for an action
+- Remove key bindings from an action
+- Add multiple key bindings for the same action
+- See all actions that have keys assigned
+
+Use cases missing:
+- Create an iterable action
+- Create a nested action
+- Choose which actions appear inside the command palette
+- See all possible actions, regardless of keys
+
+* **Pros**:
+- This allows people to edit their actions in most of their scenarios.
+- This gives us some wiggle room to cover majority of the use cases we need and seeing if people want the other use cases that are missing.
+
+* **Cons**:
+- Unfortunately we couldn't cover every single use case with this design.
+- You can't edit the properties that are on some commands, however the default commands from the command palette include options with properties anyway. For example "decrease font size" has the `delta` property already included.
+
+### Proposal 2: Have everything on one Actions page
+
+Implement an Actions page that allows you to create actions designed for the command palette as well as actions with keys.
+
+Use cases covered:
+- Add key bindings to an action that does not already have keys assigned
+- Edit key bindings for an action
+- Remove key bindings from an action
+- Add multiple key bindings for the same action
+- See all actions that have keys assigned
+- Create an iterable action
+- Create a nested action
+- Choose which actions appear inside the command palette
+- See all possible actions, regardless of keys
+
+I could not come up with a UX design that wasn't too complicated or confusing for this scenario.
+
+**Pros**:
+- There is full parity with the JSON file.
+
+**Cons**:
+- Could not come up with a simplistic design to represent all of the use cases (which makes the settings UI not as enticing since it promotes ease of use).
+
+## Conclusion
+
+We considered Proposal 2, however the design became cluttered very quickly and we agreed to create two pages and start off with Proposal 1.
+
+## UI/UX Design
+
+![Click edit on key binding](./edit-click.png)
+
+The Add new button is using the secondary color, to align with the button on the Color schemes page.
+
+![Edit key binding](./edit-keys.png)
+
+![Click add new](./add-click.png)
+
+![Add key binding](./add-keys.png)
+
+## Potential Issues
+
+This design is not 1:1 with the JSON file, so actions that don't have keys will not appear on this page. Additionally, you can't add a new action without keys with this current design.
+
+You also cannot specify properties on commands (like the `newTab` command) and these will have to be added through the JSON file. Considering there are only a few of these and we're planning to iterate on this and add a Command Palette page, we were okay with this decision.
+
+## Resources
+
+### Footnotes

doc/terminal-v2-roadmap.md

@@ -29,8 +29,8 @@ Below is the schedule for when milestones will be included in release builds of
 | 2021-03-01 | [1.7] in Windows Terminal Preview<br>[1.6] in Windows Terminal | [Windows Terminal Preview 1.7 Release](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-7-release/) |
 | 2021-04-14 | [1.8] in Windows Terminal Preview<br>[1.7] in Windows Terminal | [Windows Terminal Preview 1.8 Release](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-8-release/) |
 | 2021-05-31 | [1.9] in Windows Terminal Preview<br>[1.8] in Windows Terminal | [Windows Terminal Preview 1.9 Release](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-9-release/) |
-| 2021-07-31 | 1.10 in Windows Terminal Preview<br>[1.9] in Windows Terminal | |
-| 2021-08-30 | 1.11 in Windows Terminal Preview<br>1.10 in Windows Terminal | |
+| 2021-07-14 | [1.10] in Windows Terminal Preview<br>[1.9] in Windows Terminal | [Windows Terminal Preview 1.10 Release](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-10-release/) |
+| 2021-08-31 | [1.11] in Windows Terminal Preview<br>[1.10] in Windows Terminal | [Windows Terminal Preview 1.11 Release](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-11-release/) |
 | 2021-10-31 | 1.12 in Windows Terminal Preview<br>1.11 in Windows Terminal | |
 | 2021-11-30 | 2.0 RC in Windows Terminal Preview<br>2.0 RC in Windows Terminal | |
 | 2021-12-31 | [2.0] in Windows Terminal Preview<br>[2.0] in Windows Terminal | |
@@ -89,6 +89,8 @@ Feature Notes:
 [1.7]: https://github.com/microsoft/terminal/milestone/32
 [1.8]: https://github.com/microsoft/terminal/milestone/33
 [1.9]: https://github.com/microsoft/terminal/milestone/34
+[1.10]: https://github.com/microsoft/terminal/milestone/35
+[1.11]: https://github.com/microsoft/terminal/milestone/36
 [2.0]: https://github.com/microsoft/terminal/milestone/22
 [#1564]: https://github.com/microsoft/terminal/issues/1564
 [#6720]: https://github.com/microsoft/terminal/pull/6720

oss/boost/MAINTAINER_README.md

@@ -4,7 +4,7 @@ This was originally imported by @Austin-Lamb in December 2020.
 
 The provenance information (where it came from and which commit) is stored in the file `cgmanifest.json` in the same directory as this readme.
 Please update the provenance information in that file when ingesting an updated version of the dependent library.
-That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropiate governance standards.
+That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropriate governance standards.
 
 ## What should be done to update this in the future?
 
@@ -12,4 +12,4 @@ That provenance file is automatically read and inventoried by Microsoft systems
 2. Take the parts you want, but leave most of it behind since it's HUGE and will bloat the repo to take it all.  At the time of this writing, we only use small_vector.hpp and its dependencies as a header-only library.
 3. Validate that the license in the root of the repository didn't change and update it if so. It is sitting in a version-specific subdirectory below this readme. 
    If it changed dramatically, ensure that it is still compatible with our license scheme. Also update the NOTICE file in the root of our repository to declare the third-party usage.
-4. Submit the pull.
+4. Submit the pull.

oss/chromium/MAINTAINER_README.md

@@ -4,7 +4,7 @@ This was originally imported by @miniksa in January 2020.
 
 The provenance information (where it came from and which commit) is stored in the file `cgmanifest.json` in the same directory as this readme.
 Please update the provenance information in that file when ingesting an updated version of the dependent library.
-That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropiate governance standards.
+That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropriate governance standards.
 
 ## What should be done to update this in the future?
 

oss/dynamic_bitset/MAINTAINER_README.md

@@ -4,7 +4,7 @@ This was originally imported by @miniksa in March 2020.
 
 The provenance information (where it came from and which commit) is stored in the file `cgmanifest.json` in the same directory as this readme.
 Please update the provenance information in that file when ingesting an updated version of the dependent library.
-That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropiate governance standards.
+That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropriate governance standards.
 
 ## What should be done to update this in the future?
 

oss/fmt/MAINTAINER_README.md

@@ -4,7 +4,7 @@ This was originally imported by @DHowett-MSFT in April 2020.
 
 The provenance information (where it came from and which commit) is stored in the file `cgmanifest.json` in the same directory as this readme.
 Please update the provenance information in that file when ingesting an updated version of the dependent library.
-That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropiate governance standards.
+That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropriate governance standards.
 
 ## What should be done to update this in the future?
 

oss/interval_tree/MAINTAINER_README.md

@@ -4,7 +4,7 @@ This was originally imported by @PankajBhojwani in September 2020.
 
 The provenance information (where it came from and which commit) is stored in the file `cgmanifest.json` in the same directory as this readme.
 Please update the provenance information in that file when ingesting an updated version of the dependent library.
-That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropiate governance standards.
+That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropriate governance standards.
 
 ## What should be done to update this in the future?
 

oss/libpopcnt/MAINTAINER_README.md

@@ -4,7 +4,7 @@ This was originally imported by @miniksa in March 2020.
 
 The provenance information (where it came from and which commit) is stored in the file `cgmanifest.json` in the same directory as this readme.
 Please update the provenance information in that file when ingesting an updated version of the dependent library.
-That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropiate governance standards.
+That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropriate governance standards.
 
 ## What should be done to update this in the future?
 

oss/xorg_apps_rgb/MAINTAINER_README.md

@@ -4,4 +4,4 @@ This manifest anchors our usage of rgb.txt from the X11 distribution.
 
 The provenance information (where it came from and which commit) is stored in the file `cgmanifest.json` in the same directory as this readme.
 Please update the provenance information in that file when ingesting an updated version of the dependent library.
-That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropiate governance standards.
+That provenance file is automatically read and inventoried by Microsoft systems to ensure compliance with appropriate governance standards.

res/fonts/README.md

@@ -8,5 +8,5 @@ Please consult the [license](https://raw.githubusercontent.com/microsoft/cascadi
 
 ### Fonts Included
 
-* Cascadia Code, Cascadia Mono (2106.17)
-   * from microsoft/cascadia-code@fb0bce69c1c12f6c298b8bc1c1d181868f5daa9a
+* Cascadia Code, Cascadia Mono (2108.26)
+   * from microsoft/cascadia-code@f91d08f703ee61cf4ae936b9700ca974de2748fe

scratch/ScratchIslandApp/Package/Package.wapproj

@@ -140,12 +140,12 @@
   <!-- **END VC LIBS HACK** -->
 
   <!-- This is required to get the package dependency in the AppXManifest. -->
-  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets'))" />
+    <Error Condition="!Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets'))" />
   </Target>
 
 

scratch/ScratchIslandApp/SampleApp/SampleAppLib.vcxproj

@@ -147,13 +147,13 @@
   <!-- ========================= Globals ======================== -->
   <Import Project="$(OpenConsoleDir)src\cppwinrt.build.post.props" />
 
-  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Import Project="..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets'))" />
+    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets'))" />
     <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets'))" />
   </Target>
 

scratch/ScratchIslandApp/SampleApp/dll/SampleApp.vcxproj

@@ -80,13 +80,13 @@
   </ItemGroup>
 
 
-  <Import Project="$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Import Project="$(OpenConsoleDir)packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('$(OpenConsoleDir)packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets'))" />
+    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets'))" />
     <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets'))" />
   </Target>
 

scratch/ScratchIslandApp/SampleApp/packages.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Microsoft.Toolkit.Win32.UI.XamlApplication" version="6.1.3" targetFramework="native" />
-  <package id="Microsoft.UI.Xaml" version="2.6.2-prerelease.210818003" targetFramework="native" />
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.UI.Xaml" version="2.5.0-prerelease.201202003" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.210825.3" targetFramework="native" />
 </packages>

scratch/ScratchIslandApp/WindowExe/WindowExe.vcxproj

@@ -120,14 +120,14 @@
 
   <Import Project="$(OpenConsoleDir)src\cppwinrt.build.post.props" />
 
-  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Import Project="..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
   <Import Project="..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.4\build\native\Microsoft.VCRTForwarders.140.targets" Condition="Exists('..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.4\build\native\Microsoft.VCRTForwarders.140.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets'))" />
+    <Error Condition="!Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets'))" />
     <Error Condition="!Exists('..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.props'))" />
     <Error Condition="!Exists('..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets'))" />
     <Error Condition="!Exists('..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.4\build\native\Microsoft.VCRTForwarders.140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.4\build\native\Microsoft.VCRTForwarders.140.targets'))" />

scratch/ScratchIslandApp/WindowExe/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.210825.3" targetFramework="native" />
   <package id="Microsoft.Toolkit.Win32.UI.XamlApplication" version="6.1.3" targetFramework="native" />
-  <package id="Microsoft.UI.Xaml" version="2.6.2-prerelease.210818003" targetFramework="native" />
+  <package id="Microsoft.UI.Xaml" version="2.5.0-prerelease.201202003" targetFramework="native" />
   <package id="Microsoft.VCRTForwarders.140" version="1.0.4" targetFramework="native" />
 </packages>

src/cascadia/CascadiaPackage/CascadiaPackage.wapproj

@@ -146,12 +146,12 @@
   <!-- **END VC LIBS HACK** -->
 
   <!-- This is required to get the package dependency in the AppXManifest. -->
-  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets'))" />
+    <Error Condition="!Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets'))" />
   </Target>
 
   <Import Project="$(SolutionDir)build\rules\CollectWildcardResources.targets" />

src/cascadia/LocalTests_SettingsModel/CommandTests.cpp

@@ -152,6 +152,10 @@ namespace SettingsModelLocalTests
             { "name": "command4", "command": { "action": "splitPane" } },
             { "name": "command5", "command": { "action": "splitPane", "split": "auto" } },
             { "name": "command6", "command": { "action": "splitPane", "size": 0.25 } },
+            { "name": "command7", "command": { "action": "splitPane", "split": "right" } },
+            { "name": "command8", "command": { "action": "splitPane", "split": "left" } },
+            { "name": "command9", "command": { "action": "splitPane", "split": "up" } },
+            { "name": "command10", "command": { "action": "splitPane", "split": "down" } },
         ])" };
 
         const auto commands0Json = VerifyParseSucceeded(commands0String);
@@ -160,7 +164,7 @@ namespace SettingsModelLocalTests
         VERIFY_ARE_EQUAL(0u, commands.Size());
         auto warnings = implementation::Command::LayerJson(commands, commands0Json);
         VERIFY_ARE_EQUAL(0u, warnings.size());
-        VERIFY_ARE_EQUAL(5u, commands.Size());
+        VERIFY_ARE_EQUAL(9u, commands.Size());
 
         {
             auto command = commands.Lookup(L"command1");
@@ -170,7 +174,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
         }
         {
@@ -181,7 +185,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
         }
         {
@@ -192,7 +196,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
         }
         {
@@ -203,7 +207,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
         }
         {
@@ -214,9 +218,53 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.25, realArgs.SplitSize());
         }
+        {
+            auto command = commands.Lookup(L"command7");
+            VERIFY_IS_NOT_NULL(command);
+            VERIFY_IS_NOT_NULL(command.ActionAndArgs());
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
+            const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(realArgs);
+            // Verify the args have the expected value
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
+            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
+        }
+        {
+            auto command = commands.Lookup(L"command8");
+            VERIFY_IS_NOT_NULL(command);
+            VERIFY_IS_NOT_NULL(command.ActionAndArgs());
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
+            const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(realArgs);
+            // Verify the args have the expected value
+            VERIFY_ARE_EQUAL(SplitDirection::Left, realArgs.SplitDirection());
+            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
+        }
+        {
+            auto command = commands.Lookup(L"command9");
+            VERIFY_IS_NOT_NULL(command);
+            VERIFY_IS_NOT_NULL(command.ActionAndArgs());
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
+            const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(realArgs);
+            // Verify the args have the expected value
+            VERIFY_ARE_EQUAL(SplitDirection::Up, realArgs.SplitDirection());
+            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
+        }
+        {
+            auto command = commands.Lookup(L"command10");
+            VERIFY_IS_NOT_NULL(command);
+            VERIFY_IS_NOT_NULL(command.ActionAndArgs());
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
+            const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(realArgs);
+            // Verify the args have the expected value
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
+            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
+        }
     }
 
     void CommandTests::TestSplitPaneBadSize()
@@ -244,7 +292,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.25, realArgs.SplitSize());
         }
     }
@@ -286,8 +334,10 @@ namespace SettingsModelLocalTests
 
         const std::string commands0String{ R"([
             { "command": { "action": "splitPane", "split": null } },
-            { "command": { "action": "splitPane", "split": "vertical" } },
-            { "command": { "action": "splitPane", "split": "horizontal" } },
+            { "command": { "action": "splitPane", "split": "left" } },
+            { "command": { "action": "splitPane", "split": "right" } },
+            { "command": { "action": "splitPane", "split": "up" } },
+            { "command": { "action": "splitPane", "split": "down" } },
             { "command": { "action": "splitPane", "split": "none" } },
             { "command": { "action": "splitPane" } },
             { "command": { "action": "splitPane", "split": "auto" } },
@@ -301,10 +351,10 @@ namespace SettingsModelLocalTests
         auto warnings = implementation::Command::LayerJson(commands, commands0Json);
         VERIFY_ARE_EQUAL(0u, warnings.size());
 
-        // There are only 3 commands here: all of the `"none"`, `"auto"`,
+        // There are only 5 commands here: all of the `"none"`, `"auto"`,
         // `"foo"`, `null`, and <no args> bindings all generate the same action,
         // which will generate just a single name for all of them.
-        VERIFY_ARE_EQUAL(3u, commands.Size());
+        VERIFY_ARE_EQUAL(5u, commands.Size());
 
         {
             auto command = commands.Lookup(L"Split pane");
@@ -314,27 +364,47 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
         }
         {
-            auto command = commands.Lookup(L"Split pane, split: vertical");
+            auto command = commands.Lookup(L"Split pane, split: left");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.ActionAndArgs());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Left, realArgs.SplitDirection());
         }
         {
-            auto command = commands.Lookup(L"Split pane, split: horizontal");
+            auto command = commands.Lookup(L"Split pane, split: right");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.ActionAndArgs());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
+        }
+        {
+            auto command = commands.Lookup(L"Split pane, split: up");
+            VERIFY_IS_NOT_NULL(command);
+            VERIFY_IS_NOT_NULL(command.ActionAndArgs());
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
+            const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(realArgs);
+            // Verify the args have the expected value
+            VERIFY_ARE_EQUAL(SplitDirection::Up, realArgs.SplitDirection());
+        }
+        {
+            auto command = commands.Lookup(L"Split pane, split: down");
+            VERIFY_IS_NOT_NULL(command);
+            VERIFY_IS_NOT_NULL(command.ActionAndArgs());
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.ActionAndArgs().Action());
+            const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(realArgs);
+            // Verify the args have the expected value
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
         }
     }
     void CommandTests::TestLayerOnAutogeneratedName()
@@ -360,7 +430,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = command.ActionAndArgs().Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
         }
     }
 

src/cascadia/LocalTests_SettingsModel/DeserializationTests.cpp

@@ -2130,7 +2130,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -2147,7 +2147,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -2161,7 +2161,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -2175,7 +2175,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -2189,7 +2189,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -2218,7 +2218,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());

src/cascadia/LocalTests_SettingsModel/KeyBindingsTests.cpp

@@ -432,7 +432,7 @@ namespace SettingsModelLocalTests
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
             const auto& realArgs = actionAndArgs.Args().as<SplitPaneArgs>();
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
         }
         {
             KeyChord kc{ true, false, false, false, static_cast<int32_t>('E'), 0 };
@@ -440,7 +440,7 @@ namespace SettingsModelLocalTests
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
             const auto& realArgs = actionAndArgs.Args().as<SplitPaneArgs>();
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
         }
         {
             KeyChord kc{ true, false, false, false, static_cast<int32_t>('G'), 0 };
@@ -448,7 +448,7 @@ namespace SettingsModelLocalTests
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
             const auto& realArgs = actionAndArgs.Args().as<SplitPaneArgs>();
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
         }
         {
             KeyChord kc{ true, false, false, false, static_cast<int32_t>('H'), 0 };
@@ -456,7 +456,7 @@ namespace SettingsModelLocalTests
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
             const auto& realArgs = actionAndArgs.Args().as<SplitPaneArgs>();
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
         }
     }
 

src/cascadia/LocalTests_SettingsModel/SerializationTests.cpp

@@ -256,10 +256,14 @@ namespace SettingsModelLocalTests
                                             ])" };
 
         // complex command with key chords
-        const std::string actionsString4{ R"([
+        const std::string actionsString4A{ R"([
                                                 { "command": { "action": "adjustFontSize", "delta": 1 }, "keys": "ctrl+c" },
                                                 { "command": { "action": "adjustFontSize", "delta": 1 }, "keys": "ctrl+d" }
                                             ])" };
+        const std::string actionsString4B{ R"([
+                                                { "command": { "action": "findMatch", "direction": "next" }, "keys": "ctrl+shift+s" },
+                                                { "command": { "action": "findMatch", "direction": "prev" }, "keys": "ctrl+shift+r" }
+                                            ])" };
 
         // command with name and icon and multiple key chords
         const std::string actionsString5{ R"([
@@ -372,7 +376,8 @@ namespace SettingsModelLocalTests
         RoundtripTest<implementation::ActionMap>(actionsString3);
 
         Log::Comment(L"complex commands with key chords");
-        RoundtripTest<implementation::ActionMap>(actionsString4);
+        RoundtripTest<implementation::ActionMap>(actionsString4A);
+        RoundtripTest<implementation::ActionMap>(actionsString4B);
 
         Log::Comment(L"command with name and icon and multiple key chords");
         RoundtripTest<implementation::ActionMap>(actionsString5);

src/cascadia/LocalTests_SettingsModel/SettingsModel.LocalTests.vcxproj

@@ -98,10 +98,10 @@
     <!-- From Microsoft.UI.Xaml.targets -->
     <Native-Platform Condition="'$(Platform)' == 'Win32'">x86</Native-Platform>
     <Native-Platform Condition="'$(Platform)' != 'Win32'">$(Platform)</Native-Platform>
-    <_MUXBinRoot>&quot;$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\runtimes\win10-$(Native-Platform)\native\&quot;</_MUXBinRoot>
+    <_MUXBinRoot>&quot;$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\runtimes\win10-$(Native-Platform)\native\&quot;</_MUXBinRoot>
   </PropertyGroup>
 
 <!-- We actually can just straight up reference MUX here, it's fine -->
-  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
 
 </Project>

src/cascadia/LocalTests_SettingsModel/TerminalSettingsTests.cpp

@@ -42,6 +42,8 @@ namespace SettingsModelLocalTests
 
         TEST_METHOD(TestLayerProfileOnColorScheme);
 
+        TEST_METHOD(TestCommandlineToTitlePromotion);
+
         TEST_CLASS_SETUP(ClassSetup)
         {
             return true;
@@ -63,7 +65,7 @@ namespace SettingsModelLocalTests
         const std::string settingsJson{ R"(
         {
             "defaultProfile": "{6239a42c-0000-49a3-80bd-e8fdd045185c}",
-            "profiles": [
+            "profiles": { "list": [
                 {
                     "name": "profile0",
                     "guid": "{6239a42c-0000-49a3-80bd-e8fdd045185c}",
@@ -82,6 +84,9 @@ namespace SettingsModelLocalTests
                     "commandline": "wsl.exe"
                 }
             ],
+            "defaults": {
+                "historySize": 29
+            } },
             "keybindings": [
                 { "keys": ["ctrl+a"], "command": { "action": "splitPane", "split": "vertical" } },
                 { "keys": ["ctrl+b"], "command": { "action": "splitPane", "split": "vertical", "profile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}" } },
@@ -119,7 +124,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -140,7 +145,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -162,7 +167,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -184,7 +189,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -206,7 +211,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_FALSE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -217,9 +222,18 @@ namespace SettingsModelLocalTests
             const auto profile{ settings.GetProfileForArgs(realArgs.TerminalArgs()) };
             const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, realArgs.TerminalArgs(), nullptr) };
             const auto termSettings = settingsStruct.DefaultSettings();
-            VERIFY_ARE_EQUAL(guid0, profile.Guid());
+            if constexpr (Feature_ShowProfileDefaultsInSettings::IsEnabled())
+            {
+                // This action specified a command but no profile; it gets reassigned to the base profile
+                VERIFY_ARE_EQUAL(settings.ProfileDefaults(), profile);
+                VERIFY_ARE_EQUAL(29, termSettings.HistorySize());
+            }
+            else
+            {
+                VERIFY_ARE_EQUAL(guid0, profile.Guid());
+                VERIFY_ARE_EQUAL(1, termSettings.HistorySize());
+            }
             VERIFY_ARE_EQUAL(L"foo.exe", termSettings.Commandline());
-            VERIFY_ARE_EQUAL(1, termSettings.HistorySize());
         }
         {
             KeyChord kc{ true, false, false, false, static_cast<int32_t>('F'), 0 };
@@ -228,7 +242,7 @@ namespace SettingsModelLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_FALSE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -554,4 +568,85 @@ namespace SettingsModelLocalTests
         VERIFY_ARE_EQUAL(ARGB(0, 0x45, 0x67, 0x89), terminalSettings4->CursorColor()); // from profile (no color scheme)
         VERIFY_ARE_EQUAL(DEFAULT_CURSOR_COLOR, terminalSettings5->CursorColor()); // default
     }
+
+    void TerminalSettingsTests::TestCommandlineToTitlePromotion()
+    {
+        const std::string settingsJson{ R"(
+        {
+            "defaultProfile": "{6239a42c-0000-49a3-80bd-e8fdd045185c}",
+            "profiles": { "list": [
+                {
+                    "name": "profile0",
+                    "guid": "{6239a42c-0000-49a3-80bd-e8fdd045185c}",
+                    "historySize": 1,
+                    "commandline": "cmd.exe"
+                },
+            ],
+            "defaults": {
+                "historySize": 29
+            } }
+        })" };
+
+        const winrt::guid guid0{ ::Microsoft::Console::Utils::GuidFromString(L"{6239a42c-0000-49a3-80bd-e8fdd045185c}") };
+
+        CascadiaSettings settings{ til::u8u16(settingsJson) };
+
+        { // just a profile (profile wins)
+            NewTerminalArgs args{};
+            args.Profile(L"profile0");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"profile0", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        { // profile and command line -> no promotion (profile wins)
+            NewTerminalArgs args{};
+            args.Profile(L"profile0");
+            args.Commandline(L"foo.exe");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"profile0", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        { // just a title -> it is propagated
+            NewTerminalArgs args{};
+            args.TabTitle(L"Analog Kid");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"Analog Kid", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        { // title and command line -> no promotion
+            NewTerminalArgs args{};
+            args.TabTitle(L"Digital Man");
+            args.Commandline(L"foo.exe");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"Digital Man", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        { // just a commandline -> promotion
+            NewTerminalArgs args{};
+            args.Commandline(L"foo.exe");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"foo.exe", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        // various typesof commandline follow
+        {
+            NewTerminalArgs args{};
+            args.Commandline(L"foo.exe bar");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"foo.exe", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        {
+            NewTerminalArgs args{};
+            args.Commandline(L"\"foo exe.exe\" bar");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"foo exe.exe", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        {
+            NewTerminalArgs args{};
+            args.Commandline(L"\"\" grand designs");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"", settingsStruct.DefaultSettings().StartingTitle());
+        }
+        {
+            NewTerminalArgs args{};
+            args.Commandline(L" imagine a man");
+            const auto settingsStruct{ TerminalSettings::CreateWithNewTerminalArgs(settings, args, nullptr) };
+            VERIFY_ARE_EQUAL(L"", settingsStruct.DefaultSettings().StartingTitle());
+        }
+    }
 }

src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp

@@ -715,7 +715,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
             VERIFY_ARE_EQUAL(SplitType::Manual, myArgs.SplitMode());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
         }
@@ -735,7 +735,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, myArgs.SplitDirection());
             VERIFY_ARE_EQUAL(SplitType::Manual, myArgs.SplitMode());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
         }
@@ -757,7 +757,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Vertical, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Right, myArgs.SplitDirection());
             VERIFY_ARE_EQUAL(SplitType::Manual, myArgs.SplitMode());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
         }
@@ -799,7 +799,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
             VERIFY_IS_FALSE(myArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
@@ -828,7 +828,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Horizontal, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Down, myArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
             VERIFY_IS_FALSE(myArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
@@ -857,7 +857,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
             VERIFY_IS_FALSE(myArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
@@ -1779,7 +1779,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.5f, myArgs.SplitSize());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
         }
@@ -1799,7 +1799,7 @@ namespace TerminalAppLocalTests
             VERIFY_IS_NOT_NULL(actionAndArgs.Args());
             auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
             VERIFY_ARE_EQUAL(0.3f, myArgs.SplitSize());
             VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
         }
@@ -1820,7 +1820,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_NOT_NULL(actionAndArgs.Args());
                 auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
                 VERIFY_ARE_EQUAL(0.3f, myArgs.SplitSize());
                 VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
             }
@@ -1830,7 +1830,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_NOT_NULL(actionAndArgs.Args());
                 auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
                 VERIFY_ARE_EQUAL(0.5f, myArgs.SplitSize());
                 VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
             }
@@ -1852,7 +1852,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_NOT_NULL(actionAndArgs.Args());
                 auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
                 VERIFY_ARE_EQUAL(0.3f, myArgs.SplitSize());
                 VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
             }
@@ -1862,7 +1862,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_NOT_NULL(actionAndArgs.Args());
                 auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Automatic, myArgs.SplitDirection());
                 VERIFY_ARE_EQUAL(0.7f, myArgs.SplitSize());
                 VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
             }

src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp

@@ -132,7 +132,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -156,7 +156,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -174,7 +174,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -192,7 +192,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -259,7 +259,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -283,7 +283,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -301,7 +301,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -319,7 +319,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -388,7 +388,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -412,7 +412,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -430,7 +430,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -448,7 +448,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -680,16 +680,16 @@ namespace TerminalAppLocalTests
         // <Command Palette>
         //  ├─ profile0...
         //  |  ├─ Split pane, profile: profile0
-        //  |  ├─ Split pane, direction: vertical, profile: profile0
-        //  |  └─ Split pane, direction: horizontal, profile: profile0
+        //  |  ├─ Split pane, direction: right, profile: profile0
+        //  |  └─ Split pane, direction: down, profile: profile0
         //  ├─ profile1...
         //  |  ├─Split pane, profile: profile1
-        //  |  ├─Split pane, direction: vertical, profile: profile1
-        //  |  └─Split pane, direction: horizontal, profile: profile1
+        //  |  ├─Split pane, direction: right, profile: profile1
+        //  |  └─Split pane, direction: down, profile: profile1
         //  └─ profile2...
         //     ├─ Split pane, profile: profile2
-        //     ├─ Split pane, direction: vertical, profile: profile2
-        //     └─ Split pane, direction: horizontal, profile: profile2
+        //     ├─ Split pane, direction: right, profile: profile2
+        //     └─ Split pane, direction: down, profile: profile2
 
         const std::string settingsJson{ R"(
         {
@@ -719,8 +719,8 @@ namespace TerminalAppLocalTests
                     "name": "${profile.name}...",
                     "commands": [
                         { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "auto" } },
-                        { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "vertical" } },
-                        { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "horizontal" } }
+                        { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "right" } },
+                        { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "down" } }
                     ]
                 }
             ],
@@ -762,7 +762,7 @@ namespace TerminalAppLocalTests
                 const auto& realArgs = childActionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(realArgs);
                 // Verify the args have the expected value
-                VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
                 VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -773,7 +773,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_FALSE(childCommand.HasNestedCommands());
             }
             {
-                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: horizontal, profile: {}", name) };
+                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: down, profile: {}", name) };
                 auto childCommand = command.NestedCommands().Lookup(childCommandName);
                 VERIFY_IS_NOT_NULL(childCommand);
                 auto childActionAndArgs = childCommand.ActionAndArgs();
@@ -783,7 +783,7 @@ namespace TerminalAppLocalTests
                 const auto& realArgs = childActionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(realArgs);
                 // Verify the args have the expected value
-                VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
                 VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -794,7 +794,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_FALSE(childCommand.HasNestedCommands());
             }
             {
-                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: vertical, profile: {}", name) };
+                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: right, profile: {}", name) };
                 auto childCommand = command.NestedCommands().Lookup(childCommandName);
                 VERIFY_IS_NOT_NULL(childCommand);
                 auto childActionAndArgs = childCommand.ActionAndArgs();
@@ -804,7 +804,7 @@ namespace TerminalAppLocalTests
                 const auto& realArgs = childActionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(realArgs);
                 // Verify the args have the expected value
-                VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
                 VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -915,16 +915,16 @@ namespace TerminalAppLocalTests
         // └─ New Pane...
         //    ├─ profile0...
         //    |  ├─ Split automatically
-        //    |  ├─ Split vertically
-        //    |  └─ Split horizontally
+        //    |  ├─ Split right
+        //    |  └─ Split down
         //    ├─ profile1...
         //    |  ├─ Split automatically
-        //    |  ├─ Split vertically
-        //    |  └─ Split horizontally
+        //    |  ├─ Split right
+        //    |  └─ Split down
         //    └─ profile2...
         //       ├─ Split automatically
-        //       ├─ Split vertically
-        //       └─ Split horizontally
+        //       ├─ Split right
+        //       └─ Split down
 
         const std::string settingsJson{ R"(
         {
@@ -957,8 +957,8 @@ namespace TerminalAppLocalTests
                             "name": "${profile.name}...",
                             "commands": [
                                 { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "auto" } },
-                                { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "vertical" } },
-                                { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "horizontal" } }
+                                { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "right" } },
+                                { "command": { "action": "splitPane", "profile": "${profile.name}", "split": "down" } }
                             ]
                         }
                     ]
@@ -1010,7 +1010,7 @@ namespace TerminalAppLocalTests
                 const auto& realArgs = childActionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(realArgs);
                 // Verify the args have the expected value
-                VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
                 VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -1021,7 +1021,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_FALSE(childCommand.HasNestedCommands());
             }
             {
-                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: horizontal, profile: {}", name) };
+                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: down, profile: {}", name) };
                 auto childCommand = command.NestedCommands().Lookup(childCommandName);
                 VERIFY_IS_NOT_NULL(childCommand);
                 auto childActionAndArgs = childCommand.ActionAndArgs();
@@ -1031,7 +1031,7 @@ namespace TerminalAppLocalTests
                 const auto& realArgs = childActionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(realArgs);
                 // Verify the args have the expected value
-                VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Down, realArgs.SplitDirection());
                 VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -1042,7 +1042,7 @@ namespace TerminalAppLocalTests
                 VERIFY_IS_FALSE(childCommand.HasNestedCommands());
             }
             {
-                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: vertical, profile: {}", name) };
+                winrt::hstring childCommandName{ fmt::format(L"Split pane, split: right, profile: {}", name) };
                 auto childCommand = command.NestedCommands().Lookup(childCommandName);
                 VERIFY_IS_NOT_NULL(childCommand);
                 auto childActionAndArgs = childCommand.ActionAndArgs();
@@ -1052,7 +1052,7 @@ namespace TerminalAppLocalTests
                 const auto& realArgs = childActionAndArgs.Args().try_as<SplitPaneArgs>();
                 VERIFY_IS_NOT_NULL(realArgs);
                 // Verify the args have the expected value
-                VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
+                VERIFY_ARE_EQUAL(SplitDirection::Right, realArgs.SplitDirection());
                 VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
                 VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -1127,7 +1127,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -1156,7 +1156,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -1174,7 +1174,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());
@@ -1192,7 +1192,7 @@ namespace TerminalAppLocalTests
             const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
+            VERIFY_ARE_EQUAL(SplitDirection::Automatic, realArgs.SplitDirection());
             VERIFY_IS_NOT_NULL(realArgs.TerminalArgs());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().Commandline().empty());
             VERIFY_IS_TRUE(realArgs.TerminalArgs().StartingDirectory().empty());

src/cascadia/LocalTests_TerminalApp/TabTests.cpp

@@ -508,7 +508,7 @@ namespace TerminalAppLocalTests
 
         Log::Comment(NoThrowString().Format(L"Duplicate the first pane"));
         result = RunOnUIThread([&page]() {
-            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, 0.5f, nullptr);
+            page->_SplitPane(SplitDirection::Automatic, SplitType::Duplicate, 0.5f, nullptr);
 
             VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
             auto tab = page->_GetTerminalTabImpl(page->_tabs.GetAt(0));
@@ -526,7 +526,7 @@ namespace TerminalAppLocalTests
 
         Log::Comment(NoThrowString().Format(L"Duplicate the pane, and don't crash"));
         result = RunOnUIThread([&page]() {
-            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, 0.5f, nullptr);
+            page->_SplitPane(SplitDirection::Automatic, SplitType::Duplicate, 0.5f, nullptr);
 
             VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
             auto tab = page->_GetTerminalTabImpl(page->_tabs.GetAt(0));
@@ -844,7 +844,7 @@ namespace TerminalAppLocalTests
             // |   1    |   2    |
             // |        |        |
             // -------------------
-            page->_SplitPane(SplitState::Vertical, SplitType::Duplicate, 0.5f, nullptr);
+            page->_SplitPane(SplitDirection::Right, SplitType::Duplicate, 0.5f, nullptr);
             secondId = tab->_activePane->Id().value();
         });
         Sleep(250);
@@ -862,7 +862,7 @@ namespace TerminalAppLocalTests
             // |   3    |        |
             // |        |        |
             // -------------------
-            page->_SplitPane(SplitState::Horizontal, SplitType::Duplicate, 0.5f, nullptr);
+            page->_SplitPane(SplitDirection::Down, SplitType::Duplicate, 0.5f, nullptr);
             auto tab = page->_GetTerminalTabImpl(page->_tabs.GetAt(0));
             // Split again to make the 3rd tab
             thirdId = tab->_activePane->Id().value();
@@ -882,7 +882,7 @@ namespace TerminalAppLocalTests
             // |   3    |   4    |
             // |        |        |
             // -------------------
-            page->_SplitPane(SplitState::Horizontal, SplitType::Duplicate, 0.5f, nullptr);
+            page->_SplitPane(SplitDirection::Down, SplitType::Duplicate, 0.5f, nullptr);
             auto tab = page->_GetTerminalTabImpl(page->_tabs.GetAt(0));
             fourthId = tab->_activePane->Id().value();
         });

src/cascadia/LocalTests_TerminalApp/TerminalApp.LocalTests.vcxproj

@@ -92,11 +92,11 @@
     <!-- From Microsoft.UI.Xaml.targets -->
     <Native-Platform Condition="'$(Platform)' == 'Win32'">x86</Native-Platform>
     <Native-Platform Condition="'$(Platform)' != 'Win32'">$(Platform)</Native-Platform>
-    <_MUXBinRoot>&quot;$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\runtimes\win10-$(Native-Platform)\native\&quot;</_MUXBinRoot>
+    <_MUXBinRoot>&quot;$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\runtimes\win10-$(Native-Platform)\native\&quot;</_MUXBinRoot>
   </PropertyGroup>
 
 <!-- We actually can just straight up reference MUX here, it's fine -->
-  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Import Project="..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
 
 </Project>

src/cascadia/LocalTests_TerminalApp/TestHostApp/TestHostApp.vcxproj

@@ -123,7 +123,7 @@
     </Reference>
   </ItemGroup>
 
-  <Import Project="$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
 
   <Import Project="$(OpenConsoleDir)\src\common.build.post.props" />
 

src/cascadia/Remoting/Monarch.cpp

@@ -80,8 +80,9 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
             peasant.IdentifyWindowsRequested({ this, &Monarch::_identifyWindows });
             peasant.RenameRequested({ this, &Monarch::_renameRequested });
 
-            peasant.ShowTrayIconRequested([this](auto&&, auto&&) { _ShowTrayIconRequestedHandlers(*this, nullptr); });
-            peasant.HideTrayIconRequested([this](auto&&, auto&&) { _HideTrayIconRequestedHandlers(*this, nullptr); });
+            peasant.ShowNotificationIconRequested([this](auto&&, auto&&) { _ShowNotificationIconRequestedHandlers(*this, nullptr); });
+            peasant.HideNotificationIconRequested([this](auto&&, auto&&) { _HideNotificationIconRequestedHandlers(*this, nullptr); });
+            peasant.QuitAllRequested({ this, &Monarch::_handleQuitAll });
 
             _peasants[newPeasantsId] = peasant;
 
@@ -91,6 +92,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
                               TraceLoggingUInt64(newPeasantsId, "peasantID", "the ID of the new peasant"),
                               TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                               TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+
+            _WindowCreatedHandlers(nullptr, nullptr);
             return newPeasantsId;
         }
         catch (...)
@@ -107,6 +110,75 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         }
     }
 
+    // Method Description:
+    // - Gives the host process an opportunity to run any pre-close logic then
+    //   requests all peasants to close.
+    // Arguments:
+    // - <none> used
+    // Return Value:
+    // - <none>
+    void Monarch::_handleQuitAll(const winrt::Windows::Foundation::IInspectable& /*sender*/,
+                                 const winrt::Windows::Foundation::IInspectable& /*args*/)
+    {
+        // Let the process hosting the monarch run any needed logic before
+        // closing all windows.
+        _QuitAllRequestedHandlers(*this, nullptr);
+
+        // Tell all peasants to exit.
+        const auto callback = [&](const auto& /*id*/, const auto& p) {
+            p.Quit();
+        };
+        const auto onError = [&](const auto& id) {
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_handleQuitAll_Failed",
+                              TraceLoggingInt64(id, "peasantID", "The ID of the peasant which we could not close"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                              TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+        };
+
+        _forEachPeasant(callback, onError);
+    }
+
+    // Method Description:
+    // - Tells the monarch that a peasant is being closed.
+    // Arguments:
+    // - peasantId: the id of the peasant
+    // Return Value:
+    // - <none>
+    void Monarch::SignalClose(const uint64_t peasantId)
+    {
+        _clearOldMruEntries(peasantId);
+        _peasants.erase(peasantId);
+        _WindowClosedHandlers(nullptr, nullptr);
+    }
+
+    // Method Description:
+    // - Counts the number of living peasants.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - the number of active peasants.
+    uint64_t Monarch::GetNumberOfPeasants()
+    {
+        auto num = 0;
+        auto callback = [&](const auto& /*id*/, const auto& p) {
+            // Check that the peasant is alive, and if so increment the count
+            p.GetID();
+            num += 1;
+        };
+        auto onError = [](const auto& id) {
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_GetNumberOfPeasants_Failed",
+                              TraceLoggingInt64(id, "peasantID", "The ID of the peasant which we could not enumerate"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                              TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+        };
+
+        _forEachPeasant(callback, onError);
+
+        return num;
+    }
+
     // Method Description:
     // - Event handler for the Peasant::WindowActivated event. Used as an
     //   opportunity for us to update our internal stack of the "most recent
@@ -613,39 +685,6 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         return *result;
     }
 
-    // Method Description:
-    // - Helper for doing something on each and every peasant, with no regard
-    //   for if the peasant is living or dead.
-    // - We'll try calling callback on every peasant.
-    // - If any single peasant is dead, then we'll call errorCallback, and move on.
-    // - We're taking an errorCallback here, because the thing we usually want
-    //   to do is TraceLog a message, but TraceLoggingWrite is actually a macro
-    //   that _requires_ the second arg to be a string literal. It can't just be
-    //   a variable.
-    // Arguments:
-    // - callback: The function to call on each peasant
-    // - errorCallback: The function to call if a peasant is dead.
-    // Return Value:
-    // - <none>
-    void Monarch::_forAllPeasantsIgnoringTheDead(std::function<void(const Remoting::IPeasant&, const uint64_t)> callback,
-                                                 std::function<void(const uint64_t)> errorCallback)
-    {
-        for (const auto& [id, p] : _peasants)
-        {
-            try
-            {
-                callback(p, id);
-            }
-            catch (...)
-            {
-                LOG_CAUGHT_EXCEPTION();
-                // If this fails, we don't _really_ care. Just move on to the
-                // next one. Someone else will clean up the dead peasant.
-                errorCallback(id);
-            }
-        }
-    }
-
     // Method Description:
     // - This is an event handler for the IdentifyWindowsRequested event. A
     //   Peasant may raise that event if they want _all_ windows to identify
@@ -660,17 +699,18 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
                                    const winrt::Windows::Foundation::IInspectable& /*args*/)
     {
         // Notify all the peasants to display their ID.
-        auto callback = [](auto&& p, auto&& /*id*/) {
+        const auto callback = [&](const auto& /*id*/, const auto& p) {
             p.DisplayWindowId();
         };
-        auto onError = [](auto&& id) {
+        const auto onError = [&](const auto& id) {
             TraceLoggingWrite(g_hRemotingProvider,
                               "Monarch_identifyWindows_Failed",
                               TraceLoggingInt64(id, "peasantID", "The ID of the peasant which we could not identify"),
                               TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                               TraceLoggingKeyword(TIL_KEYWORD_TRACE));
         };
-        _forAllPeasantsIgnoringTheDead(callback, onError);
+
+        _forEachPeasant(callback, onError);
     }
 
     // Method Description:
@@ -812,48 +852,68 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
     // - <none>
     // Return Value:
     // - A map of peasant IDs to their names.
-    Windows::Foundation::Collections::IMapView<uint64_t, winrt::hstring> Monarch::GetPeasantNames()
+    Windows::Foundation::Collections::IVectorView<PeasantInfo> Monarch::GetPeasantInfos()
     {
-        auto names = winrt::single_threaded_map<uint64_t, winrt::hstring>();
+        std::vector<PeasantInfo> names;
+        names.reserve(_peasants.size());
 
-        std::vector<uint64_t> peasantsToErase{};
-        for (const auto& [id, p] : _peasants)
-        {
-            try
+        const auto func = [&](const auto& id, const auto& p) -> void {
+            names.push_back({ id, p.WindowName(), p.ActiveTabTitle() });
+        };
+
+        const auto onError = [&](const auto& id) {
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_identifyWindows_Failed",
+                              TraceLoggingInt64(id, "peasantID", "The ID of the peasant which we could not identify"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                              TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+        };
+
+        _forEachPeasant(func, onError);
+
+        return winrt::single_threaded_vector<PeasantInfo>(std::move(names)).GetView();
+    }
+
+    bool Monarch::DoesQuakeWindowExist()
+    {
+        bool result = false;
+        const auto func = [&](const auto& /*id*/, const auto& p) {
+            if (p.WindowName() == QuakeWindowName)
             {
-                names.Insert(id, p.WindowName());
+                result = true;
             }
-            catch (...)
-            {
-                LOG_CAUGHT_EXCEPTION();
-                peasantsToErase.push_back(id);
-            }
-        }
+            // continue if we didn't get a positive result
+            return !result;
+        };
 
-        // Remove the dead peasants we came across while iterating.
-        for (const auto& id : peasantsToErase)
-        {
-            _peasants.erase(id);
-            _clearOldMruEntries(id);
-        }
+        const auto onError = [&](const auto& id) {
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_DoesQuakeWindowExist_Failed",
+                              TraceLoggingInt64(id, "peasantID", "The ID of the peasant which we could not ask for its name"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                              TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+        };
 
-        return names.GetView();
+        _forEachPeasant(func, onError);
+        return result;
     }
 
     void Monarch::SummonAllWindows()
     {
-        auto callback = [](auto&& p, auto&& /*id*/) {
+        const auto func = [&](const auto& /*id*/, const auto& p) {
             SummonWindowBehavior args{};
             args.ToggleVisibility(false);
             p.Summon(args);
         };
-        auto onError = [](auto&& id) {
+
+        const auto onError = [&](const auto& id) {
             TraceLoggingWrite(g_hRemotingProvider,
                               "Monarch_SummonAll_Failed",
                               TraceLoggingInt64(id, "peasantID", "The ID of the peasant which we could not summon"),
                               TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                               TraceLoggingKeyword(TIL_KEYWORD_TRACE));
         };
-        _forAllPeasantsIgnoringTheDead(callback, onError);
+
+        _forEachPeasant(func, onError);
     }
 }

src/cascadia/Remoting/Monarch.h

@@ -47,17 +47,24 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         uint64_t GetPID();
 
         uint64_t AddPeasant(winrt::Microsoft::Terminal::Remoting::IPeasant peasant);
+        void SignalClose(const uint64_t peasantId);
+
+        uint64_t GetNumberOfPeasants();
 
         winrt::Microsoft::Terminal::Remoting::ProposeCommandlineResult ProposeCommandline(const winrt::Microsoft::Terminal::Remoting::CommandlineArgs& args);
         void HandleActivatePeasant(const winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs& args);
         void SummonWindow(const Remoting::SummonWindowSelectionArgs& args);
 
         void SummonAllWindows();
-        Windows::Foundation::Collections::IMapView<uint64_t, winrt::hstring> GetPeasantNames();
+        bool DoesQuakeWindowExist();
+        Windows::Foundation::Collections::IVectorView<winrt::Microsoft::Terminal::Remoting::PeasantInfo> GetPeasantInfos();
 
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);
-        TYPED_EVENT(ShowTrayIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
-        TYPED_EVENT(HideTrayIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(ShowNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(HideNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(WindowCreated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(WindowClosed, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(QuitAllRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
 
     private:
         uint64_t _ourPID;
@@ -89,6 +96,70 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         void _renameRequested(const winrt::Windows::Foundation::IInspectable& sender,
                               const winrt::Microsoft::Terminal::Remoting::RenameRequestArgs& args);
 
+        void _handleQuitAll(const winrt::Windows::Foundation::IInspectable& sender,
+                            const winrt::Windows::Foundation::IInspectable& args);
+
+        // Method Description:
+        // - Helper for doing something on each and every peasant.
+        // - We'll try calling func on every peasant.
+        // - If the return type of func is void, it will perform it for all peasants.
+        // - If the return type is a boolean, we'll break out of the loop once func
+        //   returns false.
+        // - If any single peasant is dead, then we'll call onError and then add it to a
+        //   list of peasants to clean up once the loop ends.
+        // Arguments:
+        // - func: The function to call on each peasant
+        // - onError: The function to call if a peasant is dead.
+        // Return Value:
+        // - <none>
+        template<typename F, typename T>
+        void _forEachPeasant(F&& func, T&& onError)
+        {
+            using Map = decltype(_peasants);
+            using R = std::invoke_result_t<F, Map::key_type, Map::mapped_type>;
+            static constexpr auto IsVoid = std::is_void_v<R>;
+
+            std::vector<uint64_t> peasantsToErase;
+
+            for (const auto& [id, p] : _peasants)
+            {
+                try
+                {
+                    if constexpr (IsVoid)
+                    {
+                        func(id, p);
+                    }
+                    else
+                    {
+                        if (!func(id, p))
+                        {
+                            break;
+                        }
+                    }
+                }
+                catch (const winrt::hresult_error& exception)
+                {
+                    onError(id);
+
+                    if (exception.code() == 0x800706ba) // The RPC server is unavailable.
+                    {
+                        peasantsToErase.emplace_back(id);
+                    }
+                    else
+                    {
+                        LOG_CAUGHT_EXCEPTION();
+                        throw;
+                    }
+                }
+            }
+
+            for (const auto& id : peasantsToErase)
+            {
+                _peasants.erase(id);
+                _clearOldMruEntries(id);
+            }
+        }
+
         friend class RemotingUnitTests::RemotingTests;
     };
 }

src/cascadia/Remoting/Monarch.idl

@@ -31,21 +31,33 @@ namespace Microsoft.Terminal.Remoting
         Windows.Foundation.IReference<UInt64> WindowID;
     }
 
+    struct PeasantInfo
+    {
+        UInt64 Id;
+        String Name;
+        String TabTitle;
+    };
 
     [default_interface] runtimeclass Monarch {
         Monarch();
 
         UInt64 GetPID();
         UInt64 AddPeasant(IPeasant peasant);
+        UInt64 GetNumberOfPeasants();
         ProposeCommandlineResult ProposeCommandline(CommandlineArgs args);
         void HandleActivatePeasant(WindowActivatedArgs args);
         void SummonWindow(SummonWindowSelectionArgs args);
+        void SignalClose(UInt64 peasantId);
 
         void SummonAllWindows();
-        Windows.Foundation.Collections.IMapView<UInt64, String> GetPeasantNames { get; };
+        Boolean DoesQuakeWindowExist();
+        Windows.Foundation.Collections.IVectorView<PeasantInfo> GetPeasantInfos { get; };
 
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;
-        event Windows.Foundation.TypedEventHandler<Object, Object> ShowTrayIconRequested;
-        event Windows.Foundation.TypedEventHandler<Object, Object> HideTrayIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> ShowNotificationIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> HideNotificationIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> WindowCreated;
+        event Windows.Foundation.TypedEventHandler<Object, Object> WindowClosed;
+        event Windows.Foundation.TypedEventHandler<Object, Object> QuitAllRequested;
     };
 }

src/cascadia/Remoting/Peasant.cpp

@@ -226,34 +226,66 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
                           TraceLoggingKeyword(TIL_KEYWORD_TRACE));
     }
 
-    void Peasant::RequestShowTrayIcon()
+    void Peasant::RequestShowNotificationIcon()
     {
         try
         {
-            _ShowTrayIconRequestedHandlers(*this, nullptr);
+            _ShowNotificationIconRequestedHandlers(*this, nullptr);
         }
         catch (...)
         {
             LOG_CAUGHT_EXCEPTION();
         }
         TraceLoggingWrite(g_hRemotingProvider,
-                          "Peasant_RequestShowTrayIcon",
+                          "Peasant_RequestShowNotificationIcon",
                           TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                           TraceLoggingKeyword(TIL_KEYWORD_TRACE));
     }
 
-    void Peasant::RequestHideTrayIcon()
+    void Peasant::RequestHideNotificationIcon()
     {
         try
         {
-            _HideTrayIconRequestedHandlers(*this, nullptr);
+            _HideNotificationIconRequestedHandlers(*this, nullptr);
         }
         catch (...)
         {
             LOG_CAUGHT_EXCEPTION();
         }
         TraceLoggingWrite(g_hRemotingProvider,
-                          "Peasant_RequestHideTrayIcon",
+                          "Peasant_RequestHideNotificationIcon",
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                          TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+    }
+
+    void Peasant::RequestQuitAll()
+    {
+        try
+        {
+            _QuitAllRequestedHandlers(*this, nullptr);
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+        }
+        TraceLoggingWrite(g_hRemotingProvider,
+                          "Peasant_RequestQuit",
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
+                          TraceLoggingKeyword(TIL_KEYWORD_TRACE));
+    }
+
+    void Peasant::Quit()
+    {
+        try
+        {
+            _QuitRequestedHandlers(*this, nullptr);
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+        }
+        TraceLoggingWrite(g_hRemotingProvider,
+                          "Peasant_Quit",
                           TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                           TraceLoggingKeyword(TIL_KEYWORD_TRACE));
     }

src/cascadia/Remoting/Peasant.h

@@ -28,13 +28,16 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         void RequestIdentifyWindows();
         void DisplayWindowId();
         void RequestRename(const winrt::Microsoft::Terminal::Remoting::RenameRequestArgs& args);
-        void RequestShowTrayIcon();
-        void RequestHideTrayIcon();
+        void RequestShowNotificationIcon();
+        void RequestHideNotificationIcon();
+        void RequestQuitAll();
+        void Quit();
 
         winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs GetLastActivatedArgs();
 
         winrt::Microsoft::Terminal::Remoting::CommandlineArgs InitialArgs();
         WINRT_PROPERTY(winrt::hstring, WindowName);
+        WINRT_PROPERTY(winrt::hstring, ActiveTabTitle);
 
         TYPED_EVENT(WindowActivated, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs);
         TYPED_EVENT(ExecuteCommandlineRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::CommandlineArgs);
@@ -42,8 +45,10 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         TYPED_EVENT(DisplayWindowIdRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
         TYPED_EVENT(RenameRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::RenameRequestArgs);
         TYPED_EVENT(SummonRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::SummonWindowBehavior);
-        TYPED_EVENT(ShowTrayIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
-        TYPED_EVENT(HideTrayIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(ShowNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(HideNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(QuitAllRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(QuitRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
 
     private:
         Peasant(const uint64_t testPID);

src/cascadia/Remoting/Peasant.idl

@@ -61,11 +61,14 @@ namespace Microsoft.Terminal.Remoting
         void DisplayWindowId(); // Tells us to display its own ID (which causes a DisplayWindowIdRequested to be raised)
 
         String WindowName { get; };
+        String ActiveTabTitle { get; };
         void RequestIdentifyWindows(); // Tells us to raise a IdentifyWindowsRequested
         void RequestRename(RenameRequestArgs args); // Tells us to raise a RenameRequested
         void Summon(SummonWindowBehavior behavior);
-        void RequestShowTrayIcon();
-        void RequestHideTrayIcon();
+        void RequestShowNotificationIcon();
+        void RequestHideNotificationIcon();
+        void RequestQuitAll();
+        void Quit();
 
         event Windows.Foundation.TypedEventHandler<Object, WindowActivatedArgs> WindowActivated;
         event Windows.Foundation.TypedEventHandler<Object, CommandlineArgs> ExecuteCommandlineRequested;
@@ -73,8 +76,10 @@ namespace Microsoft.Terminal.Remoting
         event Windows.Foundation.TypedEventHandler<Object, Object> DisplayWindowIdRequested;
         event Windows.Foundation.TypedEventHandler<Object, RenameRequestArgs> RenameRequested;
         event Windows.Foundation.TypedEventHandler<Object, SummonWindowBehavior> SummonRequested;
-        event Windows.Foundation.TypedEventHandler<Object, Object> ShowTrayIconRequested;
-        event Windows.Foundation.TypedEventHandler<Object, Object> HideTrayIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> ShowNotificationIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> HideNotificationIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> QuitAllRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> QuitRequested;
     };
 
     [default_interface] runtimeclass Peasant : IPeasant

src/cascadia/Remoting/WindowManager.cpp

@@ -54,6 +54,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         // monarch!
         CoRevokeClassObject(_registrationHostClass);
         _registrationHostClass = 0;
+        SignalClose();
         _monarchWaitInterrupt.SetEvent();
 
         // A thread is joinable once it's been started. Basically this just
@@ -64,6 +65,18 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         }
     }
 
+    void WindowManager::SignalClose()
+    {
+        if (_monarch)
+        {
+            try
+            {
+                _monarch.SignalClose(_peasant.GetID());
+            }
+            CATCH_LOG()
+        }
+    }
+
     void WindowManager::ProposeCommandline(const Remoting::CommandlineArgs& args)
     {
         // If we're the king, we _definitely_ want to process the arguments, we were
@@ -250,12 +263,15 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         // Here, we're the king!
         //
         // This is where you should do any additional setup that might need to be
-        // done when we become the king. THis will be called both for the first
+        // done when we become the king. This will be called both for the first
         // window, and when the current monarch dies.
 
+        _monarch.WindowCreated({ get_weak(), &WindowManager::_WindowCreatedHandlers });
+        _monarch.WindowClosed({ get_weak(), &WindowManager::_WindowClosedHandlers });
         _monarch.FindTargetWindowRequested({ this, &WindowManager::_raiseFindTargetWindowRequested });
-        _monarch.ShowTrayIconRequested([this](auto&&, auto&&) { _ShowTrayIconRequestedHandlers(*this, nullptr); });
-        _monarch.HideTrayIconRequested([this](auto&&, auto&&) { _HideTrayIconRequestedHandlers(*this, nullptr); });
+        _monarch.ShowNotificationIconRequested([this](auto&&, auto&&) { _ShowNotificationIconRequestedHandlers(*this, nullptr); });
+        _monarch.HideNotificationIconRequested([this](auto&&, auto&&) { _HideNotificationIconRequestedHandlers(*this, nullptr); });
+        _monarch.QuitAllRequested([this](auto&&, auto&&) { _QuitAllRequestedHandlers(*this, nullptr); });
 
         _BecameMonarchHandlers(*this, nullptr);
     }
@@ -513,55 +529,77 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
 
     void WindowManager::SummonAllWindows()
     {
-        if constexpr (Feature_TrayIcon::IsEnabled())
+        if constexpr (Feature_NotificationIcon::IsEnabled())
         {
             _monarch.SummonAllWindows();
         }
     }
 
-    Windows::Foundation::Collections::IMapView<uint64_t, winrt::hstring> WindowManager::GetPeasantNames()
+    Windows::Foundation::Collections::IVectorView<winrt::Microsoft::Terminal::Remoting::PeasantInfo> WindowManager::GetPeasantInfos()
     {
         // We should only get called when we're the monarch since the monarch
         // is the only one that knows about all peasants.
-        return _monarch.GetPeasantNames();
+        return _monarch.GetPeasantInfos();
+    }
+
+    uint64_t WindowManager::GetNumberOfPeasants()
+    {
+        if (_monarch)
+        {
+            try
+            {
+                return _monarch.GetNumberOfPeasants();
+            }
+            CATCH_LOG()
+        }
+        return 0;
     }
 
     // Method Description:
-    // - Ask the monarch to show a tray icon.
+    // - Ask the monarch to show a notification icon.
     // Arguments:
     // - <none>
     // Return Value:
     // - <none>
-    winrt::fire_and_forget WindowManager::RequestShowTrayIcon()
+    winrt::fire_and_forget WindowManager::RequestShowNotificationIcon()
     {
         co_await winrt::resume_background();
-        _peasant.RequestShowTrayIcon();
+        _peasant.RequestShowNotificationIcon();
     }
 
     // Method Description:
-    // - Ask the monarch to hide its tray icon.
+    // - Ask the monarch to hide its notification icon.
     // Arguments:
     // - <none>
     // Return Value:
     // - <none>
-    winrt::fire_and_forget WindowManager::RequestHideTrayIcon()
+    winrt::fire_and_forget WindowManager::RequestHideNotificationIcon()
     {
         auto strongThis{ get_strong() };
         co_await winrt::resume_background();
-        _peasant.RequestHideTrayIcon();
+        _peasant.RequestHideNotificationIcon();
+    }
+
+    // Method Description:
+    // - Ask the monarch to quit all windows.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    winrt::fire_and_forget WindowManager::RequestQuitAll()
+    {
+        auto strongThis{ get_strong() };
+        co_await winrt::resume_background();
+        _peasant.RequestQuitAll();
     }
 
     bool WindowManager::DoesQuakeWindowExist()
     {
-        const auto names = GetPeasantNames();
-        for (const auto [id, name] : names)
-        {
-            if (name == QuakeWindowName)
-            {
-                return true;
-            }
-        }
-        return false;
+        return _monarch.DoesQuakeWindowExist();
     }
 
+    void WindowManager::UpdateActiveTabTitle(winrt::hstring title)
+    {
+        winrt::get_self<implementation::Peasant>(_peasant)->ActiveTabTitle(title);
+    }
 }

src/cascadia/Remoting/WindowManager.h

@@ -39,18 +39,25 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         winrt::Microsoft::Terminal::Remoting::Peasant CurrentWindow();
         bool IsMonarch();
         void SummonWindow(const Remoting::SummonWindowSelectionArgs& args);
+        void SignalClose();
 
         void SummonAllWindows();
-        Windows::Foundation::Collections::IMapView<uint64_t, winrt::hstring> GetPeasantNames();
+        uint64_t GetNumberOfPeasants();
+        Windows::Foundation::Collections::IVectorView<winrt::Microsoft::Terminal::Remoting::PeasantInfo> GetPeasantInfos();
 
-        winrt::fire_and_forget RequestShowTrayIcon();
-        winrt::fire_and_forget RequestHideTrayIcon();
+        winrt::fire_and_forget RequestShowNotificationIcon();
+        winrt::fire_and_forget RequestHideNotificationIcon();
+        winrt::fire_and_forget RequestQuitAll();
         bool DoesQuakeWindowExist();
+        void UpdateActiveTabTitle(winrt::hstring title);
 
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);
         TYPED_EVENT(BecameMonarch, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
-        TYPED_EVENT(ShowTrayIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
-        TYPED_EVENT(HideTrayIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(WindowCreated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(WindowClosed, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(ShowNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(HideNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(QuitAllRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
 
     private:
         bool _shouldCreateWindow{ false };

src/cascadia/Remoting/WindowManager.idl

@@ -8,18 +8,25 @@ namespace Microsoft.Terminal.Remoting
     {
         WindowManager();
         void ProposeCommandline(CommandlineArgs args);
+        void SignalClose();
         Boolean ShouldCreateWindow { get; };
         IPeasant CurrentWindow();
         Boolean IsMonarch { get; };
         void SummonWindow(SummonWindowSelectionArgs args);
         void SummonAllWindows();
-        void RequestShowTrayIcon();
-        void RequestHideTrayIcon();
+        void RequestShowNotificationIcon();
+        void RequestHideNotificationIcon();
+        UInt64 GetNumberOfPeasants();
+        void RequestQuitAll();
+        void UpdateActiveTabTitle(String title);
         Boolean DoesQuakeWindowExist();
-        Windows.Foundation.Collections.IMapView<UInt64, String> GetPeasantNames();
+        Windows.Foundation.Collections.IVectorView<PeasantInfo> GetPeasantInfos();
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;
         event Windows.Foundation.TypedEventHandler<Object, Object> BecameMonarch;
-        event Windows.Foundation.TypedEventHandler<Object, Object> ShowTrayIconRequested;
-        event Windows.Foundation.TypedEventHandler<Object, Object> HideTrayIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> WindowCreated;
+        event Windows.Foundation.TypedEventHandler<Object, Object> WindowClosed;
+        event Windows.Foundation.TypedEventHandler<Object, Object> ShowNotificationIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> HideNotificationIconRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> QuitAllRequested;
     };
 }

src/cascadia/Remoting/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.210825.3" targetFramework="native" />
 </packages>

src/cascadia/ShellExtension/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.210825.3" targetFramework="native" />
 </packages>

src/cascadia/TerminalApp/App.xaml

@@ -20,8 +20,7 @@
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
                 <!--  Include the MUX Controls resources  -->
-                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls"
-                                       ControlsResourcesVersion="Version1" />
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
                 <ResourceDictionary>
 
                     <!--
@@ -46,7 +45,7 @@
                                      Color="{ThemeResource SystemErrorTextColor}" />
 
                     <!--  Suppress top padding  -->
-                    <Thickness x:Key="TabViewHeaderPadding">8,0,8,0</Thickness>
+                    <Thickness x:Key="TabViewHeaderPadding">9,0,8,0</Thickness>
 
                     <!--  Remove when implementing WinUI 2.6  -->
                     <Thickness x:Key="FlyoutContentPadding">12</Thickness>

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -78,7 +78,14 @@ namespace winrt::TerminalApp::implementation
     void TerminalPage::_HandleCloseWindow(const IInspectable& /*sender*/,
                                           const ActionEventArgs& args)
     {
-        CloseWindow();
+        CloseWindow(false);
+        args.Handled(true);
+    }
+
+    void TerminalPage::_HandleQuit(const IInspectable& /*sender*/,
+                                   const ActionEventArgs& args)
+    {
+        RequestQuit();
         args.Handled(true);
     }
 
@@ -166,7 +173,7 @@ namespace winrt::TerminalApp::implementation
         }
         else if (const auto& realArgs = args.ActionArgs().try_as<SplitPaneArgs>())
         {
-            _SplitPane(realArgs.SplitStyle(),
+            _SplitPane(realArgs.SplitDirection(),
                        realArgs.SplitMode(),
                        // This is safe, we're already filtering so the value is (0, 1)
                        ::base::saturated_cast<float>(realArgs.SplitSize()),
@@ -874,4 +881,44 @@ namespace winrt::TerminalApp::implementation
             }
         }
     }
+
+    void TerminalPage::_HandleOpenSystemMenu(const IInspectable& /*sender*/,
+                                             const ActionEventArgs& args)
+    {
+        _OpenSystemMenuHandlers(*this, nullptr);
+        args.Handled(true);
+    }
+
+    void TerminalPage::_HandleClearBuffer(const IInspectable& /*sender*/,
+                                          const ActionEventArgs& args)
+    {
+        if (args)
+        {
+            if (const auto& realArgs = args.ActionArgs().try_as<ClearBufferArgs>())
+            {
+                if (const auto termControl{ _GetActiveControl() })
+                {
+                    termControl.ClearBuffer(realArgs.Clear());
+                    args.Handled(true);
+                }
+            }
+        }
+    }
+
+    void TerminalPage::_HandleMultipleActions(const IInspectable& /*sender*/,
+                                              const ActionEventArgs& args)
+    {
+        if (args)
+        {
+            if (const auto& realArgs = args.ActionArgs().try_as<MultipleActionsArgs>())
+            {
+                for (const auto& action : realArgs.Actions())
+                {
+                    _actionDispatch->DoAction(action);
+                }
+
+                args.Handled(true);
+            }
+        }
+    }
 }

src/cascadia/TerminalApp/AppCommandlineArgs.cpp

@@ -274,18 +274,18 @@ void AppCommandlineArgs::_buildSplitPaneParser()
             // _getNewTerminalArgs MUST be called before parsing any other options,
             // as it might clear those options while finding the commandline
             auto terminalArgs{ _getNewTerminalArgs(subcommand) };
-            auto style{ SplitState::Automatic };
+            auto style{ SplitDirection::Automatic };
             // Make sure to use the `Option`s here to check if they were set -
             // _getNewTerminalArgs might reset them while parsing a commandline
             if ((*subcommand._horizontalOption || *subcommand._verticalOption))
             {
                 if (_splitHorizontal)
                 {
-                    style = SplitState::Horizontal;
+                    style = SplitDirection::Down;
                 }
                 else if (_splitVertical)
                 {
-                    style = SplitState::Vertical;
+                    style = SplitDirection::Right;
                 }
             }
             const auto splitMode{ subcommand._duplicateOption && _splitDuplicate ? SplitType::Duplicate : SplitType::Manual };
@@ -399,8 +399,10 @@ static const std::map<std::string, FocusDirection> focusDirectionMap = {
     { "right", FocusDirection::Right },
     { "up", FocusDirection::Up },
     { "down", FocusDirection::Down },
+    { "previous", FocusDirection::Previous },
     { "nextInOrder", FocusDirection::NextInOrder },
     { "previousInOrder", FocusDirection::PreviousInOrder },
+    { "first", FocusDirection::First },
 };
 
 // Method Description:
@@ -603,13 +605,6 @@ NewTerminalArgs AppCommandlineArgs::_getNewTerminalArgs(AppCommandlineArgs::NewT
         args.Profile(winrt::to_hstring(_profileName));
     }
 
-    if (!*subcommand.profileNameOption && !_commandline.empty())
-    {
-        // If there's no profile, but there IS a command line, set the tab title to the first part of the command
-        // This will ensure that the tab we spawn has a name (since it didn't get one from its profile!)
-        args.TabTitle(winrt::to_hstring(til::at(_commandline, 0)));
-    }
-
     if (*subcommand.startingDirectoryOption)
     {
         args.StartingDirectory(winrt::to_hstring(_startingDirectory));

src/cascadia/TerminalApp/AppLogic.cpp

@@ -10,6 +10,7 @@
 
 #include <LibraryResources.h>
 #include <WtExeUtils.h>
+#include <wil/token_helpers.h >
 
 using namespace winrt::Windows::ApplicationModel;
 using namespace winrt::Windows::ApplicationModel::DataTransfer;
@@ -131,17 +132,28 @@ static Documents::Run _BuildErrorRun(const winrt::hstring& text, const ResourceD
 // Method Description:
 // - Returns whether the user is either a member of the Administrators group or
 //   is currently elevated.
+// - This will return **FALSE** if the user has UAC disabled entirely, because
+//   there's no separation of power between the user and an admin in that case.
 // Return Value:
 // - true if the user is an administrator
 static bool _isUserAdmin() noexcept
 try
 {
-    SID_IDENTIFIER_AUTHORITY ntAuthority{ SECURITY_NT_AUTHORITY };
-    wil::unique_sid adminGroupSid{};
-    THROW_IF_WIN32_BOOL_FALSE(AllocateAndInitializeSid(&ntAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &adminGroupSid));
-    BOOL b;
-    THROW_IF_WIN32_BOOL_FALSE(CheckTokenMembership(NULL, adminGroupSid.get(), &b));
-    return !!b;
+    wil::unique_handle processToken{ GetCurrentProcessToken() };
+    const auto elevationType = wil::get_token_information<TOKEN_ELEVATION_TYPE>(processToken.get());
+    const auto elevationState = wil::get_token_information<TOKEN_ELEVATION>(processToken.get());
+    if (elevationType == TokenElevationTypeDefault && elevationState.TokenIsElevated)
+    {
+        // In this case, the user has UAC entirely disabled. This is sort of
+        // weird, we treat this like the user isn't an admin at all. There's no
+        // separation of powers, so the things we normally want to gate on
+        // "having special powers" doesn't apply.
+        //
+        // See GH#7754, GH#11096
+        return false;
+    }
+
+    return wil::test_token_membership(nullptr, SECURITY_NT_AUTHORITY, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS);
 }
 catch (...)
 {
@@ -329,6 +341,14 @@ namespace winrt::TerminalApp::implementation
             TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));
     }
 
+    void AppLogic::Quit()
+    {
+        if (_root)
+        {
+            _root->CloseWindow(true);
+        }
+    }
+
     // Method Description:
     // - Show a ContentDialog with buttons to take further action. Uses the
     //   FrameworkElements provided as the title and content of this dialog, and
@@ -596,12 +616,30 @@ namespace winrt::TerminalApp::implementation
             LoadSettings();
         }
 
-        // Use the default profile to determine how big of a window we need.
-        const auto settings{ TerminalSettings::CreateWithNewTerminalArgs(_settings, nullptr, nullptr) };
-
-        auto proposedSize = TermControl::GetProposedDimensions(settings.DefaultSettings(), dpi);
+        winrt::Windows::Foundation::Size proposedSize{};
 
         const float scale = static_cast<float>(dpi) / static_cast<float>(USER_DEFAULT_SCREEN_DPI);
+        if (_root->ShouldUsePersistedLayout(_settings))
+        {
+            const auto layouts = ApplicationState::SharedInstance().PersistedWindowLayouts();
+
+            if (layouts && layouts.Size() > 0 && layouts.GetAt(0).InitialSize())
+            {
+                proposedSize = layouts.GetAt(0).InitialSize().Value();
+                // The size is saved as a non-scaled real pixel size,
+                // so we need to scale it appropriately.
+                proposedSize.Height = proposedSize.Height * scale;
+                proposedSize.Width = proposedSize.Width * scale;
+            }
+        }
+
+        if (proposedSize.Width == 0 && proposedSize.Height == 0)
+        {
+            // Use the default profile to determine how big of a window we need.
+            const auto settings{ TerminalSettings::CreateWithNewTerminalArgs(_settings, nullptr, nullptr) };
+
+            proposedSize = TermControl::GetProposedDimensions(settings.DefaultSettings(), dpi);
+        }
 
         // GH#2061 - If the global setting "Always show tab bar" is
         // set or if "Show tabs in title bar" is set, then we'll need to add
@@ -683,7 +721,18 @@ namespace winrt::TerminalApp::implementation
             LoadSettings();
         }
 
-        const auto initialPosition{ _settings.GlobalSettings().InitialPosition() };
+        auto initialPosition{ _settings.GlobalSettings().InitialPosition() };
+
+        if (_root->ShouldUsePersistedLayout(_settings))
+        {
+            const auto layouts = ApplicationState::SharedInstance().PersistedWindowLayouts();
+
+            if (layouts && layouts.Size() > 0 && layouts.GetAt(0).InitialPosition())
+            {
+                initialPosition = layouts.GetAt(0).InitialPosition().Value();
+            }
+        }
+
         return {
             initialPosition.X ? initialPosition.X.Value() : defaultInitialX,
             initialPosition.Y ? initialPosition.Y.Value() : defaultInitialY
@@ -1125,7 +1174,7 @@ namespace winrt::TerminalApp::implementation
     {
         if (_root)
         {
-            _root->CloseWindow();
+            _root->CloseWindow(false);
         }
     }
 
@@ -1429,6 +1478,14 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    void AppLogic::SetNumberOfOpenWindows(const uint64_t num)
+    {
+        if (_root)
+        {
+            _root->SetNumberOfOpenWindows(num);
+        }
+    }
+
     void AppLogic::RenameFailed()
     {
         if (_root)
@@ -1442,9 +1499,9 @@ namespace winrt::TerminalApp::implementation
         return _root->IsQuakeWindow();
     }
 
-    bool AppLogic::GetMinimizeToTray()
+    bool AppLogic::GetMinimizeToNotificationArea()
     {
-        if constexpr (Feature_TrayIcon::IsEnabled())
+        if constexpr (Feature_NotificationIcon::IsEnabled())
         {
             if (!_loadedInitialSettings)
             {
@@ -1452,7 +1509,7 @@ namespace winrt::TerminalApp::implementation
                 LoadSettings();
             }
 
-            return _settings.GlobalSettings().MinimizeToTray();
+            return _settings.GlobalSettings().MinimizeToNotificationArea();
         }
         else
         {
@@ -1460,9 +1517,9 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
-    bool AppLogic::GetAlwaysShowTrayIcon()
+    bool AppLogic::GetAlwaysShowNotificationIcon()
     {
-        if constexpr (Feature_TrayIcon::IsEnabled())
+        if constexpr (Feature_NotificationIcon::IsEnabled())
         {
             if (!_loadedInitialSettings)
             {
@@ -1470,11 +1527,16 @@ namespace winrt::TerminalApp::implementation
                 LoadSettings();
             }
 
-            return _settings.GlobalSettings().AlwaysShowTrayIcon();
+            return _settings.GlobalSettings().AlwaysShowNotificationIcon();
         }
         else
         {
             return false;
         }
     }
+
+    bool AppLogic::GetShowTitleInTitlebar()
+    {
+        return _settings.GlobalSettings().ShowTitleInTitlebar();
+    }
 }

src/cascadia/TerminalApp/AppLogic.h

@@ -53,6 +53,8 @@ namespace winrt::TerminalApp::implementation
         void LoadSettings();
         [[nodiscard]] Microsoft::Terminal::Settings::Model::CascadiaSettings GetSettings() const noexcept;
 
+        void Quit();
+
         int32_t SetStartupCommandline(array_view<const winrt::hstring> actions);
         int32_t ExecuteCommandline(array_view<const winrt::hstring> actions, const winrt::hstring& cwd);
         TerminalApp::FindTargetWindowResult FindTargetWindow(array_view<const winrt::hstring> actions);
@@ -69,6 +71,7 @@ namespace winrt::TerminalApp::implementation
         void WindowName(const winrt::hstring& name);
         uint64_t WindowId();
         void WindowId(const uint64_t& id);
+        void SetNumberOfOpenWindows(const uint64_t num);
         bool IsQuakeWindow() const noexcept;
 
         Windows::Foundation::Size GetLaunchDimensions(uint32_t dpi);
@@ -92,8 +95,9 @@ namespace winrt::TerminalApp::implementation
 
         winrt::TerminalApp::TaskbarState TaskbarState();
 
-        bool GetMinimizeToTray();
-        bool GetAlwaysShowTrayIcon();
+        bool GetMinimizeToNotificationArea();
+        bool GetAlwaysShowNotificationIcon();
+        bool GetShowTitleInTitlebar();
 
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> ShowDialog(winrt::Windows::UI::Xaml::Controls::ContentDialog dialog);
 
@@ -171,6 +175,8 @@ namespace winrt::TerminalApp::implementation
         FORWARDED_TYPED_EVENT(RenameWindowRequested, Windows::Foundation::IInspectable, winrt::TerminalApp::RenameWindowRequestedArgs, _root, RenameWindowRequested);
         FORWARDED_TYPED_EVENT(IsQuakeWindowChanged, Windows::Foundation::IInspectable, Windows::Foundation::IInspectable, _root, IsQuakeWindowChanged);
         FORWARDED_TYPED_EVENT(SummonWindowRequested, Windows::Foundation::IInspectable, Windows::Foundation::IInspectable, _root, SummonWindowRequested);
+        FORWARDED_TYPED_EVENT(OpenSystemMenu, Windows::Foundation::IInspectable, Windows::Foundation::IInspectable, _root, OpenSystemMenu);
+        FORWARDED_TYPED_EVENT(QuitRequested, Windows::Foundation::IInspectable, Windows::Foundation::IInspectable, _root, QuitRequested);
 
 #ifdef UNIT_TESTING
         friend class TerminalAppLocalTests::CommandlineTest;

src/cascadia/TerminalApp/AppLogic.idl

@@ -39,6 +39,8 @@ namespace TerminalApp
         String ParseCommandlineMessage { get; };
         Boolean ShouldExitEarly { get; };
 
+        void Quit();
+
         void LoadSettings();
         Windows.UI.Xaml.UIElement GetRoot();
 
@@ -53,6 +55,7 @@ namespace TerminalApp
         void IdentifyWindow();
         String WindowName;
         UInt64 WindowId;
+        void SetNumberOfOpenWindows(UInt64 num);
         void RenameFailed();
         Boolean IsQuakeWindow();
 
@@ -70,8 +73,9 @@ namespace TerminalApp
 
         TaskbarState TaskbarState{ get; };
 
-        Boolean GetMinimizeToTray();
-        Boolean GetAlwaysShowTrayIcon();
+        Boolean GetMinimizeToNotificationArea();
+        Boolean GetAlwaysShowNotificationIcon();
+        Boolean GetShowTitleInTitlebar();
 
         FindTargetWindowResult FindTargetWindow(String[] args);
 
@@ -95,5 +99,7 @@ namespace TerminalApp
         event Windows.Foundation.TypedEventHandler<Object, Object> SettingsChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> IsQuakeWindowChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> SummonWindowRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> OpenSystemMenu;
+        event Windows.Foundation.TypedEventHandler<Object, Object> QuitRequested;
     }
 }

src/cascadia/TerminalApp/CommandPalette.cpp

@@ -36,7 +36,6 @@ namespace winrt::TerminalApp::implementation
         _allCommands = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
         _tabActions = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
         _mruTabActions = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
-        _commandLineHistory = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
 
         _switchToMode(CommandPaletteMode::ActionMode);
 
@@ -245,6 +244,17 @@ namespace winrt::TerminalApp::implementation
                 _PreviewActionHandlers(*this, actionPaletteItem.Command());
             }
         }
+        else if (_currentMode == CommandPaletteMode::CommandlineMode)
+        {
+            if (filteredCommand)
+            {
+                SearchBoxPlaceholderText(filteredCommand.Item().Name());
+            }
+            else
+            {
+                SearchBoxPlaceholderText(RS_(L"CmdPalCommandlinePrompt"));
+            }
+        }
     }
 
     void CommandPalette::_previewKeyDownHandler(IInspectable const& /*sender*/,
@@ -365,6 +375,17 @@ namespace winrt::TerminalApp::implementation
             _searchBox().PasteFromClipboard();
             e.Handled(true);
         }
+        else if (key == VirtualKey::Right && _currentMode == CommandPaletteMode::CommandlineMode)
+        {
+            if (const auto command{ _filteredActionsView().SelectedItem().try_as<winrt::TerminalApp::FilteredCommand>() })
+            {
+                _searchBox().Text(command.Item().Name());
+                _searchBox().Select(_searchBox().Text().size(), 0);
+                _searchBox().Focus(FocusState::Programmatic);
+                _filteredActionsView().SelectedIndex(-1);
+                e.Handled(true);
+            }
+        }
     }
 
     // Method Description:
@@ -587,7 +608,7 @@ namespace winrt::TerminalApp::implementation
         case CommandPaletteMode::TabSwitchMode:
             return _tabSwitcherMode == TabSwitcherMode::MostRecentlyUsed ? _mruTabActions : _tabActions;
         case CommandPaletteMode::CommandlineMode:
-            return _commandLineHistory;
+            return _loadRecentCommands();
         default:
             return _allCommands;
         }
@@ -720,14 +741,10 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void CommandPalette::_dispatchCommandline(winrt::TerminalApp::FilteredCommand const& command)
     {
-        const auto filteredCommand = command ? command : _buildCommandLineCommand(_getTrimmedInput());
+        const auto filteredCommand = command ? command : _buildCommandLineCommand(winrt::hstring(_getTrimmedInput()));
         if (filteredCommand.has_value())
         {
-            if (_commandLineHistory.Size() == CommandLineHistoryLength)
-            {
-                _commandLineHistory.RemoveAtEnd();
-            }
-            _commandLineHistory.InsertAt(0, filteredCommand.value());
+            _updateRecentCommands(filteredCommand.value().Item().Name());
 
             TraceLoggingWrite(
                 g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
@@ -744,15 +761,14 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
-    std::optional<winrt::TerminalApp::FilteredCommand> CommandPalette::_buildCommandLineCommand(std::wstring const& commandLine)
+    std::optional<TerminalApp::FilteredCommand> CommandPalette::_buildCommandLineCommand(const hstring& commandLine)
     {
         if (commandLine.empty())
         {
             return std::nullopt;
         }
 
-        winrt::hstring cl{ commandLine };
-        auto commandLinePaletteItem{ winrt::make<winrt::TerminalApp::implementation::CommandLinePaletteItem>(cl) };
+        auto commandLinePaletteItem{ winrt::make<CommandLinePaletteItem>(commandLine) };
         return winrt::make<FilteredCommand>(commandLinePaletteItem);
     }
 
@@ -1217,4 +1233,81 @@ namespace winrt::TerminalApp::implementation
             itemContainer.DataContext(args.Item());
         }
     }
+
+    // Method Description:
+    // - Reads the list of recent commands from the persistent application state
+    // Return Value:
+    // - The list of FilteredCommand representing the ones stored in the state
+    IVector<TerminalApp::FilteredCommand> CommandPalette::_loadRecentCommands()
+    {
+        const auto recentCommands = ApplicationState::SharedInstance().RecentCommands();
+        // If this is the first time we've opened the commandline mode and
+        // there aren't any recent commands, then just return an empty vector.
+        if (!recentCommands)
+        {
+            return single_threaded_vector<TerminalApp::FilteredCommand>();
+        }
+
+        std::vector<TerminalApp::FilteredCommand> parsedCommands;
+        parsedCommands.reserve(std::min(recentCommands.Size(), CommandLineHistoryLength));
+
+        for (const auto& c : recentCommands)
+        {
+            if (parsedCommands.size() >= CommandLineHistoryLength)
+            {
+                // Don't load more than CommandLineHistoryLength commands
+                break;
+            }
+
+            if (const auto parsedCommand = _buildCommandLineCommand(c))
+            {
+                parsedCommands.push_back(*parsedCommand);
+            }
+        }
+        return single_threaded_vector(std::move(parsedCommands));
+    }
+
+    // Method Description:
+    // - Update recent commands by putting the provided command as most recent.
+    // Upon race condition might override an update made by another window.
+    // Return Value:
+    // - <none>
+    void CommandPalette::_updateRecentCommands(const hstring& command)
+    {
+        const auto recentCommands = ApplicationState::SharedInstance().RecentCommands();
+        // If this is the first time we've opened the commandline mode and
+        // there aren't any recent commands, then just store the new command.
+        if (!recentCommands)
+        {
+            ApplicationState::SharedInstance().RecentCommands(single_threaded_vector(std::move(std::vector{ command })));
+            return;
+        }
+
+        const auto numNewRecentCommands = std::min(recentCommands.Size() + 1, CommandLineHistoryLength);
+
+        std::vector<hstring> newRecentCommands;
+        newRecentCommands.reserve(numNewRecentCommands);
+
+        std::unordered_set<hstring> uniqueCommands;
+        uniqueCommands.reserve(numNewRecentCommands);
+
+        newRecentCommands.push_back(command);
+        uniqueCommands.insert(command);
+
+        for (const auto& c : recentCommands)
+        {
+            if (newRecentCommands.size() >= CommandLineHistoryLength)
+            {
+                // Don't store more than CommandLineHistoryLength commands
+                break;
+            }
+
+            if (uniqueCommands.emplace(c).second)
+            {
+                newRecentCommands.push_back(c);
+            }
+        }
+
+        ApplicationState::SharedInstance().RecentCommands(single_threaded_vector(std::move(newRecentCommands)));
+    }
 }

src/cascadia/TerminalApp/CommandPalette.h

@@ -123,15 +123,16 @@ namespace winrt::TerminalApp::implementation
         void _dispatchCommand(winrt::TerminalApp::FilteredCommand const& command);
         void _dispatchCommandline(winrt::TerminalApp::FilteredCommand const& command);
         void _switchToTab(winrt::TerminalApp::FilteredCommand const& command);
-        std::optional<winrt::TerminalApp::FilteredCommand> _buildCommandLineCommand(std::wstring const& commandLine);
+        static std::optional<winrt::TerminalApp::FilteredCommand> _buildCommandLineCommand(const winrt::hstring& commandLine);
 
         void _dismissPalette();
 
         void _scrollToIndex(uint32_t index);
         uint32_t _getNumVisibleItems();
 
-        static constexpr int CommandLineHistoryLength = 10;
-        Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _commandLineHistory{ nullptr };
+        static constexpr uint32_t CommandLineHistoryLength = 20;
+        static Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _loadRecentCommands();
+        static void _updateRecentCommands(const winrt::hstring& command);
         ::TerminalApp::AppCommandlineArgs _appArgs;
 
         void _choosingItemContainer(Windows::UI::Xaml::Controls::ListViewBase const& sender, Windows::UI::Xaml::Controls::ChoosingItemContainerEventArgs const& args);

src/cascadia/TerminalApp/CommandPalette.xaml

@@ -407,7 +407,7 @@
               HorizontalAlignment="Stretch"
               VerticalAlignment="Top"
               Windows10version1903:Shadow="{StaticResource CommandPaletteShadow}"
-              CornerRadius="{ThemeResource ControlCornerRadius}"
+              CornerRadius="{ThemeResource OverlayCornerRadius}"
               PointerPressed="_backdropPointerPressed"
               Style="{ThemeResource CommandPaletteBackground}">
 

src/cascadia/TerminalApp/MinMaxCloseControl.xaml

@@ -9,7 +9,7 @@
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             HorizontalAlignment="Left"
             VerticalAlignment="Top"
-            d:DesignHeight="36"
+            d:DesignHeight="40"
             d:DesignWidth="400"
             Background="Transparent"
             Orientation="Horizontal"
@@ -124,8 +124,9 @@
                 tabs will be flush with the top of the window. See GH#2541 for
                 details.
             -->
-            <x:Double x:Key="CaptionButtonHeightWindowed">36.0</x:Double>
-            <x:Double x:Key="CaptionButtonHeightMaximized">32.0</x:Double>
+            <x:Double x:Key="CaptionButtonHeightWindowed">40.0</x:Double>
+            <!--  32 + 1 to compensate for GH#10746  -->
+            <x:Double x:Key="CaptionButtonHeightMaximized">33.0</x:Double>
 
             <Style x:Key="CaptionButton"
                    TargetType="Button">

src/cascadia/TerminalApp/Pane.cpp

@@ -58,8 +58,8 @@ Pane::Pane(const Profile& profile, const TermControl& control, const bool lastFo
     _root.Background(s_unfocusedBorderBrush);
 
     // Register an event with the control to have it inform us when it gains focus.
-    _gotFocusRevoker = control.GotFocus(winrt::auto_revoke, { this, &Pane::_ControlGotFocusHandler });
-    _lostFocusRevoker = control.LostFocus(winrt::auto_revoke, { this, &Pane::_ControlLostFocusHandler });
+    _gotFocusRevoker = _control.GotFocus(winrt::auto_revoke, { this, &Pane::_ControlGotFocusHandler });
+    _lostFocusRevoker = _control.LostFocus(winrt::auto_revoke, { this, &Pane::_ControlLostFocusHandler });
 
     // When our border is tapped, make sure to transfer focus to our control.
     // LOAD-BEARING: This will NOT work if the border's BorderBrush is set to
@@ -71,6 +71,155 @@ Pane::Pane(const Profile& profile, const TermControl& control, const bool lastFo
     });
 }
 
+// Method Description:
+// - Extract the terminal settings from the current (leaf) pane's control
+//   to be used to create an equivalent control
+// Arguments:
+// - <none>
+// Return Value:
+// - Arguments appropriate for a SplitPane or NewTab action
+NewTerminalArgs Pane::GetTerminalArgsForPane() const
+{
+    // Leaves are the only things that have controls
+    assert(_IsLeaf());
+
+    NewTerminalArgs args{};
+    auto controlSettings = _control.Settings().as<TerminalSettings>();
+
+    args.Profile(controlSettings.ProfileName());
+    args.StartingDirectory(controlSettings.StartingDirectory());
+    args.TabTitle(controlSettings.StartingTitle());
+    args.Commandline(controlSettings.Commandline());
+    args.SuppressApplicationTitle(controlSettings.SuppressApplicationTitle());
+    if (controlSettings.TabColor() || controlSettings.StartingTabColor())
+    {
+        til::color c;
+        // StartingTabColor is prioritized over other colors
+        if (const auto color = controlSettings.StartingTabColor())
+        {
+            c = til::color(color.Value());
+        }
+        else
+        {
+            c = til::color(controlSettings.TabColor().Value());
+        }
+
+        args.TabColor(winrt::Windows::Foundation::IReference<winrt::Windows::UI::Color>(c));
+    }
+
+    if (controlSettings.AppliedColorScheme())
+    {
+        auto name = controlSettings.AppliedColorScheme().Name();
+        args.ColorScheme(name);
+    }
+
+    return args;
+}
+
+// Method Description:
+// - Serializes the state of this tab as a series of commands that can be
+//   executed to recreate it.
+// - This will always result in the right-most child being the focus
+//   after the commands finish executing.
+// Arguments:
+// - currentId: the id to use for the current/first pane
+// - nextId: the id to use for a new pane if we split
+// Return Value:
+// - The state from building the startup actions, includes a vector of commands,
+//   the original root pane, the id of the focused pane, and the number of panes
+//   created.
+Pane::BuildStartupState Pane::BuildStartupActions(uint32_t currentId, uint32_t nextId)
+{
+    // if we are a leaf then all there is to do is defer to the parent.
+    if (_IsLeaf())
+    {
+        if (_lastActive)
+        {
+            return { {}, shared_from_this(), currentId, 0 };
+        }
+
+        return { {}, shared_from_this(), std::nullopt, 0 };
+    }
+
+    auto buildSplitPane = [&](auto newPane) {
+        ActionAndArgs actionAndArgs;
+        actionAndArgs.Action(ShortcutAction::SplitPane);
+        const auto terminalArgs{ newPane->GetTerminalArgsForPane() };
+        // When creating a pane the split size is the size of the new pane
+        // and not position.
+        const auto splitDirection = _splitState == SplitState::Horizontal ? SplitDirection::Down : SplitDirection::Right;
+        SplitPaneArgs args{ SplitType::Manual, splitDirection, 1. - _desiredSplitPosition, terminalArgs };
+        actionAndArgs.Args(args);
+
+        return actionAndArgs;
+    };
+
+    auto buildMoveFocus = [](auto direction) {
+        MoveFocusArgs args{ direction };
+
+        ActionAndArgs actionAndArgs{};
+        actionAndArgs.Action(ShortcutAction::MoveFocus);
+        actionAndArgs.Args(args);
+
+        return actionAndArgs;
+    };
+
+    // Handle simple case of a single split (a minor optimization for clarity)
+    // Here we just create the second child (by splitting) and return the first
+    // child for the parent to deal with.
+    if (_firstChild->_IsLeaf() && _secondChild->_IsLeaf())
+    {
+        auto actionAndArgs = buildSplitPane(_secondChild);
+        std::optional<uint32_t> focusedPaneId = std::nullopt;
+        if (_firstChild->_lastActive)
+        {
+            focusedPaneId = currentId;
+        }
+        else if (_secondChild->_lastActive)
+        {
+            focusedPaneId = nextId;
+        }
+
+        return { { actionAndArgs }, _firstChild, focusedPaneId, 1 };
+    }
+
+    // We now need to execute the commands for each side of the tree
+    // We've done one split, so the first-most child will have currentId, and the
+    // one after it will be incremented.
+    auto firstState = _firstChild->BuildStartupActions(currentId, nextId + 1);
+    // the next id for the second branch depends on how many splits were in the
+    // first child.
+    auto secondState = _secondChild->BuildStartupActions(nextId, nextId + firstState.panesCreated + 1);
+
+    std::vector<ActionAndArgs> actions{};
+    actions.reserve(firstState.args.size() + secondState.args.size() + 3);
+
+    // first we make our split
+    const auto newSplit = buildSplitPane(secondState.firstPane);
+    actions.emplace_back(std::move(newSplit));
+
+    if (firstState.args.size() > 0)
+    {
+        // Then move to the first child and execute any actions on the left branch
+        // then move back
+        actions.emplace_back(buildMoveFocus(FocusDirection::PreviousInOrder));
+        actions.insert(actions.end(), std::make_move_iterator(std::begin(firstState.args)), std::make_move_iterator(std::end(firstState.args)));
+        actions.emplace_back(buildMoveFocus(FocusDirection::NextInOrder));
+    }
+
+    // And if there are any commands to run on the right branch do so
+    if (secondState.args.size() > 0)
+    {
+        actions.insert(actions.end(), std::make_move_iterator(secondState.args.begin()), std::make_move_iterator(secondState.args.end()));
+    }
+
+    // if the tree is well-formed then f1.has_value and f2.has_value are
+    // mutually exclusive.
+    const auto focusedPaneId = firstState.focusedPaneId.has_value() ? firstState.focusedPaneId : secondState.focusedPaneId;
+
+    return { actions, firstState.firstPane, focusedPaneId, firstState.panesCreated + secondState.panesCreated + 1 };
+}
+
 // Method Description:
 // - Update the size of this pane. Resizes each of our columns so they have the
 //   same relative sizes, given the newSize.
@@ -223,10 +372,11 @@ bool Pane::ResizePane(const ResizeDirection& direction)
 // Arguments:
 // - sourcePane: the pane to navigate from
 // - direction: which direction to go in
+// - mruPanes: the list of most recently used panes, in order
 // Return Value:
 // - The result of navigating from source according to direction, which may be
 //   nullptr (i.e. no pane was found in that direction).
-std::shared_ptr<Pane> Pane::NavigateDirection(const std::shared_ptr<Pane> sourcePane, const FocusDirection& direction)
+std::shared_ptr<Pane> Pane::NavigateDirection(const std::shared_ptr<Pane> sourcePane, const FocusDirection& direction, const std::vector<uint32_t>& mruPanes)
 {
     // Can't navigate anywhere if we are a leaf
     if (_IsLeaf())
@@ -234,12 +384,23 @@ std::shared_ptr<Pane> Pane::NavigateDirection(const std::shared_ptr<Pane> source
         return nullptr;
     }
 
-    // If the MRU previous pane is requested we can't move; the tab handles MRU
-    if (direction == FocusDirection::None || direction == FocusDirection::Previous)
+    if (direction == FocusDirection::None)
     {
         return nullptr;
     }
 
+    // Previous movement relies on the last used panes
+    if (direction == FocusDirection::Previous)
+    {
+        // If there is actually a previous pane.
+        if (mruPanes.size() > 1)
+        {
+            // This could return nullptr if the id is not actually in the tree.
+            return FindPane(mruPanes.at(1));
+        }
+        return nullptr;
+    }
+
     // Check if we in-order traversal is requested
     if (direction == FocusDirection::NextInOrder)
     {
@@ -251,22 +412,46 @@ std::shared_ptr<Pane> Pane::NavigateDirection(const std::shared_ptr<Pane> source
         return PreviousPane(sourcePane);
     }
 
+    if (direction == FocusDirection::First)
+    {
+        std::shared_ptr<Pane> firstPane = nullptr;
+        WalkTree([&](auto p) {
+            if (p->_IsLeaf())
+            {
+                firstPane = p;
+                return true;
+            }
+
+            return false;
+        });
+
+        // Don't need to do any movement if we are the source and target pane.
+        if (firstPane == sourcePane)
+        {
+            return nullptr;
+        }
+        return firstPane;
+    }
+
     // We are left with directional traversal now
     // If the focus direction does not match the split direction, the source pane
     // and its neighbor must necessarily be contained within the same child.
     if (!DirectionMatchesSplit(direction, _splitState))
     {
-        if (auto p = _firstChild->NavigateDirection(sourcePane, direction))
+        if (const auto p = _firstChild->NavigateDirection(sourcePane, direction, mruPanes))
         {
             return p;
         }
-        return _secondChild->NavigateDirection(sourcePane, direction);
+        return _secondChild->NavigateDirection(sourcePane, direction, mruPanes);
     }
 
     // Since the direction is the same as our split, it is possible that we must
     // move focus from from one child to another child.
     // We now must keep track of state while we recurse.
-    const auto paneNeighborPair = _FindPaneAndNeighbor(sourcePane, direction, { 0, 0 });
+    // If we have it, get the size of this pane.
+    const auto scaleX = _root.ActualWidth() > 0 ? gsl::narrow_cast<float>(_root.ActualWidth()) : 1.f;
+    const auto scaleY = _root.ActualHeight() > 0 ? gsl::narrow_cast<float>(_root.ActualHeight()) : 1.f;
+    const auto paneNeighborPair = _FindPaneAndNeighbor(sourcePane, direction, { 0, 0, scaleX, scaleY });
 
     if (paneNeighborPair.source && paneNeighborPair.neighbor)
     {
@@ -517,17 +702,15 @@ bool Pane::SwapPanes(std::shared_ptr<Pane> first, std::shared_ptr<Pane> second)
 }
 
 // Method Description:
-// - Given two panes, test whether the `direction` side of first is adjacent to second.
+// - Given two panes' offsets, test whether the `direction` side of first is adjacent to second.
 // Arguments:
-// - first: The reference pane.
-// - second: the pane to test adjacency with.
+// - firstOffset: The offset for the reference pane
+// - secondOffset: the offset to test adjacency with.
 // - direction: The direction to search in from the reference pane.
 // Return Value:
 // - true if the two panes are adjacent.
-bool Pane::_IsAdjacent(const std::shared_ptr<Pane> first,
-                       const Pane::PanePoint firstOffset,
-                       const std::shared_ptr<Pane> second,
-                       const Pane::PanePoint secondOffset,
+bool Pane::_IsAdjacent(const PanePoint firstOffset,
+                       const PanePoint secondOffset,
                        const FocusDirection& direction) const
 {
     // Since float equality is tricky (arithmetic is non-associative, commutative),
@@ -536,14 +719,22 @@ bool Pane::_IsAdjacent(const std::shared_ptr<Pane> first,
         return abs(left - right) < 1e-4F;
     };
 
+    auto getXMax = [](PanePoint offset) {
+        return offset.x + offset.scaleX;
+    };
+
+    auto getYMax = [](PanePoint offset) {
+        return offset.y + offset.scaleY;
+    };
+
     // When checking containment in a range, the range is half-closed, i.e. [x, x+w).
     // If the direction is left test that the left side of the first element is
     // next to the right side of the second element, and that the top left
     // corner of the first element is within the second element's height
     if (direction == FocusDirection::Left)
     {
-        auto sharesBorders = floatEqual(firstOffset.x, secondOffset.x + gsl::narrow_cast<float>(second->GetRootElement().ActualWidth()));
-        auto withinHeight = (firstOffset.y >= secondOffset.y) && (firstOffset.y < secondOffset.y + gsl::narrow_cast<float>(second->GetRootElement().ActualHeight()));
+        const auto sharesBorders = floatEqual(firstOffset.x, getXMax(secondOffset));
+        const auto withinHeight = (firstOffset.y >= secondOffset.y) && (firstOffset.y < getYMax(secondOffset));
 
         return sharesBorders && withinHeight;
     }
@@ -552,8 +743,8 @@ bool Pane::_IsAdjacent(const std::shared_ptr<Pane> first,
     // corner of the first element is within the second element's height
     else if (direction == FocusDirection::Right)
     {
-        auto sharesBorders = floatEqual(firstOffset.x + gsl::narrow_cast<float>(first->GetRootElement().ActualWidth()), secondOffset.x);
-        auto withinHeight = (firstOffset.y >= secondOffset.y) && (firstOffset.y < secondOffset.y + gsl::narrow_cast<float>(second->GetRootElement().ActualHeight()));
+        const auto sharesBorders = floatEqual(getXMax(firstOffset), secondOffset.x);
+        const auto withinHeight = (firstOffset.y >= secondOffset.y) && (firstOffset.y < getYMax(secondOffset));
 
         return sharesBorders && withinHeight;
     }
@@ -562,8 +753,8 @@ bool Pane::_IsAdjacent(const std::shared_ptr<Pane> first,
     // corner of the first element is within the second element's width
     else if (direction == FocusDirection::Up)
     {
-        auto sharesBorders = floatEqual(firstOffset.y, secondOffset.y + gsl::narrow_cast<float>(second->GetRootElement().ActualHeight()));
-        auto withinWidth = (firstOffset.x >= secondOffset.x) && (firstOffset.x < secondOffset.x + gsl::narrow_cast<float>(second->GetRootElement().ActualWidth()));
+        const auto sharesBorders = floatEqual(firstOffset.y, getYMax(secondOffset));
+        const auto withinWidth = (firstOffset.x >= secondOffset.x) && (firstOffset.x < getXMax(secondOffset));
 
         return sharesBorders && withinWidth;
     }
@@ -572,14 +763,52 @@ bool Pane::_IsAdjacent(const std::shared_ptr<Pane> first,
     // corner of the first element is within the second element's width
     else if (direction == FocusDirection::Down)
     {
-        auto sharesBorders = floatEqual(firstOffset.y + gsl::narrow_cast<float>(first->GetRootElement().ActualHeight()), secondOffset.y);
-        auto withinWidth = (firstOffset.x >= secondOffset.x) && (firstOffset.x < secondOffset.x + gsl::narrow_cast<float>(second->GetRootElement().ActualWidth()));
+        const auto sharesBorders = floatEqual(getYMax(firstOffset), secondOffset.y);
+        const auto withinWidth = (firstOffset.x >= secondOffset.x) && (firstOffset.x < getXMax(secondOffset));
 
         return sharesBorders && withinWidth;
     }
     return false;
 }
 
+// Method Description:
+// - Gets the offsets for the two children of this parent pane
+// - If real dimensions are not available, simulated ones based on the split size
+//   will be used instead.
+// Arguments:
+// - parentOffset the location and scale information of this pane.
+// Return Value:
+// - the two location/scale points for the children panes.
+std::pair<Pane::PanePoint, Pane::PanePoint> Pane::_GetOffsetsForPane(const PanePoint parentOffset) const
+{
+    assert(!_IsLeaf());
+    auto firstOffset = parentOffset;
+    auto secondOffset = parentOffset;
+
+    // Make up fake dimensions using an exponential layout. This is useful
+    // since we might need to navigate when there are panes not attached  to
+    // the ui tree, such as initialization, command running, and zoom.
+    // Basically create the tree layout on the fly by partitioning [0,1].
+    // This could run into issues if the tree depth is >127 (or other
+    // degenerate splits) as a float's mantissa only has so many bits of
+    // precision.
+
+    if (_splitState == SplitState::Horizontal)
+    {
+        secondOffset.y += (1 - _desiredSplitPosition) * parentOffset.scaleY;
+        firstOffset.scaleY *= _desiredSplitPosition;
+        secondOffset.scaleY *= (1 - _desiredSplitPosition);
+    }
+    else
+    {
+        secondOffset.x += (1 - _desiredSplitPosition) * parentOffset.scaleX;
+        firstOffset.scaleX *= _desiredSplitPosition;
+        secondOffset.scaleX *= (1 - _desiredSplitPosition);
+    }
+
+    return { firstOffset, secondOffset };
+}
+
 // Method Description:
 // - Given the source pane, and its relative position in the tree, attempt to
 //   find its visual neighbor within the current pane's tree.
@@ -611,24 +840,14 @@ Pane::PaneNeighborSearch Pane::_FindNeighborForPane(const FocusDirection& direct
     // If we are a leaf node test if we adjacent to the focus node
     if (_IsLeaf())
     {
-        if (_IsAdjacent(searchResult.source, searchResult.sourceOffset, shared_from_this(), offset, direction))
+        if (_IsAdjacent(searchResult.sourceOffset, offset, direction))
         {
             searchResult.neighbor = shared_from_this();
         }
         return searchResult;
     }
 
-    auto firstOffset = offset;
-    auto secondOffset = offset;
-    // The second child has an offset depending on the split
-    if (_splitState == SplitState::Horizontal)
-    {
-        secondOffset.y += gsl::narrow_cast<float>(_firstChild->GetRootElement().ActualHeight());
-    }
-    else
-    {
-        secondOffset.x += gsl::narrow_cast<float>(_firstChild->GetRootElement().ActualWidth());
-    }
+    auto [firstOffset, secondOffset] = _GetOffsetsForPane(offset);
     auto sourceNeighborSearch = _firstChild->_FindNeighborForPane(direction, searchResult, sourceIsSecondSide, firstOffset);
     if (sourceNeighborSearch.neighbor)
     {
@@ -661,18 +880,7 @@ Pane::PaneNeighborSearch Pane::_FindPaneAndNeighbor(const std::shared_ptr<Pane>
         return { nullptr, nullptr, offset };
     }
 
-    // Search the first child, which has no offset from the parent pane
-    auto firstOffset = offset;
-    auto secondOffset = offset;
-    // The second child has an offset depending on the split
-    if (_splitState == SplitState::Horizontal)
-    {
-        secondOffset.y += gsl::narrow_cast<float>(_firstChild->GetRootElement().ActualHeight());
-    }
-    else
-    {
-        secondOffset.x += gsl::narrow_cast<float>(_firstChild->GetRootElement().ActualWidth());
-    }
+    auto [firstOffset, secondOffset] = _GetOffsetsForPane(offset);
 
     auto sourceNeighborSearch = _firstChild->_FindPaneAndNeighbor(sourcePane, direction, firstOffset);
     // If we have both the focus element and its neighbor, we are done
@@ -1084,7 +1292,7 @@ void Pane::UpdateSettings(const TerminalSettingsCreateResult& settings, const Pr
 // - splitType: How the pane should be attached
 // Return Value:
 // - the new reference to the child created from the current pane.
-std::shared_ptr<Pane> Pane::AttachPane(std::shared_ptr<Pane> pane, SplitState splitType)
+std::shared_ptr<Pane> Pane::AttachPane(std::shared_ptr<Pane> pane, SplitDirection splitType)
 {
     // Splice the new pane into the tree
     const auto [first, _] = _Split(splitType, .5, pane);
@@ -1134,7 +1342,7 @@ std::shared_ptr<Pane> Pane::DetachPane(std::shared_ptr<Pane> pane)
         auto detached = isFirstChild ? _firstChild : _secondChild;
         // Remove the child from the tree, replace the current node with the
         // other child.
-        _CloseChild(isFirstChild);
+        _CloseChild(isFirstChild, true);
 
         detached->_borders = Borders::None;
         detached->_UpdateBorders();
@@ -1162,9 +1370,12 @@ std::shared_ptr<Pane> Pane::DetachPane(std::shared_ptr<Pane> pane)
 // Arguments:
 // - closeFirst: if true, the first child should be closed, and the second
 //   should be preserved, and vice-versa for false.
+// - isDetaching: if true, then the pane event handlers for the closed child
+//   should be kept, this way they don't have to be recreated when it is later
+//   reattached to a tree somewhere as the control moves with the pane.
 // Return Value:
 // - <none>
-void Pane::_CloseChild(const bool closeFirst)
+void Pane::_CloseChild(const bool closeFirst, const bool isDetaching)
 {
     // Lock the create/close lock so that another operation won't concurrently
     // modify our tree
@@ -1182,6 +1393,8 @@ void Pane::_CloseChild(const bool closeFirst)
 
     auto closedChild = closeFirst ? _firstChild : _secondChild;
     auto remainingChild = closeFirst ? _secondChild : _firstChild;
+    auto closedChildClosedToken = closeFirst ? _firstClosedToken : _secondClosedToken;
+    auto remainingChildClosedToken = closeFirst ? _secondClosedToken : _firstClosedToken;
 
     // If the only child left is a leaf, that means we're a leaf now.
     if (remainingChild->_IsLeaf())
@@ -1207,11 +1420,18 @@ void Pane::_CloseChild(const bool closeFirst)
         // themselves closing, and remove their handlers for their controls
         // closing. At this point, if the remaining child's control is closed,
         // they'll trigger only our event handler for the control's close.
-        _firstChild->Closed(_firstClosedToken);
-        _secondChild->Closed(_secondClosedToken);
-        closedChild->_control.ConnectionStateChanged(closedChild->_connectionStateChangedToken);
+
+        // However, if we are detaching the pane we want to keep its control
+        // handlers since it is just getting moved.
+        if (!isDetaching)
+        {
+            closedChild->_control.ConnectionStateChanged(closedChild->_connectionStateChangedToken);
+            closedChild->_control.WarningBell(closedChild->_warningBellToken);
+        }
+
+        closedChild->Closed(closedChildClosedToken);
+        remainingChild->Closed(remainingChildClosedToken);
         remainingChild->_control.ConnectionStateChanged(remainingChild->_connectionStateChangedToken);
-        closedChild->_control.WarningBell(closedChild->_warningBellToken);
         remainingChild->_control.WarningBell(remainingChild->_warningBellToken);
 
         // If either of our children was focused, we want to take that focus from
@@ -1271,12 +1491,6 @@ void Pane::_CloseChild(const bool closeFirst)
         // Find what borders need to persist after we close the child
         auto remainingBorders = _GetCommonBorders();
 
-        // First stash away references to the old panes and their tokens
-        const auto oldFirstToken = _firstClosedToken;
-        const auto oldSecondToken = _secondClosedToken;
-        const auto oldFirst = _firstChild;
-        const auto oldSecond = _secondChild;
-
         // Steal all the state from our child
         _splitState = remainingChild->_splitState;
         _firstChild = remainingChild->_firstChild;
@@ -1289,11 +1503,14 @@ void Pane::_CloseChild(const bool closeFirst)
         _firstChild->Closed(remainingChild->_firstClosedToken);
         _secondChild->Closed(remainingChild->_secondClosedToken);
 
-        // Revoke event handlers on old panes and controls
-        oldFirst->Closed(oldFirstToken);
-        oldSecond->Closed(oldSecondToken);
-        closedChild->_control.ConnectionStateChanged(closedChild->_connectionStateChangedToken);
-        closedChild->_control.WarningBell(closedChild->_warningBellToken);
+        // Remove the event handlers on the old children
+        remainingChild->Closed(remainingChildClosedToken);
+        closedChild->Closed(closedChildClosedToken);
+        if (!isDetaching)
+        {
+            closedChild->_control.ConnectionStateChanged(closedChild->_connectionStateChangedToken);
+            closedChild->_control.WarningBell(closedChild->_warningBellToken);
+        }
 
         // Reset our UI:
         _root.Children().Clear();
@@ -1364,7 +1581,7 @@ winrt::fire_and_forget Pane::_CloseChildRoutine(const bool closeFirst)
         // this one doesn't seem to.
         if (!animationsEnabledInOS || !animationsEnabledInApp || eitherChildZoomed)
         {
-            pane->_CloseChild(closeFirst);
+            pane->_CloseChild(closeFirst, false);
             co_return;
         }
 
@@ -1471,7 +1688,7 @@ winrt::fire_and_forget Pane::_CloseChildRoutine(const bool closeFirst)
             {
                 // We don't need to manually undo any of the above trickiness.
                 // We're going to re-parent the child's content into us anyways
-                pane->_CloseChild(closeFirst);
+                pane->_CloseChild(closeFirst, false);
             }
         });
     }
@@ -1786,7 +2003,7 @@ void Pane::_SetupEntranceAnimation()
 // Note:
 // - This method is highly similar to Pane::PreCalculateAutoSplit
 std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> target,
-                                               SplitState splitType,
+                                               SplitDirection splitType,
                                                const float splitSize,
                                                const winrt::Windows::Foundation::Size availableSpace) const
 {
@@ -1800,12 +2017,7 @@ std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> targe
             // the available space to calculate which direction to split in.
             const Size minSize = _GetMinSize();
 
-            if (splitType == SplitState::None)
-            {
-                return { false };
-            }
-
-            else if (splitType == SplitState::Vertical)
+            if (splitType == SplitDirection::Left || splitType == SplitDirection::Right)
             {
                 const auto widthMinusSeparator = availableSpace.Width - CombinedPaneBorderSize;
                 const auto newFirstWidth = widthMinusSeparator * firstPrecent;
@@ -1814,7 +2026,7 @@ std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> targe
                 return { newFirstWidth > minSize.Width && newSecondWidth > minSize.Width };
             }
 
-            else if (splitType == SplitState::Horizontal)
+            else if (splitType == SplitDirection::Up || splitType == SplitDirection::Down)
             {
                 const auto heightMinusSeparator = availableSpace.Height - CombinedPaneBorderSize;
                 const auto newFirstHeight = heightMinusSeparator * firstPrecent;
@@ -1867,8 +2079,8 @@ std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> targe
 // - profile: The profile to associate with the newly created pane.
 // - control: A TermControl to use in the new pane.
 // Return Value:
-// - The two newly created Panes
-std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::Split(SplitState splitType,
+// - The two newly created Panes, with the original pane first
+std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::Split(SplitDirection splitType,
                                                                     const float splitSize,
                                                                     const Profile& profile,
                                                                     const TermControl& control)
@@ -1931,18 +2143,18 @@ bool Pane::ToggleSplitOrientation()
 // Method Description:
 // - Converts an "automatic" split type into either Vertical or Horizontal,
 //   based upon the current dimensions of the Pane.
-// - If any of the other SplitState values are passed in, they're returned
-//   unmodified.
+// - Similarly, if Up/Down or Left/Right are provided a Horizontal or Vertical
+//   split type will be returned.
 // Arguments:
-// - splitType: The SplitState to attempt to convert
+// - splitType: The SplitDirection to attempt to convert
 // Return Value:
-// - None if splitType was None, otherwise one of Horizontal or Vertical
-SplitState Pane::_convertAutomaticSplitState(const SplitState& splitType) const
+// - One of Horizontal or Vertical
+SplitState Pane::_convertAutomaticOrDirectionalSplitState(const SplitDirection& splitType) const
 {
     // Careful here! If the pane doesn't yet have a size, these dimensions will
     // be 0, and we'll always return Vertical.
 
-    if (splitType == SplitState::Automatic)
+    if (splitType == SplitDirection::Automatic)
     {
         // If the requested split type was "auto", determine which direction to
         // split based on our current dimensions
@@ -1950,7 +2162,12 @@ SplitState Pane::_convertAutomaticSplitState(const SplitState& splitType) const
                                gsl::narrow_cast<float>(_root.ActualHeight()) };
         return actualSize.Width >= actualSize.Height ? SplitState::Vertical : SplitState::Horizontal;
     }
-    return splitType;
+    if (splitType == SplitDirection::Up || splitType == SplitDirection::Down)
+    {
+        return SplitState::Horizontal;
+    }
+    // All that is left is Left / Right which are vertical splits
+    return SplitState::Vertical;
 }
 
 // Method Description:
@@ -1961,17 +2178,12 @@ SplitState Pane::_convertAutomaticSplitState(const SplitState& splitType) const
 // - splitSize: what fraction of the pane the new pane should get
 // - newPane: the pane to add as a child
 // Return Value:
-// - The two newly created Panes
-std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState splitType,
+// - The two newly created Panes, with the original pane as the first pane.
+std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitDirection splitType,
                                                                      const float splitSize,
                                                                      std::shared_ptr<Pane> newPane)
 {
-    if (splitType == SplitState::None)
-    {
-        return { nullptr, nullptr };
-    }
-
-    auto actualSplitType = _convertAutomaticSplitState(splitType);
+    auto actualSplitType = _convertAutomaticOrDirectionalSplitState(splitType);
 
     // Lock the create/close lock so that another operation won't concurrently
     // modify our tree
@@ -2002,9 +2214,16 @@ std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState
     //   Move the new guid, control into the second.
     _firstChild = std::make_shared<Pane>(_profile, _control);
     _firstChild->_connectionState = std::exchange(_connectionState, ConnectionState::NotConnected);
+    _secondChild = newPane;
+
+    // If we want the new pane to be the first child, swap the children
+    if (splitType == SplitDirection::Up || splitType == SplitDirection::Left)
+    {
+        std::swap(_firstChild, _secondChild);
+    }
+
     _profile = nullptr;
     _control = { nullptr };
-    _secondChild = newPane;
 
     _CreateRowColDefinitions();
 
@@ -2023,6 +2242,12 @@ std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState
     // Clear out our ID, only leaves should have IDs
     _id = {};
 
+    // Regardless of which child the new child is, we want to return the
+    // original one first.
+    if (splitType == SplitDirection::Up || splitType == SplitDirection::Left)
+    {
+        return { _secondChild, _firstChild };
+    }
     return { _firstChild, _secondChild };
 }
 
@@ -2658,10 +2883,10 @@ int Pane::GetLeafPaneCount() const noexcept
 // - availableSpace: The theoretical space that's available for this pane to be able to split.
 // Return Value:
 // - nullopt if `target` is not this pane or a child of this pane, otherwise the
-//   SplitState that `target` would use for an `Automatic` split given
+//   SplitDirection that `target` would use for an `Automatic` split given
 //   `availableSpace`
-std::optional<SplitState> Pane::PreCalculateAutoSplit(const std::shared_ptr<Pane> target,
-                                                      const winrt::Windows::Foundation::Size availableSpace) const
+std::optional<SplitDirection> Pane::PreCalculateAutoSplit(const std::shared_ptr<Pane> target,
+                                                          const winrt::Windows::Foundation::Size availableSpace) const
 {
     if (_IsLeaf())
     {
@@ -2669,7 +2894,7 @@ std::optional<SplitState> Pane::PreCalculateAutoSplit(const std::shared_ptr<Pane
         {
             //If this pane is a leaf, and it's the pane we're looking for, use
             //the available space to calculate which direction to split in.
-            return availableSpace.Width > availableSpace.Height ? SplitState::Vertical : SplitState::Horizontal;
+            return availableSpace.Width > availableSpace.Height ? SplitDirection::Right : SplitDirection::Down;
         }
         else
         {

src/cascadia/TerminalApp/Pane.h

@@ -44,6 +44,13 @@ enum class Borders : int
 };
 DEFINE_ENUM_FLAG_OPERATORS(Borders);
 
+enum class SplitState : int
+{
+    None = 0,
+    Horizontal = 1,
+    Vertical = 2
+};
+
 class Pane : public std::enable_shared_from_this<Pane>
 {
 public:
@@ -70,34 +77,46 @@ public:
     void ClearActive();
     void SetActive();
 
+    struct BuildStartupState
+    {
+        std::vector<winrt::Microsoft::Terminal::Settings::Model::ActionAndArgs> args;
+        std::shared_ptr<Pane> firstPane;
+        std::optional<uint32_t> focusedPaneId;
+        uint32_t panesCreated;
+    };
+    BuildStartupState BuildStartupActions(uint32_t currentId, uint32_t nextId);
+    winrt::Microsoft::Terminal::Settings::Model::NewTerminalArgs GetTerminalArgsForPane() const;
+
     void UpdateSettings(const winrt::Microsoft::Terminal::Settings::Model::TerminalSettingsCreateResult& settings,
                         const winrt::Microsoft::Terminal::Settings::Model::Profile& profile);
     void ResizeContent(const winrt::Windows::Foundation::Size& newSize);
     void Relayout();
     bool ResizePane(const winrt::Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
-    std::shared_ptr<Pane> NavigateDirection(const std::shared_ptr<Pane> sourcePane, const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction);
+    std::shared_ptr<Pane> NavigateDirection(const std::shared_ptr<Pane> sourcePane,
+                                            const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction,
+                                            const std::vector<uint32_t>& mruPanes);
     bool SwapPanes(std::shared_ptr<Pane> first, std::shared_ptr<Pane> second);
 
     std::shared_ptr<Pane> NextPane(const std::shared_ptr<Pane> pane);
     std::shared_ptr<Pane> PreviousPane(const std::shared_ptr<Pane> pane);
 
-    std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Split(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
+    std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Split(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                                                                   const float splitSize,
                                                                   const winrt::Microsoft::Terminal::Settings::Model::Profile& profile,
                                                                   const winrt::Microsoft::Terminal::Control::TermControl& control);
     bool ToggleSplitOrientation();
     float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const;
-    std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitState> PreCalculateAutoSplit(const std::shared_ptr<Pane> target,
-                                                                                                 const winrt::Windows::Foundation::Size parentSize) const;
+    std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitDirection> PreCalculateAutoSplit(const std::shared_ptr<Pane> target,
+                                                                                                     const winrt::Windows::Foundation::Size parentSize) const;
     std::optional<bool> PreCalculateCanSplit(const std::shared_ptr<Pane> target,
-                                             winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
+                                             winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                                              const float splitSize,
                                              const winrt::Windows::Foundation::Size availableSpace) const;
     void Shutdown();
     void Close();
 
     std::shared_ptr<Pane> AttachPane(std::shared_ptr<Pane> pane,
-                                     winrt::Microsoft::Terminal::Settings::Model::SplitState splitType);
+                                     winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType);
     std::shared_ptr<Pane> DetachPane(std::shared_ptr<Pane> pane);
 
     int GetLeafPaneCount() const noexcept;
@@ -162,7 +181,7 @@ private:
 
     std::shared_ptr<Pane> _firstChild{ nullptr };
     std::shared_ptr<Pane> _secondChild{ nullptr };
-    winrt::Microsoft::Terminal::Settings::Model::SplitState _splitState{ winrt::Microsoft::Terminal::Settings::Model::SplitState::None };
+    SplitState _splitState{ SplitState::None };
     float _desiredSplitPosition;
 
     std::optional<uint32_t> _id;
@@ -187,7 +206,7 @@ private:
     bool _HasFocusedChild() const noexcept;
     void _SetupChildCloseHandlers();
 
-    std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> _Split(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
+    std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> _Split(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                                                                    const float splitSize,
                                                                    std::shared_ptr<Pane> newPane);
 
@@ -200,7 +219,8 @@ private:
     bool _Resize(const winrt::Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
 
     std::shared_ptr<Pane> _FindParentOfPane(const std::shared_ptr<Pane> pane);
-    bool _IsAdjacent(const std::shared_ptr<Pane> first, const PanePoint firstOffset, const std::shared_ptr<Pane> second, const PanePoint secondOffset, const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction) const;
+    std::pair<PanePoint, PanePoint> _GetOffsetsForPane(const PanePoint parentOffset) const;
+    bool _IsAdjacent(const PanePoint firstOffset, const PanePoint secondOffset, const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction) const;
     PaneNeighborSearch _FindNeighborForPane(const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction,
                                             PaneNeighborSearch searchResult,
                                             const bool focusIsSecondSide,
@@ -209,7 +229,7 @@ private:
                                             const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction,
                                             const PanePoint offset);
 
-    void _CloseChild(const bool closeFirst);
+    void _CloseChild(const bool closeFirst, const bool isDetaching);
     winrt::fire_and_forget _CloseChildRoutine(const bool closeFirst);
 
     void _FocusFirstChild();
@@ -225,14 +245,13 @@ private:
     SnapChildrenSizeResult _CalcSnappedChildrenSizes(const bool widthOrHeight, const float fullSize) const;
     SnapSizeResult _CalcSnappedDimension(const bool widthOrHeight, const float dimension) const;
     void _AdvanceSnappedDimension(const bool widthOrHeight, LayoutSizeNode& sizeNode) const;
-
     winrt::Windows::Foundation::Size _GetMinSize() const;
     LayoutSizeNode _CreateMinSizeTree(const bool widthOrHeight) const;
     float _ClampSplitPosition(const bool widthOrHeight, const float requestedValue, const float totalSize) const;
 
-    winrt::Microsoft::Terminal::Settings::Model::SplitState _convertAutomaticSplitState(const winrt::Microsoft::Terminal::Settings::Model::SplitState& splitType) const;
+    SplitState _convertAutomaticOrDirectionalSplitState(const winrt::Microsoft::Terminal::Settings::Model::SplitDirection& splitType) const;
 
-    std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitState> _preCalculateAutoSplit(const std::shared_ptr<Pane> target, const winrt::Windows::Foundation::Size parentSize) const;
+    std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitDirection> _preCalculateAutoSplit(const std::shared_ptr<Pane> target, const winrt::Windows::Foundation::Size parentSize) const;
 
     // Function Description:
     // - Returns true if the given direction can be used with the given split
@@ -243,24 +262,24 @@ private:
     // - Also used for moving focus between panes, which again happens _across_ a separator.
     // Arguments:
     // - direction: The Direction to compare
-    // - splitType: The winrt::TerminalApp::SplitState to compare
+    // - splitType: The SplitState to compare
     // Return Value:
     // - true iff the direction is perpendicular to the splitType. False for
-    //   winrt::TerminalApp::SplitState::None.
+    //   SplitState::None.
     template<typename T>
     static constexpr bool DirectionMatchesSplit(const T& direction,
-                                                const winrt::Microsoft::Terminal::Settings::Model::SplitState& splitType)
+                                                const SplitState& splitType)
     {
-        if (splitType == winrt::Microsoft::Terminal::Settings::Model::SplitState::None)
+        if (splitType == SplitState::None)
         {
             return false;
         }
-        else if (splitType == winrt::Microsoft::Terminal::Settings::Model::SplitState::Horizontal)
+        else if (splitType == SplitState::Horizontal)
         {
             return direction == T::Up ||
                    direction == T::Down;
         }
-        else if (splitType == winrt::Microsoft::Terminal::Settings::Model::SplitState::Vertical)
+        else if (splitType == SplitState::Vertical)
         {
             return direction == T::Left ||
                    direction == T::Right;
@@ -274,6 +293,8 @@ private:
     {
         float x;
         float y;
+        float scaleX;
+        float scaleY;
     };
 
     struct PaneNeighborSearch

src/cascadia/TerminalApp/Resources/en-US/Resources.resw

@@ -184,6 +184,9 @@
   <data name="CloseAll" xml:space="preserve">
     <value>Close all</value>
   </data>
+  <data name="Quit" xml:space="preserve">
+    <value>Quit</value>
+  </data>
   <data name="CloseWindowWarningTitle" xml:space="preserve">
     <value>Do you want to close all tabs?</value>
   </data>
@@ -441,6 +444,15 @@
     <value>Third-Party Notices</value>
     <comment>A hyperlink name for the Terminal's third-party notices</comment>
   </data>
+  <data name="QuitDialog.CloseButtonText" xml:space="preserve">
+    <value>Cancel</value>
+  </data>
+  <data name="QuitDialog.PrimaryButtonText" xml:space="preserve">
+    <value>Close all</value>
+  </data>
+  <data name="QuitDialog.Title" xml:space="preserve">
+    <value>Do you want to close all windows?</value>
+  </data>
   <data name="CloseAllDialog.CloseButtonText" xml:space="preserve">
     <value>Cancel</value>
   </data>
@@ -653,11 +665,11 @@
   <data name="CommandPaletteMenuItem" xml:space="preserve">
     <value>Command Palette</value>
   </data>
-  <data name="TrayIconFocusTerminal" xml:space="preserve">
+  <data name="NotificationIconFocusTerminal" xml:space="preserve">
     <value>Focus Terminal</value>
     <comment>This is displayed as a label for the context menu item that focuses the terminal.</comment>
   </data>
-  <data name="TrayIconWindowSubmenu" xml:space="preserve">
+  <data name="NotificationIconWindowSubmenu" xml:space="preserve">
     <value>Windows</value>
     <comment>This is displayed as a label for the context menu item that holds the submenu of available windows.</comment>
   </data>
@@ -685,4 +697,22 @@
   <data name="DropPathTabSplit.Text" xml:space="preserve">
     <value>Split the window and start in given directory</value>
   </data>
+  <data name="ExportTabText" xml:space="preserve">
+    <value>Export Text</value>
+  </data>
+  <data name="ExportFailure" xml:space="preserve">
+    <value>Failed to export terminal content</value>
+  </data>
+  <data name="ExportSuccess" xml:space="preserve">
+    <value>Successfully exported terminal content</value>
+  </data>
+  <data name="PlainText" xml:space="preserve">
+    <value>Plain Text</value>
+  </data>
+  <data name="CloseOnExitInfoBar.Message" xml:space="preserve">
+    <value>Termination behavior can be configured in advanced profile settings.</value>
+  </data>
+  <data name="InfoBarDismissButton.Content" xml:space="preserve">
+    <value>Don't show again</value>
+  </data>
 </root>

src/cascadia/TerminalApp/TabManagement.cpp

@@ -28,6 +28,9 @@ using namespace winrt::Windows::UI::Core;
 using namespace winrt::Windows::System;
 using namespace winrt::Windows::ApplicationModel::DataTransfer;
 using namespace winrt::Windows::UI::Text;
+using namespace winrt::Windows::Storage;
+using namespace winrt::Windows::Storage::Pickers;
+using namespace winrt::Windows::Storage::Provider;
 using namespace winrt::Microsoft::Terminal;
 using namespace winrt::Microsoft::Terminal::Control;
 using namespace winrt::Microsoft::Terminal::TerminalConnection;
@@ -171,6 +174,16 @@ namespace winrt::TerminalApp::implementation
             }
         });
 
+        newTabImpl->ExportTabRequested([weakTab, weakThis{ get_weak() }]() {
+            auto page{ weakThis.get() };
+            auto tab{ weakTab.get() };
+
+            if (page && tab)
+            {
+                page->_ExportTab(*tab);
+            }
+        });
+
         auto tabViewItem = newTabImpl->TabViewItem();
         _tabView.TabItems().Append(tabViewItem);
 
@@ -276,7 +289,7 @@ namespace winrt::TerminalApp::implementation
             auto newControl = _InitControl(settings, debugConnection);
             _RegisterTerminalEvents(newControl);
             // Split (auto) with the debug tap.
-            newTabImpl->SplitPane(SplitState::Automatic, 0.5f, profile, newControl);
+            newTabImpl->SplitPane(SplitDirection::Automatic, 0.5f, profile, newControl);
         }
     }
 
@@ -350,8 +363,10 @@ namespace winrt::TerminalApp::implementation
             // current control's live settings (which will include changes
             // made through VT).
 
-            if (const auto profile = tab.GetFocusedProfile())
+            if (auto profile = tab.GetFocusedProfile())
             {
+                // TODO GH#5047 If we cache the NewTerminalArgs, we no longer need to do this.
+                profile = GetClosestProfileForDuplicationOfProfile(profile);
                 const auto settingsCreateResult{ TerminalSettings::CreateWithProfile(_settings, profile, *_bindings) };
                 const auto workingDirectory = tab.GetActiveTerminalControl().WorkingDirectory();
                 const auto validWorkingDirectory = !workingDirectory.empty();
@@ -384,7 +399,46 @@ namespace winrt::TerminalApp::implementation
         try
         {
             _SetFocusedTab(tab);
-            _SplitPane(tab, SplitState::Automatic, SplitType::Duplicate);
+            _SplitPane(tab, SplitDirection::Automatic, SplitType::Duplicate);
+        }
+        CATCH_LOG();
+    }
+
+    // Method Description:
+    // - Exports the content of the Terminal Buffer inside the tab
+    // Arguments:
+    // - tab: tab to export
+    winrt::fire_and_forget TerminalPage::_ExportTab(const TerminalTab& tab)
+    {
+        try
+        {
+            if (const auto control{ tab.GetActiveTerminalControl() })
+            {
+                const FileSavePicker savePicker;
+                savePicker.as<IInitializeWithWindow>()->Initialize(*_hostingHwnd);
+                savePicker.SuggestedStartLocation(PickerLocationId::Downloads);
+                const auto fileChoices = single_threaded_vector<hstring>({ L".txt" });
+                savePicker.FileTypeChoices().Insert(RS_(L"PlainText"), fileChoices);
+                savePicker.SuggestedFileName(control.Title());
+
+                const StorageFile file = co_await savePicker.PickSaveFileAsync();
+                if (file != nullptr)
+                {
+                    const auto buffer = control.ReadEntireBuffer();
+                    CachedFileManager::DeferUpdates(file);
+                    co_await FileIO::WriteTextAsync(file, buffer);
+                    const auto status = co_await CachedFileManager::CompleteUpdatesAsync(file);
+                    switch (status)
+                    {
+                    case FileUpdateStatus::Complete:
+                    case FileUpdateStatus::CompleteAndRenamed:
+                        _ShowControlNoticeDialog(RS_(L"NoticeInfo"), RS_(L"ExportSuccess"));
+                        break;
+                    default:
+                        _ShowControlNoticeDialog(RS_(L"NoticeError"), RS_(L"ExportFailure"));
+                    }
+                }
+            }
         }
         CATCH_LOG();
     }
@@ -445,6 +499,14 @@ namespace winrt::TerminalApp::implementation
         // To close the window here, we need to close the hosting window.
         if (_tabs.Size() == 0)
         {
+            // If we are supposed to save state, make sure we clear it out
+            // if the user manually closed all tabs.
+            if (!_maintainStateOnTabClose && ShouldUsePersistedLayout(_settings))
+            {
+                auto state = ApplicationState::SharedInstance();
+                state.PersistedWindowLayouts(nullptr);
+            }
+
             _LastTabClosedHandlers(*this, nullptr);
         }
         else if (focusedTabIndex.has_value() && focusedTabIndex.value() == gsl::narrow_cast<uint32_t>(tabIndex))
@@ -545,9 +607,13 @@ namespace winrt::TerminalApp::implementation
         tabIndex = std::clamp(tabIndex, 0u, _tabs.Size() - 1);
 
         auto tab{ _tabs.GetAt(tabIndex) };
+        // GH#11107 - Always just set the item directly first so that if
+        // tab movement is done as part of multiple actions following calls
+        // to _GetFocusedTab will return the correct tab.
+        _tabView.SelectedItem(tab.TabViewItem());
+
         if (_startupState == StartupState::InStartup)
         {
-            _tabView.SelectedItem(tab.TabViewItem());
             _UpdatedSelectedTab(tab);
         }
         else

src/cascadia/TerminalApp/TerminalAppLib.vcxproj

@@ -21,14 +21,12 @@
   <Import Project="$(OpenConsoleDir)src\cppwinrt.build.pre.props" />
   <Import Project="..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.props" Condition="Exists('..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.props')" />
   <ItemDefinitionGroup>
-
     <ClCompile>
       <!-- For CLI11: It uses dynamic_cast to cast types around, which depends
       on being compiled with RTTI (/GR). -->
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
     </ClCompile>
   </ItemDefinitionGroup>
-
   <!-- ========================= XAML files ======================== -->
   <ItemGroup>
     <!-- HERE BE DRAGONS:
@@ -238,7 +236,6 @@
     </ClCompile>
     <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
     <ClCompile Include="Toast.cpp" />
-
   </ItemGroup>
   <!-- ========================= idl Files ======================== -->
   <ItemGroup>
@@ -379,17 +376,16 @@
   </ItemDefinitionGroup>
   <!-- ========================= Globals ======================== -->
   <Import Project="$(OpenConsoleDir)src\cppwinrt.build.post.props" />
-
-  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Import Project="..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets'))" />
+    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets'))" />
     <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets'))" />
+    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.VisualStudio.Setup.Configuration.Native.2.3.2262\build\native\Microsoft.VisualStudio.Setup.Configuration.Native.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.VisualStudio.Setup.Configuration.Native.2.3.2262\build\native\Microsoft.VisualStudio.Setup.Configuration.Native.targets'))" />
   </Target>
-
   <!--
     By default, the PRI file will contain resource paths beginning with the
     project name. Since we enabled XBF embedding, this *also* includes App.xbf.
@@ -409,6 +405,5 @@
       </PackagingOutputs>
     </ItemGroup>
   </Target>
-
   <Import Project="$(SolutionDir)build\rules\CollectWildcardResources.targets" />
 </Project>

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -276,6 +276,21 @@ namespace winrt::TerminalApp::implementation
         CATCH_LOG();
     }
 
+    // Method Description;
+    // - Checks if the current terminal window should load or save its layout information.
+    // Arguments:
+    // - settings: The settings to use as this may be called before the page is
+    //   fully initialized.
+    // Return Value:
+    // - true if the ApplicationState should be used.
+    bool TerminalPage::ShouldUsePersistedLayout(CascadiaSettings& settings) const
+    {
+        // If the setting is enabled, and we are the only window.
+        return Feature_PersistedWindowLayout::IsEnabled() &&
+               settings.GlobalSettings().FirstWindowPreference() == FirstWindowPreference::PersistedWindowLayout &&
+               _numOpenWindows == 1;
+    }
+
     winrt::fire_and_forget TerminalPage::NewTerminalByDrop(winrt::Windows::UI::Xaml::DragEventArgs& e)
     {
         Windows::Foundation::Collections::IVectorView<Windows::Storage::IStorageItem> items;
@@ -358,6 +373,34 @@ namespace winrt::TerminalApp::implementation
         if (_startupState == StartupState::NotInitialized)
         {
             _startupState = StartupState::InStartup;
+
+            // If the user selected to save their tab layout, we are the first
+            // window opened, and wt was not run with any other arguments, then
+            // we should use the saved settings.
+            auto firstActionIsDefault = [](ActionAndArgs action) {
+                if (action.Action() != ShortcutAction::NewTab)
+                {
+                    return false;
+                }
+
+                // If no commands were given, we will have default args
+                if (const auto args = action.Args().try_as<NewTabArgs>())
+                {
+                    NewTerminalArgs defaultArgs{};
+                    return args.TerminalArgs() == nullptr || args.TerminalArgs().Equals(defaultArgs);
+                }
+
+                return false;
+            };
+            if (ShouldUsePersistedLayout(_settings) && _startupActions.Size() == 1 && firstActionIsDefault(_startupActions.GetAt(0)))
+            {
+                auto layouts = ApplicationState::SharedInstance().PersistedWindowLayouts();
+                if (layouts && layouts.Size() > 0 && layouts.GetAt(0).TabLayout() && layouts.GetAt(0).TabLayout().Size() > 0)
+                {
+                    _startupActions = layouts.GetAt(0).TabLayout();
+                }
+            }
+
             ProcessStartupActions(_startupActions, true);
 
             // If we were told that the COM server needs to be started to listen for incoming
@@ -461,7 +504,10 @@ namespace winrt::TerminalApp::implementation
             // GH#6586: now that we're done processing all startup commands,
             // focus the active control. This will work as expected for both
             // commandline invocations and for `wt` action invocations.
-            _GetActiveControl().Focus(FocusState::Programmatic);
+            if (const auto control = _GetActiveControl())
+            {
+                control.Focus(FocusState::Programmatic);
+            }
         }
         if (initial)
         {
@@ -512,6 +558,21 @@ namespace winrt::TerminalApp::implementation
         ShellExecute(nullptr, nullptr, currentPath.c_str(), nullptr, nullptr, SW_SHOW);
     }
 
+    // Method Description:
+    // - Displays a dialog to warn the user that they are about to close all open windows.
+    //   Once the user clicks the OK button, shut down the application.
+    //   If cancel is clicked, the dialog will close.
+    // - Only one dialog can be visible at a time. If another dialog is visible
+    //   when this is called, nothing happens. See _ShowDialog for details
+    winrt::Windows::Foundation::IAsyncOperation<ContentDialogResult> TerminalPage::_ShowQuitDialog()
+    {
+        if (auto presenter{ _dialogPresenter.get() })
+        {
+            co_return co_await presenter.ShowDialog(FindName(L"QuitDialog").try_as<WUX::Controls::ContentDialog>());
+        }
+        co_return ContentDialogResult::None;
+    }
+
     // Method Description:
     // - Displays a dialog for warnings found while closing the terminal app using
     //   key binding with multiple tabs opened. Display messages to warn user
@@ -766,7 +827,7 @@ namespace winrt::TerminalApp::implementation
 
         if (altPressed && !debugTap)
         {
-            this->_SplitPane(SplitState::Automatic,
+            this->_SplitPane(SplitDirection::Automatic,
                              SplitType::Manual,
                              0.5f,
                              newTerminalArgs);
@@ -811,12 +872,6 @@ namespace winrt::TerminalApp::implementation
     TerminalConnection::ITerminalConnection TerminalPage::_CreateConnectionFromSettings(Profile profile,
                                                                                         TerminalSettings settings)
     {
-        if (!profile)
-        {
-            // Use the default profile if we didn't get one as an argument.
-            profile = _settings.FindProfile(_settings.GlobalSettings().DefaultProfile());
-        }
-
         TerminalConnection::ITerminalConnection connection{ nullptr };
 
         winrt::guid connectionType = profile.ConnectionType();
@@ -1022,7 +1077,7 @@ namespace winrt::TerminalApp::implementation
     {
         auto newTabTitle = tab.Title();
 
-        if (_settings.GlobalSettings().ShowTitleInTitlebar() && tab == _GetFocusedTab())
+        if (tab == _GetFocusedTab())
         {
             _TitleChangedHandlers(*this, newTabTitle);
         }
@@ -1053,6 +1108,8 @@ namespace winrt::TerminalApp::implementation
         // Add an event handler for when the terminal or tab wants to set a
         // progress indicator on the taskbar
         term.SetTaskbarProgress({ get_weak(), &TerminalPage::_SetTaskbarProgressHandler });
+
+        term.ConnectionStateChanged({ get_weak(), &TerminalPage::_ConnectionStateChangedHandler });
     }
 
     // Method Description:
@@ -1167,7 +1224,6 @@ namespace winrt::TerminalApp::implementation
     {
         if (const auto terminalTab{ _GetFocusedTabImpl() })
         {
-            _UnZoomIfNeeded();
             return terminalTab->NavigateFocus(direction);
         }
         return false;
@@ -1198,13 +1254,116 @@ namespace winrt::TerminalApp::implementation
         }
         return nullptr;
     }
+    // Method Description:
+    // - Warn the user that they are about to close all open windows, then
+    //   signal that we want to close everything.
+    fire_and_forget TerminalPage::RequestQuit()
+    {
+        if (!_displayingCloseDialog)
+        {
+            _displayingCloseDialog = true;
+            ContentDialogResult warningResult = co_await _ShowQuitDialog();
+            _displayingCloseDialog = false;
+
+            if (warningResult != ContentDialogResult::Primary)
+            {
+                co_return;
+            }
+
+            _QuitRequestedHandlers(nullptr, nullptr);
+        }
+    }
+
+    // Method Description:
+    // - Saves the window position and tab layout to the application state
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void TerminalPage::PersistWindowLayout()
+    {
+        std::vector<ActionAndArgs> actions;
+
+        for (auto tab : _tabs)
+        {
+            if (auto terminalTab = _GetTerminalTabImpl(tab))
+            {
+                auto tabActions = terminalTab->BuildStartupActions();
+                actions.insert(actions.end(), tabActions.begin(), tabActions.end());
+            }
+            else if (tab.try_as<SettingsTab>())
+            {
+                ActionAndArgs action;
+                action.Action(ShortcutAction::OpenSettings);
+                OpenSettingsArgs args{ SettingsTarget::SettingsUI };
+                action.Args(args);
+
+                actions.push_back(action);
+            }
+        }
+
+        // if the focused tab was not the last tab, restore that
+        auto idx = _GetFocusedTabIndex();
+        if (idx && idx != _tabs.Size() - 1)
+        {
+            ActionAndArgs action;
+            action.Action(ShortcutAction::SwitchToTab);
+            SwitchToTabArgs switchToTabArgs{ idx.value() };
+            action.Args(switchToTabArgs);
+
+            actions.push_back(action);
+        }
+
+        WindowLayout layout{};
+        layout.TabLayout(winrt::single_threaded_vector<ActionAndArgs>(std::move(actions)));
+
+        // Only save the content size because the tab size will be added on load.
+        const float contentWidth = ::base::saturated_cast<float>(_tabContent.ActualWidth());
+        const float contentHeight = ::base::saturated_cast<float>(_tabContent.ActualHeight());
+        const winrt::Windows::Foundation::Size windowSize{ contentWidth, contentHeight };
+
+        layout.InitialSize(windowSize);
+
+        if (_hostingHwnd)
+        {
+            // Get the position of the current window. This includes the
+            // non-client already.
+            RECT window{};
+            GetWindowRect(_hostingHwnd.value(), &window);
+
+            // We want to remove the non-client area so calculate that.
+            // We don't have access to the (NonClient)IslandWindow directly so
+            // just replicate the logic.
+            const auto windowStyle = static_cast<DWORD>(GetWindowLong(_hostingHwnd.value(), GWL_STYLE));
+
+            auto dpi = GetDpiForWindow(_hostingHwnd.value());
+            RECT nonClientArea{};
+            LOG_IF_WIN32_BOOL_FALSE(AdjustWindowRectExForDpi(&nonClientArea, windowStyle, false, 0, dpi));
+
+            // The nonClientArea adjustment is negative, so subtract that out.
+            // This way we save the user-visible location of the terminal.
+            LaunchPosition pos{};
+            pos.X = window.left - nonClientArea.left;
+            pos.Y = window.top;
+
+            layout.InitialPosition(pos);
+        }
+
+        auto state = ApplicationState::SharedInstance();
+        state.PersistedWindowLayouts(winrt::single_threaded_vector<WindowLayout>({ layout }));
+    }
 
     // Method Description:
     // - Close the terminal app. If there is more
     //   than one tab opened, show a warning dialog.
-    fire_and_forget TerminalPage::CloseWindow()
+    // Arguments:
+    // - bypassDialog: if true a dialog won't be shown even if the user would
+    //   normally get confirmation. This is used in the case where the user
+    //   has already been prompted by the Quit action.
+    fire_and_forget TerminalPage::CloseWindow(bool bypassDialog)
     {
-        if (_HasMultipleTabs() &&
+        if (!bypassDialog &&
+            _HasMultipleTabs() &&
             _settings.GlobalSettings().ConfirmCloseAllTabs() &&
             !_displayingCloseDialog)
         {
@@ -1218,6 +1377,13 @@ namespace winrt::TerminalApp::implementation
             }
         }
 
+        if (ShouldUsePersistedLayout(_settings))
+        {
+            PersistWindowLayout();
+            // don't delete the ApplicationState when all of the tabs are removed.
+            _maintainStateOnTabClose = true;
+        }
+
         _RemoveAllTabs();
     }
 
@@ -1302,25 +1468,18 @@ namespace winrt::TerminalApp::implementation
     // Method Description:
     // - Split the focused pane either horizontally or vertically, and place the
     //   given TermControl into the newly created pane.
-    // - If splitType == SplitState::None, this method does nothing.
     // Arguments:
-    // - splitType: one value from the TerminalApp::SplitState enum, indicating how the
+    // - splitDirection: one value from the TerminalApp::SplitDirection enum, indicating how the
     //   new pane should be split from its parent.
     // - splitMode: value from TerminalApp::SplitType enum, indicating the profile to be used in the newly split pane.
     // - newTerminalArgs: An object that may contain a blob of parameters to
     //   control which profile is created and with possible other
     //   configurations. See CascadiaSettings::BuildSettings for more details.
-    void TerminalPage::_SplitPane(const SplitState splitType,
+    void TerminalPage::_SplitPane(const SplitDirection splitDirection,
                                   const SplitType splitMode,
                                   const float splitSize,
                                   const NewTerminalArgs& newTerminalArgs)
     {
-        // Do nothing if we're requesting no split.
-        if (splitType == SplitState::None)
-        {
-            return;
-        }
-
         const auto focusedTab{ _GetFocusedTabImpl() };
 
         // Do nothing if no TerminalTab is focused
@@ -1329,33 +1488,26 @@ namespace winrt::TerminalApp::implementation
             return;
         }
 
-        _SplitPane(*focusedTab, splitType, splitMode, splitSize, newTerminalArgs);
+        _SplitPane(*focusedTab, splitDirection, splitMode, splitSize, newTerminalArgs);
     }
 
     // Method Description:
     // - Split the focused pane of the given tab, either horizontally or vertically, and place the
     //   given TermControl into the newly created pane.
-    // - If splitType == SplitState::None, this method does nothing.
     // Arguments:
     // - tab: The tab that is going to be split.
-    // - splitType: one value from the TerminalApp::SplitState enum, indicating how the
+    // - splitDirection: one value from the TerminalApp::SplitDirection enum, indicating how the
     //   new pane should be split from its parent.
     // - splitMode: value from TerminalApp::SplitType enum, indicating the profile to be used in the newly split pane.
     // - newTerminalArgs: An object that may contain a blob of parameters to
     //   control which profile is created and with possible other
     //   configurations. See CascadiaSettings::BuildSettings for more details.
     void TerminalPage::_SplitPane(TerminalTab& tab,
-                                  const SplitState splitType,
+                                  const SplitDirection splitDirection,
                                   const SplitType splitMode,
                                   const float splitSize,
                                   const NewTerminalArgs& newTerminalArgs)
     {
-        // Do nothing if we're requesting no split.
-        if (splitType == SplitState::None)
-        {
-            return;
-        }
-
         try
         {
             TerminalSettingsCreateResult controlSettings{ nullptr };
@@ -1366,6 +1518,8 @@ namespace winrt::TerminalApp::implementation
                 profile = tab.GetFocusedProfile();
                 if (profile)
                 {
+                    // TODO GH#5047 If we cache the NewTerminalArgs, we no longer need to do this.
+                    profile = GetClosestProfileForDuplicationOfProfile(profile);
                     controlSettings = TerminalSettings::CreateWithProfile(_settings, profile, *_bindings);
                     const auto workingDirectory = tab.GetActiveTerminalControl().WorkingDirectory();
                     const auto validWorkingDirectory = !workingDirectory.empty();
@@ -1399,8 +1553,8 @@ namespace winrt::TerminalApp::implementation
             const float contentHeight = ::base::saturated_cast<float>(_tabContent.ActualHeight());
             const winrt::Windows::Foundation::Size availableSpace{ contentWidth, contentHeight };
 
-            auto realSplitType = splitType;
-            if (realSplitType == SplitState::Automatic)
+            auto realSplitType = splitDirection;
+            if (realSplitType == SplitDirection::Automatic)
             {
                 realSplitType = tab.PreCalculateAutoSplit(availableSpace);
             }
@@ -2531,13 +2685,28 @@ namespace winrt::TerminalApp::implementation
         // and wait on it hence the locking mechanism.
         if (Dispatcher().HasThreadAccess())
         {
-            // TODO: GH 9458 will give us more context so we can try to choose a better profile.
-            auto hr = _OpenNewTab(nullptr, connection);
+            try
+            {
+                NewTerminalArgs newTerminalArgs{};
+                // TODO GH#10952: When we pass the actual commandline (or originating application), the
+                // settings model can choose the right settings based on command matching, or synthesize
+                // a profile from the registry/link settings (TODO GH#9458).
+                // TODO GH#9458: Get and pass the LNK/EXE filenames.
+                // Passing in a commandline forces GetProfileForArgs to use Base Layer instead of Default Profile;
+                // in the future, it can make a better decision based on the value we pull out of the process handle.
+                // TODO GH#5047: When we hang on to the N.T.A., try not to spawn "default... .exe" :)
+                newTerminalArgs.Commandline(L"default-terminal-invocation-placeholder");
+                const auto profile{ _settings.GetProfileForArgs(newTerminalArgs) };
+                const auto settings{ TerminalSettings::CreateWithProfile(_settings, profile, *_bindings) };
 
-            // Request a summon of this window to the foreground
-            _SummonWindowRequestedHandlers(*this, nullptr);
+                _CreateNewTabWithProfileAndSettings(profile, settings, connection);
 
-            return hr;
+                // Request a summon of this window to the foreground
+                _SummonWindowRequestedHandlers(*this, nullptr);
+            }
+            CATCH_RETURN();
+
+            return S_OK;
         }
         else
         {
@@ -2545,9 +2714,8 @@ namespace winrt::TerminalApp::implementation
             HRESULT finalVal = S_OK;
 
             Dispatcher().RunAsync(CoreDispatcherPriority::Normal, [&]() {
-                finalVal = _OpenNewTab(nullptr, connection);
-
-                _SummonWindowRequestedHandlers(*this, nullptr);
+                // Re-running ourselves under the dispatcher will cause us to take the first branch above.
+                finalVal = _OnNewConnection(connection);
 
                 latch.count_down();
             });
@@ -2696,11 +2864,14 @@ namespace winrt::TerminalApp::implementation
     // Method Description:
     // - Displays a dialog stating the "Touch Keyboard and Handwriting Panel
     //   Service" is disabled.
-    void TerminalPage::ShowKeyboardServiceWarning()
+    void TerminalPage::ShowKeyboardServiceWarning() const
     {
-        if (auto keyboardWarningInfoBar = FindName(L"KeyboardWarningInfoBar").try_as<MUX::Controls::InfoBar>())
+        if (!_IsMessageDismissed(InfoBarMessage::KeyboardServiceWarning))
         {
-            keyboardWarningInfoBar.IsOpen(true);
+            if (const auto keyboardServiceWarningInfoBar = FindName(L"KeyboardServiceWarningInfoBar").try_as<MUX::Controls::InfoBar>())
+            {
+                keyboardServiceWarningInfoBar.IsOpen(true);
+            }
         }
     }
 
@@ -2920,6 +3091,11 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    void TerminalPage::SetNumberOfOpenWindows(const uint64_t num)
+    {
+        _numOpenWindows = num;
+    }
+
     // Method Description:
     // - Returns a label like "Window: 1234" for the ID of this window
     // Arguments:
@@ -3045,4 +3221,111 @@ namespace winrt::TerminalApp::implementation
     {
         return WindowName() == QuakeWindowName;
     }
+
+    // Method Description:
+    // - This function stops people from duplicating the base profile, because
+    //   it gets ~ ~ weird ~ ~ when they do. Remove when TODO GH#5047 is done.
+    Profile TerminalPage::GetClosestProfileForDuplicationOfProfile(const Profile& profile) const noexcept
+    {
+        if (profile == _settings.ProfileDefaults())
+        {
+            return _settings.FindProfile(_settings.GlobalSettings().DefaultProfile());
+        }
+        return profile;
+    }
+
+    // Method Description:
+    // - Handles the change of connection state.
+    // If the connection state is failure show information bar suggesting to configure termination behavior
+    // (unless user asked not to show this message again)
+    // Arguments:
+    // - sender: the ICoreState instance containing the connection state
+    // Return Value:
+    // - <none>
+    winrt::fire_and_forget TerminalPage::_ConnectionStateChangedHandler(const IInspectable& sender, const IInspectable& /*args*/) const
+    {
+        if (const auto coreState{ sender.try_as<winrt::Microsoft::Terminal::Control::ICoreState>() })
+        {
+            const auto newConnectionState = coreState.ConnectionState();
+            if (newConnectionState == ConnectionState::Failed && !_IsMessageDismissed(InfoBarMessage::CloseOnExitInfo))
+            {
+                co_await winrt::resume_foreground(Dispatcher());
+                if (const auto infoBar = FindName(L"CloseOnExitInfoBar").try_as<MUX::Controls::InfoBar>())
+                {
+                    infoBar.IsOpen(true);
+                }
+            }
+        }
+    }
+
+    // Method Description:
+    // - Persists the user's choice not to show information bar guiding to configure termination behavior.
+    // Then hides this information buffer.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void TerminalPage::_CloseOnExitInfoDismissHandler(const IInspectable& /*sender*/, const IInspectable& /*args*/) const
+    {
+        _DismissMessage(InfoBarMessage::CloseOnExitInfo);
+        if (const auto infoBar = FindName(L"CloseOnExitInfoBar").try_as<MUX::Controls::InfoBar>())
+        {
+            infoBar.IsOpen(false);
+        }
+    }
+
+    // Method Description:
+    // - Persists the user's choice not to show information bar warning about "Touch keyboard and Handwriting Panel Service" disabled
+    // Then hides this information buffer.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void TerminalPage::_KeyboardServiceWarningInfoDismissHandler(const IInspectable& /*sender*/, const IInspectable& /*args*/) const
+    {
+        _DismissMessage(InfoBarMessage::KeyboardServiceWarning);
+        if (const auto infoBar = FindName(L"KeyboardServiceWarningInfoBar").try_as<MUX::Controls::InfoBar>())
+        {
+            infoBar.IsOpen(false);
+        }
+    }
+
+    // Method Description:
+    // - Checks whether information bar message was dismissed earlier (in the application state)
+    // Arguments:
+    // - message: message to look for in the state
+    // Return Value:
+    // - true, if the message was dismissed
+    bool TerminalPage::_IsMessageDismissed(const InfoBarMessage& message)
+    {
+        if (const auto dismissedMessages{ ApplicationState::SharedInstance().DismissedMessages() })
+        {
+            for (const auto& dismissedMessage : dismissedMessages)
+            {
+                if (dismissedMessage == message)
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // Method Description:
+    // - Persists the user's choice to dismiss information bar message (in application state)
+    // Arguments:
+    // - message: message to dismiss
+    // Return Value:
+    // - <none>
+    void TerminalPage::_DismissMessage(const InfoBarMessage& message)
+    {
+        auto dismissedMessages = ApplicationState::SharedInstance().DismissedMessages();
+        if (!dismissedMessages)
+        {
+            dismissedMessages = winrt::single_threaded_vector<InfoBarMessage>();
+        }
+
+        dismissedMessages.Append(message);
+        ApplicationState::SharedInstance().DismissedMessages(dismissedMessages);
+    }
 }

src/cascadia/TerminalApp/TerminalPage.h

@@ -58,6 +58,8 @@ namespace winrt::TerminalApp::implementation
 
         void Create();
 
+        bool ShouldUsePersistedLayout(Microsoft::Terminal::Settings::Model::CascadiaSettings& settings) const;
+
         winrt::fire_and_forget NewTerminalByDrop(winrt::Windows::UI::Xaml::DragEventArgs& e);
 
         hstring Title();
@@ -69,7 +71,8 @@ namespace winrt::TerminalApp::implementation
         winrt::hstring ApplicationDisplayName();
         winrt::hstring ApplicationVersion();
 
-        winrt::fire_and_forget CloseWindow();
+        winrt::fire_and_forget RequestQuit();
+        winrt::fire_and_forget CloseWindow(bool bypassDialog);
 
         void ToggleFocusMode();
         void ToggleFullscreen();
@@ -79,6 +82,8 @@ namespace winrt::TerminalApp::implementation
         bool AlwaysOnTop() const;
 
         void SetStartupActions(std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs>& actions);
+        void PersistWindowLayout();
+
         void SetInboundListener(bool isEmbedding);
         static std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> ConvertExecuteCommandlineToActions(const Microsoft::Terminal::Settings::Model::ExecuteCommandlineArgs& args);
 
@@ -87,7 +92,7 @@ namespace winrt::TerminalApp::implementation
 
         winrt::TerminalApp::TaskbarState TaskbarState() const;
 
-        void ShowKeyboardServiceWarning();
+        void ShowKeyboardServiceWarning() const;
         winrt::hstring KeyboardServiceDisabledText();
 
         winrt::fire_and_forget IdentifyWindow();
@@ -104,6 +109,9 @@ namespace winrt::TerminalApp::implementation
         winrt::fire_and_forget WindowName(const winrt::hstring& value);
         uint64_t WindowId() const noexcept;
         void WindowId(const uint64_t& value);
+
+        void SetNumberOfOpenWindows(const uint64_t value);
+
         winrt::hstring WindowIdForDisplay() const noexcept;
         winrt::hstring WindowNameForDisplay() const noexcept;
         bool IsQuakeWindow() const noexcept;
@@ -124,6 +132,8 @@ namespace winrt::TerminalApp::implementation
         TYPED_EVENT(RenameWindowRequested, Windows::Foundation::IInspectable, winrt::TerminalApp::RenameWindowRequestedArgs);
         TYPED_EVENT(IsQuakeWindowChanged, IInspectable, IInspectable);
         TYPED_EVENT(SummonWindowRequested, IInspectable, IInspectable);
+        TYPED_EVENT(OpenSystemMenu, IInspectable, IInspectable);
+        TYPED_EVENT(QuitRequested, IInspectable, IInspectable);
 
     private:
         friend struct TerminalPageT<TerminalPage>; // for Xaml to bind events
@@ -155,10 +165,12 @@ namespace winrt::TerminalApp::implementation
         bool _isAlwaysOnTop{ false };
         winrt::hstring _WindowName{};
         uint64_t _WindowId{ 0 };
+        uint64_t _numOpenWindows{ 0 };
 
-        bool _rearranging;
-        std::optional<int> _rearrangeFrom;
-        std::optional<int> _rearrangeTo;
+        bool _maintainStateOnTabClose{ false };
+        bool _rearranging{ false };
+        std::optional<int> _rearrangeFrom{};
+        std::optional<int> _rearrangeTo{};
         bool _removing{ false };
 
         uint32_t _systemRowsToScroll{ DefaultRowsToScroll };
@@ -180,6 +192,7 @@ namespace winrt::TerminalApp::implementation
         std::shared_ptr<Toast> _windowRenameFailedToast{ nullptr };
 
         void _ShowAboutDialog();
+        winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowQuitDialog();
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowCloseWarningDialog();
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowCloseReadOnlyDialog();
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowMultiLinePasteWarningDialog();
@@ -220,6 +233,7 @@ namespace winrt::TerminalApp::implementation
         void _DuplicateTab(const TerminalTab& tab);
 
         void _SplitTab(TerminalTab& tab);
+        winrt::fire_and_forget _ExportTab(const TerminalTab& tab);
 
         winrt::Windows::Foundation::IAsyncAction _HandleCloseTabRequested(winrt::TerminalApp::TabBase tab);
         void _CloseTabAtIndex(uint32_t index);
@@ -255,12 +269,12 @@ namespace winrt::TerminalApp::implementation
 
         void _Scroll(ScrollDirection scrollDirection, const Windows::Foundation::IReference<uint32_t>& rowsToScroll);
 
-        void _SplitPane(const Microsoft::Terminal::Settings::Model::SplitState splitType,
+        void _SplitPane(const Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                         const Microsoft::Terminal::Settings::Model::SplitType splitMode = Microsoft::Terminal::Settings::Model::SplitType::Manual,
                         const float splitSize = 0.5f,
                         const Microsoft::Terminal::Settings::Model::NewTerminalArgs& newTerminalArgs = nullptr);
         void _SplitPane(TerminalTab& tab,
-                        const Microsoft::Terminal::Settings::Model::SplitState splitType,
+                        const Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                         const Microsoft::Terminal::Settings::Model::SplitType splitMode = Microsoft::Terminal::Settings::Model::SplitType::Manual,
                         const float splitSize = 0.5f,
                         const Microsoft::Terminal::Settings::Model::NewTerminalArgs& newTerminalArgs = nullptr);
@@ -358,6 +372,14 @@ namespace winrt::TerminalApp::implementation
 
         void _SetFocusMode(const bool inFocusMode);
 
+        winrt::Microsoft::Terminal::Settings::Model::Profile GetClosestProfileForDuplicationOfProfile(const winrt::Microsoft::Terminal::Settings::Model::Profile& profile) const noexcept;
+
+        winrt::fire_and_forget _ConnectionStateChangedHandler(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args) const;
+        void _CloseOnExitInfoDismissHandler(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args) const;
+        void _KeyboardServiceWarningInfoDismissHandler(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args) const;
+        static bool _IsMessageDismissed(const winrt::Microsoft::Terminal::Settings::Model::InfoBarMessage& message);
+        static void _DismissMessage(const winrt::Microsoft::Terminal::Settings::Model::InfoBarMessage& message);
+
 #pragma region ActionHandlers
         // These are all defined in AppActionHandlers.cpp
 #define ON_ALL_ACTIONS(action) DECLARE_ACTION_HANDLER(action);

src/cascadia/TerminalApp/TerminalPage.idl

@@ -33,6 +33,7 @@ namespace TerminalApp
         UInt64 WindowId;
         String WindowNameForDisplay { get; };
         String WindowIdForDisplay { get; };
+        void SetNumberOfOpenWindows(UInt64 num);
         void RenameFailed();
         Boolean IsQuakeWindow();
 
@@ -57,5 +58,6 @@ namespace TerminalApp
         event Windows.Foundation.TypedEventHandler<Object, RenameWindowRequestedArgs> RenameWindowRequested;
         event Windows.Foundation.TypedEventHandler<Object, Object> IsQuakeWindowChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> SummonWindowRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> OpenSystemMenu;
     }
 }

src/cascadia/TerminalApp/TerminalPage.xaml

@@ -47,6 +47,11 @@
             </StackPanel>
         </ContentDialog>
 
+        <ContentDialog x:Name="QuitDialog"
+                       x:Uid="QuitDialog"
+                       x:Load="False"
+                       DefaultButton="Primary" />
+
         <ContentDialog x:Name="CloseAllDialog"
                        x:Uid="CloseAllDialog"
                        x:Load="False"
@@ -109,13 +114,33 @@
                               PreviewKeyDown="_KeyDownHandler"
                               Visibility="Collapsed" />
 
-        <mux:InfoBar x:Name="KeyboardWarningInfoBar"
-                     x:Load="False"
-                     IsClosable="True"
-                     IsIconVisible="True"
-                     IsOpen="False"
-                     Message="{x:Bind KeyboardServiceDisabledText, Mode=OneWay}"
-                     Severity="Warning" />
+        <StackPanel>
+            <mux:InfoBar x:Name="KeyboardServiceWarningInfoBar"
+                         x:Load="False"
+                         IsClosable="True"
+                         IsIconVisible="True"
+                         IsOpen="False"
+                         Message="{x:Bind KeyboardServiceDisabledText, Mode=OneWay}"
+                         Severity="Warning">
+                <mux:InfoBar.ActionButton>
+                    <Button x:Uid="InfoBarDismissButton"
+                            Click="_KeyboardServiceWarningInfoDismissHandler" />
+                </mux:InfoBar.ActionButton>
+            </mux:InfoBar>
+
+            <mux:InfoBar x:Name="CloseOnExitInfoBar"
+                         x:Uid="CloseOnExitInfoBar"
+                         x:Load="False"
+                         IsClosable="True"
+                         IsIconVisible="True"
+                         IsOpen="False"
+                         Severity="Informational">
+                <mux:InfoBar.ActionButton>
+                    <Button x:Uid="InfoBarDismissButton"
+                            Click="_CloseOnExitInfoDismissHandler" />
+                </mux:InfoBar.ActionButton>
+            </mux:InfoBar>
+        </StackPanel>
 
         <!--
             A TeachingTip with IsLightDismissEnabled="True" will immediately

src/cascadia/TerminalApp/TerminalTab.cpp

@@ -437,6 +437,50 @@ namespace winrt::TerminalApp::implementation
         control.ScrollViewport(::base::ClampAdd(currentOffset, delta));
     }
 
+    // Method Description:
+    // - Serializes the state of this tab as a series of commands that can be
+    //   executed to recreate it.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - A vector of commands
+    std::vector<ActionAndArgs> TerminalTab::BuildStartupActions() const
+    {
+        // Give initial ids (0 for the child created with this tab,
+        // 1 for the child after the first split.
+        auto state = _rootPane->BuildStartupActions(0, 1);
+
+        ActionAndArgs newTabAction{};
+        newTabAction.Action(ShortcutAction::NewTab);
+        NewTabArgs newTabArgs{ state.firstPane->GetTerminalArgsForPane() };
+        newTabAction.Args(newTabArgs);
+
+        state.args.emplace(state.args.begin(), std::move(newTabAction));
+
+        // If we only have one arg, we only have 1 pane so we don't need any
+        // special focus logic
+        if (state.args.size() > 1 && state.focusedPaneId.has_value())
+        {
+            ActionAndArgs focusPaneAction{};
+            focusPaneAction.Action(ShortcutAction::FocusPane);
+            FocusPaneArgs focusArgs{ state.focusedPaneId.value() };
+            focusPaneAction.Args(focusArgs);
+
+            state.args.emplace_back(std::move(focusPaneAction));
+        }
+
+        if (_zoomedPane)
+        {
+            // we start without any panes zoomed so toggle zoom will enable zoom.
+            ActionAndArgs zoomPaneAction{};
+            zoomPaneAction.Action(ShortcutAction::TogglePaneZoom);
+
+            state.args.emplace_back(std::move(zoomPaneAction));
+        }
+
+        return state.args;
+    }
+
     // Method Description:
     // - Split the focused pane in our tree of panes, and place the
     //   given TermControl into the newly created pane.
@@ -446,40 +490,43 @@ namespace winrt::TerminalApp::implementation
     // - control: A TermControl to use in the new pane.
     // Return Value:
     // - <none>
-    void TerminalTab::SplitPane(SplitState splitType,
+    void TerminalTab::SplitPane(SplitDirection splitType,
                                 const float splitSize,
                                 const Profile& profile,
                                 TermControl& control)
     {
         // Make sure to take the ID before calling Split() - Split() will clear out the active pane's ID
         const auto activePaneId = _activePane->Id();
-        auto [first, second] = _activePane->Split(splitType, splitSize, profile, control);
+        // Depending on which direction will be split, the new pane can be
+        // either the first or second child, but this will always return the
+        // original pane first.
+        auto [original, newPane] = _activePane->Split(splitType, splitSize, profile, control);
         if (activePaneId)
         {
-            first->Id(activePaneId.value());
-            second->Id(_nextPaneId);
+            original->Id(activePaneId.value());
+            newPane->Id(_nextPaneId);
             ++_nextPaneId;
         }
         else
         {
-            first->Id(_nextPaneId);
+            original->Id(_nextPaneId);
             ++_nextPaneId;
-            second->Id(_nextPaneId);
+            newPane->Id(_nextPaneId);
             ++_nextPaneId;
         }
-        _activePane = first;
+        _activePane = original;
 
         // Add a event handlers to the new panes' GotFocus event. When the pane
         // gains focus, we'll mark it as the new active pane.
-        _AttachEventHandlersToControl(second->Id().value(), control);
-        _AttachEventHandlersToPane(first);
-        _AttachEventHandlersToPane(second);
+        _AttachEventHandlersToControl(newPane->Id().value(), control);
+        _AttachEventHandlersToPane(original);
+        _AttachEventHandlersToPane(newPane);
 
         // Immediately update our tracker of the focused pane now. If we're
         // splitting panes during startup (from a commandline), then it's
         // possible that the focus events won't propagate immediately. Updating
         // the focus here will give the same effect though.
-        _UpdateActivePane(second);
+        _UpdateActivePane(newPane);
     }
 
     // Method Description:
@@ -565,7 +612,7 @@ namespace winrt::TerminalApp::implementation
         const auto previousId = _activePane->Id();
 
         // Add the new pane as an automatic split on the active pane.
-        auto first = _activePane->AttachPane(pane, SplitState::Automatic);
+        auto first = _activePane->AttachPane(pane, SplitDirection::Automatic);
 
         // under current assumptions this condition should always be true.
         if (previousId)
@@ -648,26 +695,21 @@ namespace winrt::TerminalApp::implementation
     //   to the terminal when no other panes are present (GH#6219)
     bool TerminalTab::NavigateFocus(const FocusDirection& direction)
     {
-        if (direction == FocusDirection::Previous)
+        // NOTE: This _must_ be called on the root pane, so that it can propagate
+        // throughout the entire tree.
+        if (const auto newFocus = _rootPane->NavigateDirection(_activePane, direction, _mruPanes))
         {
-            if (_mruPanes.size() < 2)
+            const auto res = _rootPane->FocusPane(newFocus);
+
+            if (_zoomedPane)
             {
-                return false;
-            }
-            // To get to the previous pane, get the id of the previous pane and focus to that
-            return _rootPane->FocusPane(_mruPanes.at(1));
-        }
-        else
-        {
-            // NOTE: This _must_ be called on the root pane, so that it can propagate
-            // throughout the entire tree.
-            if (auto newFocus = _rootPane->NavigateDirection(_activePane, direction))
-            {
-                return _rootPane->FocusPane(newFocus);
+                UpdateZoom(newFocus);
             }
 
-            return false;
+            return res;
         }
+
+        return false;
     }
 
     // Method Description:
@@ -680,27 +722,11 @@ namespace winrt::TerminalApp::implementation
     // - true if two panes were swapped.
     bool TerminalTab::SwapPane(const FocusDirection& direction)
     {
-        if (direction == FocusDirection::Previous)
+        // NOTE: This _must_ be called on the root pane, so that it can propagate
+        // throughout the entire tree.
+        if (auto neighbor = _rootPane->NavigateDirection(_activePane, direction, _mruPanes))
         {
-            if (_mruPanes.size() < 2)
-            {
-                return false;
-            }
-            if (auto lastPane = _rootPane->FindPane(_mruPanes.at(1)))
-            {
-                return _rootPane->SwapPanes(_activePane, lastPane);
-            }
-        }
-        else
-        {
-            // NOTE: This _must_ be called on the root pane, so that it can propagate
-            // throughout the entire tree.
-            if (auto neighbor = _rootPane->NavigateDirection(_activePane, direction))
-            {
-                return _rootPane->SwapPanes(_activePane, neighbor);
-            }
-
-            return false;
+            return _rootPane->SwapPanes(_activePane, neighbor);
         }
 
         return false;
@@ -1211,6 +1237,23 @@ namespace winrt::TerminalApp::implementation
             splitTabMenuItem.Icon(splitTabSymbol);
         }
 
+        Controls::MenuFlyoutItem exportTabMenuItem;
+        {
+            // "Split Tab"
+            Controls::FontIcon exportTabSymbol;
+            exportTabSymbol.FontFamily(Media::FontFamily{ L"Segoe MDL2 Assets" });
+            exportTabSymbol.Glyph(L"\xE74E"); // Save
+
+            exportTabMenuItem.Click([weakThis](auto&&, auto&&) {
+                if (auto tab{ weakThis.get() })
+                {
+                    tab->_ExportTabRequestedHandlers();
+                }
+            });
+            exportTabMenuItem.Text(RS_(L"ExportTabText"));
+            exportTabMenuItem.Icon(exportTabSymbol);
+        }
+
         // Build the menu
         Controls::MenuFlyout contextMenuFlyout;
         Controls::MenuFlyoutSeparator menuSeparator;
@@ -1218,6 +1261,7 @@ namespace winrt::TerminalApp::implementation
         contextMenuFlyout.Items().Append(renameTabMenuItem);
         contextMenuFlyout.Items().Append(duplicateTabMenuItem);
         contextMenuFlyout.Items().Append(splitTabMenuItem);
+        contextMenuFlyout.Items().Append(exportTabMenuItem);
         contextMenuFlyout.Items().Append(menuSeparator);
 
         // GH#5750 - When the context menu is dismissed with ESC, toss the focus
@@ -1474,20 +1518,36 @@ namespace winrt::TerminalApp::implementation
     // Arguments:
     // - availableSpace: The theoretical space that's available for this Tab's content
     // Return Value:
-    // - The SplitState that we should use for an `Automatic` split given
+    // - The SplitDirection that we should use for an `Automatic` split given
     //   `availableSpace`
-    SplitState TerminalTab::PreCalculateAutoSplit(winrt::Windows::Foundation::Size availableSpace) const
+    SplitDirection TerminalTab::PreCalculateAutoSplit(winrt::Windows::Foundation::Size availableSpace) const
     {
-        return _rootPane->PreCalculateAutoSplit(_activePane, availableSpace).value_or(SplitState::Vertical);
+        return _rootPane->PreCalculateAutoSplit(_activePane, availableSpace).value_or(SplitDirection::Right);
     }
 
-    bool TerminalTab::PreCalculateCanSplit(SplitState splitType,
+    bool TerminalTab::PreCalculateCanSplit(SplitDirection splitType,
                                            const float splitSize,
                                            winrt::Windows::Foundation::Size availableSpace) const
     {
         return _rootPane->PreCalculateCanSplit(_activePane, splitType, splitSize, availableSpace).value_or(false);
     }
 
+    // Method Description:
+    // - Updates the zoomed pane when the focus changes
+    // Arguments:
+    // - newFocus: the new pane to be zoomed
+    // Return Value:
+    // - <none>
+    void TerminalTab::UpdateZoom(std::shared_ptr<Pane> newFocus)
+    {
+        // clear the existing content so the old zoomed pane can be added back to the root tree
+        Content(nullptr);
+        _rootPane->Restore(_zoomedPane);
+        _zoomedPane = newFocus;
+        _rootPane->Maximize(_zoomedPane);
+        Content(_zoomedPane->GetRootElement());
+    }
+
     // Method Description:
     // - Toggle our zoom state.
     //   * If we're not zoomed, then zoom the active pane, making it take the
@@ -1592,4 +1652,5 @@ namespace winrt::TerminalApp::implementation
     DEFINE_EVENT(TerminalTab, TabRaiseVisualBell, _TabRaiseVisualBellHandlers, winrt::delegate<>);
     DEFINE_EVENT(TerminalTab, DuplicateRequested, _DuplicateRequestedHandlers, winrt::delegate<>);
     DEFINE_EVENT(TerminalTab, SplitTabRequested, _SplitTabRequestedHandlers, winrt::delegate<>);
+    DEFINE_EVENT(TerminalTab, ExportTabRequested, _ExportTabRequestedHandlers, winrt::delegate<>);
 }

src/cascadia/TerminalApp/TerminalTab.h

@@ -38,7 +38,7 @@ namespace winrt::TerminalApp::implementation
         std::shared_ptr<Pane> DetachPane();
         void AttachPane(std::shared_ptr<Pane> pane);
 
-        void SplitPane(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
+        void SplitPane(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                        const float splitSize,
                        const winrt::Microsoft::Terminal::Settings::Model::Profile& profile,
                        winrt::Microsoft::Terminal::Control::TermControl& control);
@@ -51,8 +51,8 @@ namespace winrt::TerminalApp::implementation
         winrt::fire_and_forget ActivateBellIndicatorTimer();
 
         float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const;
-        winrt::Microsoft::Terminal::Settings::Model::SplitState PreCalculateAutoSplit(winrt::Windows::Foundation::Size rootSize) const;
-        bool PreCalculateCanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
+        winrt::Microsoft::Terminal::Settings::Model::SplitDirection PreCalculateAutoSplit(winrt::Windows::Foundation::Size rootSize) const;
+        bool PreCalculateCanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitDirection splitType,
                                   const float splitSize,
                                   winrt::Windows::Foundation::Size availableSpace) const;
 
@@ -79,11 +79,14 @@ namespace winrt::TerminalApp::implementation
         void ResetRuntimeTabColor();
         void ActivateColorPicker();
 
+        void UpdateZoom(std::shared_ptr<Pane> newFocus);
         void ToggleZoom();
         bool IsZoomed();
         void EnterZoom();
         void ExitZoom();
 
+        std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> BuildStartupActions() const;
+
         int GetLeafPaneCount() const noexcept;
 
         void TogglePaneReadOnly();
@@ -103,6 +106,7 @@ namespace winrt::TerminalApp::implementation
         DECLARE_EVENT(TabRaiseVisualBell, _TabRaiseVisualBellHandlers, winrt::delegate<>);
         DECLARE_EVENT(DuplicateRequested, _DuplicateRequestedHandlers, winrt::delegate<>);
         DECLARE_EVENT(SplitTabRequested, _SplitTabRequestedHandlers, winrt::delegate<>);
+        DECLARE_EVENT(ExportTabRequested, _ExportTabRequestedHandlers, winrt::delegate<>);
         TYPED_EVENT(TaskbarProgressChanged, IInspectable, IInspectable);
 
     private:

src/cascadia/TerminalApp/dll/TerminalApp.vcxproj

@@ -89,13 +89,13 @@
   </ItemGroup>
 
 
-  <Import Project="$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" />
+  <Import Project="$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('$(OpenConsoleDir)packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" />
   <Import Project="$(OpenConsoleDir)packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('$(OpenConsoleDir)packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.6.2-prerelease.210818003\build\native\Microsoft.UI.Xaml.targets'))" />
+    <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.UI.Xaml.2.5.0-prerelease.201202003\build\native\Microsoft.UI.Xaml.targets'))" />
     <Error Condition="!Exists('$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(OpenConsoleDir)\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets'))" />
   </Target>
 

src/cascadia/TerminalApp/packages.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Microsoft.Toolkit.Win32.UI.XamlApplication" version="6.1.3" targetFramework="native" />
-  <package id="Microsoft.UI.Xaml" version="2.6.2-prerelease.210818003" targetFramework="native" />
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.UI.Xaml" version="2.5.0-prerelease.201202003" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.210825.3" targetFramework="native" />
 </packages>

src/cascadia/TerminalApp/pch.h

@@ -56,6 +56,9 @@
 #include <winrt/Microsoft.Terminal.TerminalConnection.h>
 #include <winrt/Microsoft.Terminal.Settings.Editor.h>
 #include <winrt/Microsoft.Terminal.Settings.Model.h>
+#include <winrt/Windows.Storage.h>
+#include <winrt/Windows.Storage.Provider.h>
+#include <winrt/Windows.Storage.Pickers.h>
 
 #include <windows.ui.xaml.media.dxinterop.h>
 

src/cascadia/TerminalAzBridge/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.210825.3" targetFramework="native" />
 </packages>

src/cascadia/TerminalConnection/ConptyConnection.cpp

@@ -513,6 +513,16 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         }
     }
 
+    void ConptyConnection::ClearBuffer()
+    {
+        // If we haven't connected yet, then we really don't need to do
+        // anything. The connection should already start clear!
+        if (_isConnected())
+        {
+            THROW_IF_FAILED(ConptyClearPseudoConsole(_hPC.get()));
+        }
+    }
+
     void ConptyConnection::Close() noexcept
     try
     {

src/cascadia/TerminalConnection/ConptyConnection.h

@@ -35,6 +35,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         void WriteInput(hstring const& data);
         void Resize(uint32_t rows, uint32_t columns);
         void Close() noexcept;
+        void ClearBuffer();
 
         winrt::guid Guid() const noexcept;
 

src/cascadia/TerminalConnection/ConptyConnection.idl

@@ -9,6 +9,7 @@ namespace Microsoft.Terminal.TerminalConnection
     {
         ConptyConnection();
         Guid Guid { get; };
+        void ClearBuffer();
 
         static event NewConnectionHandler NewConnection;
         static void StartInboundListener();

src/cascadia/TerminalConnection/packages.config

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.210825.3" targetFramework="native" />
   <package id="vcpkg-cpprestsdk" version="2.10.14" targetFramework="native" />
 </packages>

src/cascadia/TerminalControl/ControlCore.cpp

@@ -414,6 +414,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         // This is a scroll event that wasn't initiated by the terminal
         //      itself - it was initiated by the mouse wheel, or the scrollbar.
         _terminal->UserScrollViewport(viewTop);
+
+        _updatePatternLocations->Run();
     }
 
     void ControlCore::AdjustOpacity(const double adjustment)
@@ -1497,4 +1499,63 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _updatePatternLocations->Run();
     }
 
+    // Method Description:
+    // - Clear the contents of the buffer. The region cleared is given by
+    //   clearType:
+    //   * Screen: Clear only the contents of the visible viewport, leaving the
+    //     cursor row at the top of the viewport.
+    //   * Scrollback: Clear the contents of the scrollback.
+    //   * All: Do both - clear the visible viewport and the scrollback, leaving
+    //     only the cursor row at the top of the viewport.
+    // Arguments:
+    // - clearType: The type of clear to perform.
+    // Return Value:
+    // - <none>
+    void ControlCore::ClearBuffer(Control::ClearBufferType clearType)
+    {
+        if (clearType == Control::ClearBufferType::Scrollback || clearType == Control::ClearBufferType::All)
+        {
+            _terminal->EraseInDisplay(::Microsoft::Console::VirtualTerminal::DispatchTypes::EraseType::Scrollback);
+        }
+
+        if (clearType == Control::ClearBufferType::Screen || clearType == Control::ClearBufferType::All)
+        {
+            // Send a signal to conpty to clear the buffer.
+            if (auto conpty{ _connection.try_as<TerminalConnection::ConptyConnection>() })
+            {
+                // ConPTY will emit sequences to sync up our buffer with its new
+                // contents.
+                conpty.ClearBuffer();
+            }
+        }
+    }
+
+    hstring ControlCore::ReadEntireBuffer() const
+    {
+        auto terminalLock = _terminal->LockForWriting();
+
+        const auto& textBuffer = _terminal->GetTextBuffer();
+
+        std::wstringstream ss;
+        const auto lastRow = textBuffer.GetLastNonSpaceCharacter().Y;
+        for (auto rowIndex = 0; rowIndex <= lastRow; rowIndex++)
+        {
+            const auto& row = textBuffer.GetRowByOffset(rowIndex);
+            auto rowText = row.GetText();
+            const auto strEnd = rowText.find_last_not_of(UNICODE_SPACE);
+            if (strEnd != std::string::npos)
+            {
+                rowText.erase(strEnd + 1);
+                ss << rowText;
+            }
+
+            if (!row.WasWrapForced())
+            {
+                ss << UNICODE_CARRIAGERETURN << UNICODE_LINEFEED;
+            }
+        }
+
+        return hstring(ss.str());
+    }
+
 }

src/cascadia/TerminalControl/ControlCore.h

@@ -112,6 +112,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                             const short wheelDelta,
                             const ::Microsoft::Console::VirtualTerminal::TerminalInput::MouseButtonState state);
         void UserScrollViewport(const int viewTop);
+
+        void ClearBuffer(Control::ClearBufferType clearType);
+
 #pragma endregion
 
         void BlinkAttributeTick();
@@ -144,6 +147,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         bool IsInReadOnlyMode() const;
         void ToggleReadOnlyMode();
 
+        hstring ReadEntireBuffer() const;
+
         // -------------------------------- WinRT Events ---------------------------------
         // clang-format off
         WINRT_CALLBACK(FontSizeChanged, Control::FontSizeChangedEventArgs);

src/cascadia/TerminalControl/ControlCore.idl

@@ -22,6 +22,14 @@ namespace Microsoft.Terminal.Control
         IsRightButtonDown = 0x4
     };
 
+
+    enum ClearBufferType
+    {
+        Screen,
+        Scrollback,
+        All
+    };
+
     [default_interface] runtimeclass ControlCore : ICoreState
     {
         ControlCore(IControlSettings settings,
@@ -49,6 +57,7 @@ namespace Microsoft.Terminal.Control
                            Microsoft.Terminal.Core.ControlKeyStates modifiers);
         void SendInput(String text);
         void PasteText(String text);
+        void ClearBuffer(ClearBufferType clearType);
 
         void SetHoveredCell(Microsoft.Terminal.Core.Point terminalPosition);
         void ClearHoveredCell();
@@ -81,6 +90,8 @@ namespace Microsoft.Terminal.Control
         Boolean CursorOn;
         void EnablePainting();
 
+        String ReadEntireBuffer();
+
         event FontSizeChangedEventArgs FontSizeChanged;
 
         event Windows.Foundation.TypedEventHandler<Object, CopyToClipboardEventArgs> CopyToClipboard;

src/cascadia/TerminalControl/SearchBoxControl.xaml

@@ -16,18 +16,23 @@
         <ResourceDictionary>
             <Style x:Key="ToggleButtonStyle"
                    TargetType="ToggleButton">
-                <Setter Property="Width" Value="25" />
-                <Setter Property="Height" Value="25" />
+                <Setter Property="Width" Value="24" />
+                <Setter Property="Height" Value="24" />
                 <Setter Property="Background" Value="Transparent" />
-                <Setter Property="Padding" Value="1" />
-                <Setter Property="CornerRadius" Value="2" />
+                <Setter Property="BorderBrush" Value="Transparent" />
+                <Setter Property="Padding" Value="0" />
+                <Setter Property="Margin" Value="2,0" />
+                <Setter Property="CornerRadius" Value="{ThemeResource ControlCornerRadius}" />
             </Style>
             <Style x:Key="ButtonStyle"
                    TargetType="Button">
-                <Setter Property="Width" Value="25" />
-                <Setter Property="Height" Value="25" />
+                <Setter Property="Width" Value="24" />
+                <Setter Property="Height" Value="24" />
                 <Setter Property="Background" Value="Transparent" />
-                <Setter Property="CornerRadius" Value="2" />
+                <Setter Property="BorderBrush" Value="Transparent" />
+                <Setter Property="Padding" Value="0" />
+                <Setter Property="Margin" Value="6,0,0,0" />
+                <Setter Property="CornerRadius" Value="{ThemeResource ControlCornerRadius}" />
             </Style>
             <ResourceDictionary.ThemeDictionaries>
                 <ResourceDictionary x:Key="Dark">
@@ -227,18 +232,20 @@
         </ResourceDictionary>
     </UserControl.Resources>
 
-    <StackPanel Padding="5"
-                CornerRadius="0,0,2,2"
+    <StackPanel Margin="8"
+                Padding="8"
+                CornerRadius="{ThemeResource OverlayCornerRadius}"
                 Orientation="Horizontal"
                 Style="{ThemeResource SearchBoxBackground}">
         <TextBox x:Name="TextBox"
                  x:Uid="SearchBox_TextBox"
                  Width="160"
-                 Margin="5"
+                 Margin="0,0,6,0"
                  HorizontalAlignment="Left"
                  VerticalAlignment="Center"
                  CornerRadius="2"
                  FontSize="15"
+                 IsSpellCheckEnabled="False"
                  KeyDown="TextBoxKeyDown"
                  PlaceholderForeground="{ThemeResource TextBoxPlaceholderTextThemeBrush}" />
 
@@ -269,7 +276,6 @@
 
         <Button x:Name="CloseButton"
                 x:Uid="SearchBox_Close"
-                Padding="0"
                 Click="CloseClick"
                 Style="{ThemeResource ButtonStyle}">
             <FontIcon FontFamily="Segoe MDL2 Assets"

src/cascadia/TerminalControl/TermControl.cpp

@@ -351,6 +351,10 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     {
         _core.SendInput(wstr);
     }
+    void TermControl::ClearBuffer(Control::ClearBufferType clearType)
+    {
+        _core.ClearBuffer(clearType);
+    }
 
     void TermControl::ToggleShaderEffects()
     {
@@ -2568,4 +2572,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     {
         _playWarningBell->Run();
     }
+
+    hstring TermControl::ReadEntireBuffer() const
+    {
+        return _core.ReadEntireBuffer();
+    }
 }

src/cascadia/TerminalControl/TermControl.h

@@ -63,6 +63,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         til::point GetFontSize() const;
 
         void SendInput(const winrt::hstring& input);
+        void ClearBuffer(Control::ClearBufferType clearType);
+
         void ToggleShaderEffects();
 
         winrt::fire_and_forget RenderEngineSwapChainChanged(IInspectable sender, IInspectable args);
@@ -107,6 +109,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         static unsigned int GetPointerUpdateKind(const winrt::Windows::UI::Input::PointerPoint point);
         static Windows::UI::Xaml::Thickness ParseThicknessFromPadding(const hstring padding);
 
+        hstring ReadEntireBuffer() const;
+
         // -------------------------------- WinRT Events ---------------------------------
         // clang-format off
         WINRT_CALLBACK(FontSizeChanged, Control::FontSizeChangedEventArgs);

src/cascadia/TerminalControl/TermControl.idl

@@ -6,6 +6,7 @@ import "IControlSettings.idl";
 import "IDirectKeyListener.idl";
 import "EventArgs.idl";
 import "ICoreState.idl";
+import "ControlCore.idl";
 
 namespace Microsoft.Terminal.Control
 {
@@ -46,6 +47,7 @@ namespace Microsoft.Terminal.Control
 
         Boolean CopySelectionToClipboard(Boolean singleLine, Windows.Foundation.IReference<CopyFormat> formats);
         void PasteTextFromClipboard();
+        void ClearBuffer(ClearBufferType clearType);
         void Close();
         Windows.Foundation.Size CharacterDimensions { get; };
         Windows.Foundation.Size MinimumSize { get; };
@@ -67,5 +69,7 @@ namespace Microsoft.Terminal.Control
 
         Boolean ReadOnly { get; };
         void ToggleReadOnly();
+
+        String ReadEntireBuffer();
     }
 }