diff --git a/.github/actions/spelling/allow/allow.txt b/.github/actions/spelling/allow/allow.txt
index 13e2e78ed3b..843a1ae91e6 100644
--- a/.github/actions/spelling/allow/allow.txt
+++ b/.github/actions/spelling/allow/allow.txt
@@ -95,6 +95,7 @@ slnt
 Sos
 ssh
 stakeholders
+sxn
 timeline
 timelines
 timestamped
diff --git a/.github/actions/spelling/expect/expect.txt b/.github/actions/spelling/expect/expect.txt
index 722bf19093b..626777f6bdb 100644
--- a/.github/actions/spelling/expect/expect.txt
+++ b/.github/actions/spelling/expect/expect.txt
@@ -315,6 +315,7 @@ CPLINFO
 cplusplus
 CPPCORECHECK
 cppcorecheckrules
+cpprest
 cpprestsdk
 cppwinrt
 CProc
@@ -1452,6 +1453,7 @@ PPEB
 ppf
 ppguid
 ppidl
+pplx
 PPROC
 ppropvar
 ppsi
diff --git a/src/cascadia/LocalTests_TerminalApp/pch.h b/src/cascadia/LocalTests_TerminalApp/pch.h
index 75aabc570b8..f82561888b1 100644
--- a/src/cascadia/LocalTests_TerminalApp/pch.h
+++ b/src/cascadia/LocalTests_TerminalApp/pch.h
@@ -74,3 +74,5 @@ Author(s):
 #include "../../inc/DefaultSettings.h"
 
 #include <cppwinrt_utils.h>
+
+#include <til/winrt.h>
diff --git a/src/cascadia/TerminalApp/SuggestionsControl.cpp b/src/cascadia/TerminalApp/SuggestionsControl.cpp
new file mode 100644
index 00000000000..83694267a6d
--- /dev/null
+++ b/src/cascadia/TerminalApp/SuggestionsControl.cpp
@@ -0,0 +1,1103 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "ActionPaletteItem.h"
+#include "CommandLinePaletteItem.h"
+#include "SuggestionsControl.h"
+#include <LibraryResources.h>
+
+#include "SuggestionsControl.g.cpp"
+
+using namespace winrt;
+using namespace winrt::TerminalApp;
+using namespace winrt::Windows::UI::Core;
+using namespace winrt::Windows::UI::Xaml;
+using namespace winrt::Windows::UI::Xaml::Controls;
+using namespace winrt::Windows::System;
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Windows::Foundation::Collections;
+using namespace winrt::Microsoft::Terminal::Settings::Model;
+
+namespace winrt::TerminalApp::implementation
+{
+    SuggestionsControl::SuggestionsControl()
+    {
+        InitializeComponent();
+
+        _itemTemplateSelector = Resources().Lookup(winrt::box_value(L"PaletteItemTemplateSelector")).try_as<PaletteItemTemplateSelector>();
+        _listItemTemplate = Resources().Lookup(winrt::box_value(L"ListItemTemplate")).try_as<DataTemplate>();
+
+        _filteredActions = winrt::single_threaded_observable_vector<winrt::TerminalApp::FilteredCommand>();
+        _nestedActionStack = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
+        _currentNestedCommands = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
+        _allCommands = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
+
+        _switchToMode();
+
+        // Whatever is hosting us will enable us by setting our visibility to
+        // "Visible". When that happens, set focus to our search box.
+        RegisterPropertyChangedCallback(UIElement::VisibilityProperty(), [this](auto&&, auto&&) {
+            if (Visibility() == Visibility::Visible)
+            {
+                // Force immediate binding update so we can select an item
+                Bindings->Update();
+                UpdateLayout(); // THIS ONE IN PARTICULAR SEEMS LOAD BEARING.
+                // Without the UpdateLayout call, our ListView won't have a
+                // chance to instantiate ListViewItem's. If we don't have those,
+                // then our call to `SelectedItem()` below is going to return
+                // null. If it does that, then we won't be able to focus
+                // ourselves when we're opened.
+
+                // Select the correct element in the list, depending on which
+                // direction we were opened in.
+                //
+                // Make sure to use _scrollToIndex, to move the scrollbar too!
+                if (_direction == TerminalApp::SuggestionsDirection::TopDown)
+                {
+                    _scrollToIndex(0);
+                }
+                else // BottomUp
+                {
+                    _scrollToIndex(_filteredActionsView().Items().Size() - 1);
+                }
+
+                if (_mode == SuggestionsMode::Palette)
+                {
+                    // Toss focus into the search box in palette mode
+                    _searchBox().Visibility(Visibility::Visible);
+                    _searchBox().Focus(FocusState::Programmatic);
+                }
+                else if (_mode == SuggestionsMode::Menu)
+                {
+                    // Toss focus onto the selected item in menu mode.
+                    // Don't just focus the _filteredActionsView, because that will always select the 0th element.
+
+                    _searchBox().Visibility(Visibility::Collapsed);
+
+                    if (const auto& dependencyObj = SelectedItem().try_as<winrt::Windows::UI::Xaml::DependencyObject>())
+                    {
+                        Input::FocusManager::TryFocusAsync(dependencyObj, FocusState::Programmatic);
+                    }
+                }
+
+                TraceLoggingWrite(
+                    g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
+                    "SuggestionsControlOpened",
+                    TraceLoggingDescription("Event emitted when the Command Palette is opened"),
+                    TraceLoggingWideString(L"Action", "Mode", "which mode the palette was opened in"),
+                    TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+                    TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
+            }
+            else
+            {
+                // Raise an event to return control to the Terminal.
+                _dismissPalette();
+            }
+        });
+
+        // Focusing the ListView when the Command Palette control is set to Visible
+        // for the first time fails because the ListView hasn't finished loading by
+        // the time Focus is called. Luckily, We can listen to SizeChanged to know
+        // when the ListView has been measured out and is ready, and we'll immediately
+        // revoke the handler because we only needed to handle it once on initialization.
+        _sizeChangedRevoker = _filteredActionsView().SizeChanged(winrt::auto_revoke, [this](auto /*s*/, auto /*e*/) {
+            // This does only fire once, when the size changes, which is the
+            // very first time it's opened. It does not fire for subsequent
+            // openings.
+
+            _sizeChangedRevoker.revoke();
+        });
+
+        _filteredActionsView().SelectionChanged({ this, &SuggestionsControl::_selectedCommandChanged });
+    }
+
+    TerminalApp::SuggestionsMode SuggestionsControl::Mode() const
+    {
+        return _mode;
+    }
+    void SuggestionsControl::Mode(TerminalApp::SuggestionsMode mode)
+    {
+        _mode = mode;
+
+        if (_mode == SuggestionsMode::Palette)
+        {
+            _searchBox().Visibility(Visibility::Visible);
+            _searchBox().Focus(FocusState::Programmatic);
+        }
+        else if (_mode == SuggestionsMode::Menu)
+        {
+            _searchBox().Visibility(Visibility::Collapsed);
+            _filteredActionsView().Focus(FocusState::Programmatic);
+        }
+    }
+
+    // Method Description:
+    // - Moves the focus up or down the list of commands. If we're at the top,
+    //   we'll loop around to the bottom, and vice-versa.
+    // Arguments:
+    // - moveDown: if true, we're attempting to move to the next item in the
+    //   list. Otherwise, we're attempting to move to the previous.
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::SelectNextItem(const bool moveDown)
+    {
+        auto selected = _filteredActionsView().SelectedIndex();
+        const auto numItems = ::base::saturated_cast<int>(_filteredActionsView().Items().Size());
+
+        // Do not try to select an item if
+        // - the list is empty
+        // - if no item is selected and "up" is pressed
+        if (numItems != 0 && (selected != -1 || moveDown))
+        {
+            // Wraparound math. By adding numItems and then calculating modulo numItems,
+            // we clamp the values to the range [0, numItems) while still supporting moving
+            // upward from 0 to numItems - 1.
+            const auto newIndex = ((numItems + selected + (moveDown ? 1 : -1)) % numItems);
+            _filteredActionsView().SelectedIndex(newIndex);
+            _filteredActionsView().ScrollIntoView(_filteredActionsView().SelectedItem());
+        }
+    }
+
+    // Method Description:
+    // - Scroll the command palette to the specified index
+    // Arguments:
+    // - index within a list view of commands
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_scrollToIndex(uint32_t index)
+    {
+        auto numItems = _filteredActionsView().Items().Size();
+
+        if (numItems == 0)
+        {
+            // if the list is empty no need to scroll
+            return;
+        }
+
+        auto clampedIndex = std::clamp<int32_t>(index, 0, numItems - 1);
+        _filteredActionsView().SelectedIndex(clampedIndex);
+        _filteredActionsView().ScrollIntoView(_filteredActionsView().SelectedItem());
+    }
+
+    // Method Description:
+    // - Computes the number of visible commands
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - the approximate number of items visible in the list (in other words the size of the page)
+    uint32_t SuggestionsControl::_getNumVisibleItems()
+    {
+        if (const auto container = _filteredActionsView().ContainerFromIndex(0))
+        {
+            if (const auto item = container.try_as<winrt::Windows::UI::Xaml::Controls::ListViewItem>())
+            {
+                const auto itemHeight = ::base::saturated_cast<int>(item.ActualHeight());
+                const auto listHeight = ::base::saturated_cast<int>(_filteredActionsView().ActualHeight());
+                return listHeight / itemHeight;
+            }
+        }
+        return 0;
+    }
+
+    // Method Description:
+    // - Scrolls the focus one page up the list of commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::ScrollPageUp()
+    {
+        auto selected = _filteredActionsView().SelectedIndex();
+        auto numVisibleItems = _getNumVisibleItems();
+        _scrollToIndex(selected - numVisibleItems);
+    }
+
+    // Method Description:
+    // - Scrolls the focus one page down the list of commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::ScrollPageDown()
+    {
+        auto selected = _filteredActionsView().SelectedIndex();
+        auto numVisibleItems = _getNumVisibleItems();
+        _scrollToIndex(selected + numVisibleItems);
+    }
+
+    // Method Description:
+    // - Moves the focus to the top item in the list of commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::ScrollToTop()
+    {
+        _scrollToIndex(0);
+    }
+
+    // Method Description:
+    // - Moves the focus to the bottom item in the list of commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::ScrollToBottom()
+    {
+        _scrollToIndex(_filteredActionsView().Items().Size() - 1);
+    }
+
+    Windows::UI::Xaml::FrameworkElement SuggestionsControl::SelectedItem()
+    {
+        auto index = _filteredActionsView().SelectedIndex();
+        const auto container = _filteredActionsView().ContainerFromIndex(index);
+        const auto item = container.try_as<winrt::Windows::UI::Xaml::Controls::ListViewItem>();
+        return item;
+    }
+
+    // Method Description:
+    // - Called when the command selection changes. We'll use this to preview the selected action.
+    // Arguments:
+    // - <unused>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_selectedCommandChanged(const IInspectable& /*sender*/,
+                                                     const Windows::UI::Xaml::RoutedEventArgs& /*args*/)
+    {
+        const auto selectedCommand = _filteredActionsView().SelectedItem();
+        const auto filteredCommand{ selectedCommand.try_as<winrt::TerminalApp::FilteredCommand>() };
+
+        _PropertyChangedHandlers(*this, Windows::UI::Xaml::Data::PropertyChangedEventArgs{ L"SelectedItem" });
+
+        // Make sure to not send the preview if we're collapsed. This can
+        // sometimes fire after we've been closed, which can trigger us to
+        // preview the action for the empty text (as we've cleared the search
+        // text as a part of closing).
+        const bool isVisible{ this->Visibility() == Visibility::Visible };
+
+        if (filteredCommand != nullptr &&
+            isVisible)
+        {
+            if (const auto actionPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() })
+            {
+                PreviewAction.raise(*this, actionPaletteItem.Command());
+            }
+        }
+    }
+
+    void SuggestionsControl::_previewKeyDownHandler(const IInspectable& /*sender*/,
+                                                    const Windows::UI::Xaml::Input::KeyRoutedEventArgs& e)
+    {
+        const auto key = e.OriginalKey();
+        const auto coreWindow = CoreWindow::GetForCurrentThread();
+        const auto ctrlDown = WI_IsFlagSet(coreWindow.GetKeyState(winrt::Windows::System::VirtualKey::Control), CoreVirtualKeyStates::Down);
+
+        if (key == VirtualKey::Home && ctrlDown)
+        {
+            ScrollToTop();
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::End && ctrlDown)
+        {
+            ScrollToBottom();
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::Up)
+        {
+            // Move focus to the next item in the list.
+            SelectNextItem(false);
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::Down)
+        {
+            // Move focus to the previous item in the list.
+            SelectNextItem(true);
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::PageUp)
+        {
+            // Move focus to the first visible item in the list.
+            ScrollPageUp();
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::PageDown)
+        {
+            // Move focus to the last visible item in the list.
+            ScrollPageDown();
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::Enter ||
+                 key == VirtualKey::Tab ||
+                 key == VirtualKey::Right)
+        {
+            // If the user pressed enter, tab, or the right arrow key, then
+            // we'll want to dispatch the command that's selected as they
+            // accepted the suggestion.
+
+            if (const auto& button = e.OriginalSource().try_as<Button>())
+            {
+                // Let the button handle the Enter key so an eventually attached click handler will be called
+                e.Handled(false);
+                return;
+            }
+
+            const auto selectedCommand = _filteredActionsView().SelectedItem();
+            const auto filteredCommand = selectedCommand.try_as<winrt::TerminalApp::FilteredCommand>();
+            _dispatchCommand(filteredCommand);
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::Escape)
+        {
+            // Dismiss the palette if the text is empty, otherwise clear the
+            // search string.
+            if (_searchBox().Text().empty())
+            {
+                _dismissPalette();
+            }
+            else
+            {
+                _searchBox().Text(L"");
+            }
+
+            e.Handled(true);
+        }
+
+        else if (key == VirtualKey::C && ctrlDown)
+        {
+            _searchBox().CopySelectionToClipboard();
+            e.Handled(true);
+        }
+        else if (key == VirtualKey::V && ctrlDown)
+        {
+            _searchBox().PasteFromClipboard();
+            e.Handled(true);
+        }
+
+        // If the user types a character while the menu (not in palette mode)
+        // is open, then dismiss ourselves. That way, when you type a character,
+        // we'll instead send it to the TermControl.
+        if (_mode == SuggestionsMode::Menu && !e.Handled())
+        {
+            _dismissPalette();
+        }
+    }
+
+    // Method Description:
+    // - Implements the Alt handler
+    // Return value:
+    // - whether the key was handled
+    bool SuggestionsControl::OnDirectKeyEvent(const uint32_t /*vkey*/, const uint8_t /*scanCode*/, const bool /*down*/)
+    {
+        auto handled = false;
+        return handled;
+    }
+
+    void SuggestionsControl::_keyUpHandler(const IInspectable& /*sender*/,
+                                           const Windows::UI::Xaml::Input::KeyRoutedEventArgs& /*e*/)
+    {
+    }
+
+    // Method Description:
+    // - This event is triggered when someone clicks anywhere in the bounds of
+    //   the window that's _not_ the command palette UI. When that happens,
+    //   we'll want to dismiss the palette.
+    // Arguments:
+    // - <unused>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_rootPointerPressed(const Windows::Foundation::IInspectable& /*sender*/,
+                                                 const Windows::UI::Xaml::Input::PointerRoutedEventArgs& /*e*/)
+    {
+        if (Visibility() != Visibility::Collapsed)
+        {
+            _dismissPalette();
+        }
+    }
+
+    // Method Description:
+    // - The purpose of this event handler is to hide the palette if it loses focus.
+    // We say we lost focus if our root element and all its descendants lost focus.
+    // This handler is invoked when our root element or some descendant loses focus.
+    // At this point we need to learn if the newly focused element belongs to this palette.
+    // To achieve this:
+    // - We start with the newly focused element and traverse its visual ancestors up to the Xaml root.
+    // - If one of the ancestors is this SuggestionsControl, then by our definition the focus is not lost
+    // - If we reach the Xaml root without meeting this SuggestionsControl,
+    // then the focus is not contained in it anymore and it should be dismissed
+    // Arguments:
+    // - <unused>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_lostFocusHandler(const Windows::Foundation::IInspectable& /*sender*/,
+                                               const Windows::UI::Xaml::RoutedEventArgs& /*args*/)
+    {
+        const auto flyout = _searchBox().ContextFlyout();
+        if (flyout && flyout.IsOpen())
+        {
+            return;
+        }
+
+        auto root = this->XamlRoot();
+        if (!root)
+        {
+            return;
+        }
+
+        auto focusedElementOrAncestor = Input::FocusManager::GetFocusedElement(root).try_as<DependencyObject>();
+        while (focusedElementOrAncestor)
+        {
+            if (focusedElementOrAncestor == *this)
+            {
+                // This palette is the focused element or an ancestor of the focused element. No need to dismiss.
+                return;
+            }
+
+            // Go up to the next ancestor
+            focusedElementOrAncestor = winrt::Windows::UI::Xaml::Media::VisualTreeHelper::GetParent(focusedElementOrAncestor);
+        }
+
+        // We got to the root (the element with no parent) and didn't meet this palette on the path.
+        // It means that it lost the focus and needs to be dismissed.
+        _dismissPalette();
+    }
+
+    // Method Description:
+    // - This event is only triggered when someone clicks in the space right
+    //   next to the text box in the command palette. We _don't_ want that click
+    //   to light dismiss the palette, so we'll mark it handled here.
+    // Arguments:
+    // - e: the PointerRoutedEventArgs that we want to mark as handled
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_backdropPointerPressed(const Windows::Foundation::IInspectable& /*sender*/,
+                                                     const Windows::UI::Xaml::Input::PointerRoutedEventArgs& e)
+    {
+        e.Handled(true);
+    }
+
+    // Method Description:
+    // - This event is called when the user clicks on an individual item from
+    //   the list. We'll get the item that was clicked and dispatch the command
+    //   that the user clicked on.
+    // Arguments:
+    // - e: an ItemClickEventArgs who's ClickedItem() will be the command that was clicked on.
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_listItemClicked(const Windows::Foundation::IInspectable& /*sender*/,
+                                              const Windows::UI::Xaml::Controls::ItemClickEventArgs& e)
+    {
+        const auto selectedCommand = e.ClickedItem();
+        if (const auto filteredCommand = selectedCommand.try_as<winrt::TerminalApp::FilteredCommand>())
+        {
+            _dispatchCommand(filteredCommand);
+        }
+    }
+
+    void SuggestionsControl::_listItemSelectionChanged(const Windows::Foundation::IInspectable& /*sender*/, const Windows::UI::Xaml::Controls::SelectionChangedEventArgs& e)
+    {
+        if (auto automationPeer{ Automation::Peers::FrameworkElementAutomationPeer::FromElement(_searchBox()) })
+        {
+            if (const auto selectedList = e.AddedItems(); selectedList.Size() > 0)
+            {
+                const auto selectedCommand = selectedList.GetAt(0);
+                if (const auto filteredCmd = selectedCommand.try_as<TerminalApp::FilteredCommand>())
+                {
+                    if (const auto paletteItem = filteredCmd.Item().try_as<TerminalApp::PaletteItem>())
+                    {
+                        automationPeer.RaiseNotificationEvent(
+                            Automation::Peers::AutomationNotificationKind::ItemAdded,
+                            Automation::Peers::AutomationNotificationProcessing::MostRecent,
+                            paletteItem.Name() + L" " + paletteItem.KeyChordText(),
+                            L"SuggestionsControlSelectedItemChanged" /* unique name for this notification category */);
+                    }
+                }
+            }
+        }
+    }
+
+    // Method Description:
+    // This event is called when the user clicks on a ChevronLeft button right
+    // next to the ParentCommandName (e.g. New Tab...) above the subcommands list.
+    // It'll go up a single level when the user clicks the button.
+    // Arguments:
+    // - sender: the button that got clicked
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_moveBackButtonClicked(const Windows::Foundation::IInspectable& /*sender*/,
+                                                    const Windows::UI::Xaml::RoutedEventArgs&)
+    {
+        PreviewAction.raise(*this, nullptr);
+        _searchBox().Focus(FocusState::Programmatic);
+
+        const auto previousAction{ _nestedActionStack.GetAt(_nestedActionStack.Size() - 1) };
+        _nestedActionStack.RemoveAtEnd();
+
+        // Repopulate nested commands when the root has not been reached yet
+        if (_nestedActionStack.Size() > 0)
+        {
+            const auto newPreviousAction{ _nestedActionStack.GetAt(_nestedActionStack.Size() - 1) };
+            const auto actionPaletteItem{ newPreviousAction.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() };
+
+            ParentCommandName(actionPaletteItem.Command().Name());
+            _updateCurrentNestedCommands(actionPaletteItem.Command());
+        }
+        else
+        {
+            ParentCommandName(L"");
+            _currentNestedCommands.Clear();
+        }
+        _updateFilteredActions();
+
+        const auto lastSelectedIt = std::find_if(begin(_filteredActions), end(_filteredActions), [&](const auto& filteredCommand) {
+            return filteredCommand.Item().Name() == previousAction.Item().Name();
+        });
+        const auto lastSelectedIndex = static_cast<int32_t>(std::distance(begin(_filteredActions), lastSelectedIt));
+        _scrollToIndex(lastSelectedIt != end(_filteredActions) ? lastSelectedIndex : 0);
+    }
+
+    // Method Description:
+    // - This is called when the user selects a command with subcommands. It
+    //   will update our UI to now display the list of subcommands instead, and
+    //   clear the search text so the user can search from the new list of
+    //   commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_updateUIForStackChange()
+    {
+        if (_searchBox().Text().empty())
+        {
+            // Manually call _filterTextChanged, because setting the text to the
+            // empty string won't update it for us (as it won't actually change value.)
+            _filterTextChanged(nullptr, nullptr);
+        }
+
+        // Changing the value of the search box will trigger _filterTextChanged,
+        // which will cause us to refresh the list of filterable commands.
+        _searchBox().Text(L"");
+        _searchBox().Focus(FocusState::Programmatic);
+
+        if (auto automationPeer{ Automation::Peers::FrameworkElementAutomationPeer::FromElement(_searchBox()) })
+        {
+            automationPeer.RaiseNotificationEvent(
+                Automation::Peers::AutomationNotificationKind::ActionCompleted,
+                Automation::Peers::AutomationNotificationProcessing::CurrentThenMostRecent,
+                fmt::format(std::wstring_view{ RS_(L"CommandPalette_NestedCommandAnnouncement") }, ParentCommandName()),
+                L"SuggestionsControlNestingLevelChanged" /* unique name for this notification category */);
+        }
+    }
+
+    // Method Description:
+    // - Retrieve the list of commands that we should currently be filtering.
+    //   * If the user has command with subcommands, this will return that command's subcommands.
+    //   * If we're in Tab Switcher mode, return the tab actions.
+    //   * Otherwise, just return the list of all the top-level commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - A list of Commands to filter.
+    Collections::IVector<winrt::TerminalApp::FilteredCommand> SuggestionsControl::_commandsToFilter()
+    {
+        if (_nestedActionStack.Size() > 0)
+        {
+            return _currentNestedCommands;
+        }
+
+        return _allCommands;
+    }
+
+    // Method Description:
+    // - Helper method for retrieving the action from a command the user
+    //   selected, and dispatching that command. Also fires a tracelogging event
+    //   indicating that the user successfully found the action they were
+    //   looking for.
+    // Arguments:
+    // - command: the Command to dispatch. This might be null.
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_dispatchCommand(const winrt::TerminalApp::FilteredCommand& filteredCommand)
+    {
+        if (filteredCommand)
+        {
+            if (const auto actionPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::ActionPaletteItem>() })
+            {
+                if (actionPaletteItem.Command().HasNestedCommands())
+                {
+                    // If this Command had subcommands, then don't dispatch the
+                    // action. Instead, display a new list of commands for the user
+                    // to pick from.
+                    _nestedActionStack.Append(filteredCommand);
+                    ParentCommandName(actionPaletteItem.Command().Name());
+                    _updateCurrentNestedCommands(actionPaletteItem.Command());
+
+                    _updateUIForStackChange();
+                }
+                else
+                {
+                    // First stash the search text length, because _close will clear this.
+                    const auto searchTextLength = _searchBox().Text().size();
+
+                    // An action from the root command list has depth=0
+                    const auto nestedCommandDepth = _nestedActionStack.Size();
+
+                    // Close before we dispatch so that actions that open the command
+                    // palette like the Tab Switcher will be able to have the last laugh.
+                    _close();
+
+                    // A note: the command palette ignores
+                    // "ToggleCommandPalette" actions. We may want to do the
+                    // same with "Suggestions" actions in the future, should we
+                    // ever allow non-sendInput actions.
+                    DispatchCommandRequested.raise(*this, actionPaletteItem.Command());
+
+                    TraceLoggingWrite(
+                        g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
+                        "SuggestionsControlDispatchedAction",
+                        TraceLoggingDescription("Event emitted when the user selects an action in the Command Palette"),
+                        TraceLoggingUInt32(searchTextLength, "SearchTextLength", "Number of characters in the search string"),
+                        TraceLoggingUInt32(nestedCommandDepth, "NestedCommandDepth", "the depth in the tree of commands for the dispatched action"),
+                        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+                        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
+                }
+            }
+        }
+    }
+    // Method Description:
+    // - Get all the input text in _searchBox that follows any leading spaces.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - the string of input following any number of leading spaces
+    std::wstring SuggestionsControl::_getTrimmedInput()
+    {
+        const std::wstring input{ _searchBox().Text() };
+        if (input.empty())
+        {
+            return input;
+        }
+
+        // Trim leading whitespace
+        const auto firstNonSpace = input.find_first_not_of(L" ");
+        if (firstNonSpace == std::wstring::npos)
+        {
+            // All the following characters are whitespace.
+            return L"";
+        }
+
+        return input.substr(firstNonSpace);
+    }
+
+    // Method Description:
+    // - Helper method for closing the command palette, when the user has _not_
+    //   selected an action. Also fires a tracelogging event indicating that the
+    //   user closed the palette without running a command.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_dismissPalette()
+    {
+        _close();
+
+        TraceLoggingWrite(
+            g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
+            "SuggestionsControlDismissed",
+            TraceLoggingDescription("Event emitted when the user dismisses the Command Palette without selecting an action"),
+            TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+            TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
+    }
+
+    // Method Description:
+    // - Event handler for when the text in the input box changes. In Action
+    //   Mode, we'll update the list of displayed commands, and select the first one.
+    // Arguments:
+    // - <unused>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_filterTextChanged(const IInspectable& /*sender*/,
+                                                const Windows::UI::Xaml::RoutedEventArgs& /*args*/)
+    {
+        // We're setting _lastFilterTextWasEmpty here, because if the user tries
+        // to backspace the last character in the input, the Backspace KeyDown
+        // event will fire _before_ _filterTextChanged does. Updating the value
+        // here will ensure that we can check this case appropriately.
+        _lastFilterTextWasEmpty = _searchBox().Text().empty();
+
+        _updateFilteredActions();
+
+        // In the command line mode we want the user to explicitly select the command
+        _filteredActionsView().SelectedIndex(0);
+
+        const auto currentNeedleHasResults{ _filteredActions.Size() > 0 };
+        _noMatchesText().Visibility(currentNeedleHasResults ? Visibility::Collapsed : Visibility::Visible);
+        if (auto automationPeer{ Automation::Peers::FrameworkElementAutomationPeer::FromElement(_searchBox()) })
+        {
+            automationPeer.RaiseNotificationEvent(
+                Automation::Peers::AutomationNotificationKind::ActionCompleted,
+                Automation::Peers::AutomationNotificationProcessing::ImportantMostRecent,
+                currentNeedleHasResults ?
+                    winrt::hstring{ fmt::format(std::wstring_view{ RS_(L"CommandPalette_MatchesAvailable") }, _filteredActions.Size()) } :
+                    NoMatchesText(), // what to announce if results were found
+                L"SuggestionsControlResultAnnouncement" /* unique name for this group of notifications */);
+        }
+    }
+
+    Collections::IObservableVector<winrt::TerminalApp::FilteredCommand> SuggestionsControl::FilteredActions()
+    {
+        return _filteredActions;
+    }
+
+    void SuggestionsControl::SetActionMap(const Microsoft::Terminal::Settings::Model::IActionMapView& actionMap)
+    {
+        _actionMap = actionMap;
+    }
+
+    void SuggestionsControl::SetCommands(const Collections::IVector<Command>& actions)
+    {
+        _allCommands.Clear();
+        for (const auto& action : actions)
+        {
+            auto actionPaletteItem{ winrt::make<winrt::TerminalApp::implementation::ActionPaletteItem>(action) };
+            auto filteredCommand{ winrt::make<FilteredCommand>(actionPaletteItem) };
+            _allCommands.Append(filteredCommand);
+        }
+
+        if (Visibility() == Visibility::Visible)
+        {
+            _updateFilteredActions();
+        }
+        else // THIS BRANCH IS NEW
+        {
+            auto actions = _collectFilteredActions();
+            _filteredActions.Clear();
+            for (const auto& action : actions)
+            {
+                _filteredActions.Append(action);
+            }
+        }
+    }
+
+    void SuggestionsControl::_switchToMode()
+    {
+        const auto currentlyVisible{ Visibility() == Visibility::Visible };
+
+        auto modeAnnouncementResourceKey{ USES_RESOURCE(L"CommandPaletteModeAnnouncement_ActionMode") };
+        ParsedCommandLineText(L"");
+        _searchBox().Text(L"");
+        _searchBox().Select(_searchBox().Text().size(), 0);
+
+        _nestedActionStack.Clear();
+        ParentCommandName(L"");
+        _currentNestedCommands.Clear();
+        // Leaving this block of code outside the above if-statement
+        // guarantees that the correct text is shown for the mode
+        // whenever _switchToMode is called.
+
+        SearchBoxPlaceholderText(RS_(L"CommandPalette_SearchBox/PlaceholderText"));
+        NoMatchesText(RS_(L"CommandPalette_NoMatchesText/Text"));
+        ControlName(RS_(L"CommandPaletteControlName"));
+        // modeAnnouncementResourceKey is already set to _ActionMode
+        // We did this above to deduce the type (and make it easier on ourselves later).
+
+        if (currentlyVisible)
+        {
+            if (auto automationPeer{ Automation::Peers::FrameworkElementAutomationPeer::FromElement(_searchBox()) })
+            {
+                automationPeer.RaiseNotificationEvent(
+                    Automation::Peers::AutomationNotificationKind::ActionCompleted,
+                    Automation::Peers::AutomationNotificationProcessing::CurrentThenMostRecent,
+                    GetLibraryResourceString(modeAnnouncementResourceKey),
+                    L"SuggestionsControlModeSwitch" /* unique ID for this notification */);
+            }
+        }
+
+        // The smooth remove/add animations that happen during
+        // UpdateFilteredActions don't work very well when switching between
+        // modes because of the sheer amount of remove/adds. So, let's just
+        // clear + append when switching between modes.
+        _filteredActions.Clear();
+        _updateFilteredActions();
+    }
+
+    // Method Description:
+    // - Produce a list of filtered actions to reflect the current contents of
+    //   the input box.
+    // Arguments:
+    // - A collection that will receive the filtered actions
+    // Return Value:
+    // - <none>
+    std::vector<winrt::TerminalApp::FilteredCommand> SuggestionsControl::_collectFilteredActions()
+    {
+        std::vector<winrt::TerminalApp::FilteredCommand> actions;
+
+        winrt::hstring searchText{ _getTrimmedInput() };
+
+        auto commandsToFilter = _commandsToFilter();
+
+        {
+            for (const auto& action : commandsToFilter)
+            {
+                // Update filter for all commands
+                // This will modify the highlighting but will also lead to re-computation of weight (and consequently sorting).
+                // Pay attention that it already updates the highlighting in the UI
+                action.UpdateFilter(searchText);
+
+                // if there is active search we skip commands with 0 weight
+                if (searchText.empty() || action.Weight() > 0)
+                {
+                    actions.push_back(action);
+                }
+            }
+        }
+        if (_mode == SuggestionsMode::Palette)
+        {
+            // We want to present the commands sorted
+            std::sort(actions.begin(), actions.end(), FilteredCommand::Compare);
+        }
+
+        // Adjust the order of the results depending on if we're top-down or
+        // bottom up. This way, the "first" / "best" match is always closest to
+        // the cursor.
+        if (_direction == TerminalApp::SuggestionsDirection::BottomUp)
+        {
+            // Reverse the list
+            std::reverse(std::begin(actions), std::end(actions));
+        }
+
+        return actions;
+    }
+
+    // Method Description:
+    // - Update our list of filtered actions to reflect the current contents of
+    //   the input box.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_updateFilteredActions()
+    {
+        auto actions = _collectFilteredActions();
+
+        // Make _filteredActions look identical to actions, using only Insert and Remove.
+        // This allows WinUI to nicely animate the ListView as it changes.
+        for (uint32_t i = 0; i < _filteredActions.Size() && i < actions.size(); i++)
+        {
+            for (auto j = i; j < _filteredActions.Size(); j++)
+            {
+                if (_filteredActions.GetAt(j).Item() == actions[i].Item())
+                {
+                    for (auto k = i; k < j; k++)
+                    {
+                        _filteredActions.RemoveAt(i);
+                    }
+                    break;
+                }
+            }
+
+            if (_filteredActions.GetAt(i).Item() != actions[i].Item())
+            {
+                _filteredActions.InsertAt(i, actions[i]);
+            }
+        }
+
+        // Remove any extra trailing items from the destination
+        while (_filteredActions.Size() > actions.size())
+        {
+            _filteredActions.RemoveAtEnd();
+        }
+
+        // Add any extra trailing items from the source
+        while (_filteredActions.Size() < actions.size())
+        {
+            _filteredActions.Append(actions[_filteredActions.Size()]);
+        }
+    }
+
+    // Method Description:
+    // - Update the list of current nested commands to match that of the
+    //   given parent command.
+    // Arguments:
+    // - parentCommand: the command with an optional list of nested commands.
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_updateCurrentNestedCommands(const winrt::Microsoft::Terminal::Settings::Model::Command& parentCommand)
+    {
+        _currentNestedCommands.Clear();
+        for (const auto& nameAndCommand : parentCommand.NestedCommands())
+        {
+            const auto action = nameAndCommand.Value();
+            auto nestedActionPaletteItem{ winrt::make<winrt::TerminalApp::implementation::ActionPaletteItem>(action) };
+            auto nestedFilteredCommand{ winrt::make<FilteredCommand>(nestedActionPaletteItem) };
+            _currentNestedCommands.Append(nestedFilteredCommand);
+        }
+    }
+
+    // Method Description:
+    // - Dismiss the command palette. This will:
+    //   * select all the current text in the input box
+    //   * set our visibility to Hidden
+    //   * raise our Closed event, so the page can return focus to the active Terminal
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_close()
+    {
+        Visibility(Visibility::Collapsed);
+
+        // Clear the text box each time we close the dialog. This is consistent with VsCode.
+        _searchBox().Text(L"");
+
+        _nestedActionStack.Clear();
+
+        ParentCommandName(L"");
+        _currentNestedCommands.Clear();
+
+        PreviewAction.raise(*this, nullptr);
+    }
+
+    // Method Description:
+    // - This event is triggered when filteredActionView is looking for item container (ListViewItem)
+    // to use to present the filtered actions.
+    // GH#9288: unfortunately the default lookup seems to choose items with wrong data templates,
+    // e.g., using DataTemplate rendering actions for tab palette items.
+    // We handle this event by manually selecting an item from the cache.
+    // If no item is found we allocate a new one.
+    // Arguments:
+    // - args: the ChoosingItemContainerEventArgs allowing to get container candidate suggested by the
+    // system and replace it with another candidate if required.
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_choosingItemContainer(
+        const Windows::UI::Xaml::Controls::ListViewBase& /*sender*/,
+        const Windows::UI::Xaml::Controls::ChoosingItemContainerEventArgs& args)
+    {
+        const auto dataTemplate = _itemTemplateSelector.SelectTemplate(args.Item());
+        const auto itemContainer = args.ItemContainer();
+        if (itemContainer && itemContainer.ContentTemplate() == dataTemplate)
+        {
+            // If the suggested candidate is OK simply remove it from the cache
+            // (so we won't allocate it until it is released) and return
+            _listViewItemsCache[dataTemplate].erase(itemContainer);
+        }
+        else
+        {
+            // We need another candidate, let's look it up inside the cache
+            auto& containersByTemplate = _listViewItemsCache[dataTemplate];
+            if (!containersByTemplate.empty())
+            {
+                // There cache contains available items for required DataTemplate
+                // Let's return one of them (and remove it from the cache)
+                auto firstItem = containersByTemplate.begin();
+                args.ItemContainer(*firstItem);
+                containersByTemplate.erase(firstItem);
+            }
+            else
+            {
+                ElementFactoryGetArgs factoryArgs{};
+                const auto listViewItem = _listItemTemplate.GetElement(factoryArgs).try_as<Controls::ListViewItem>();
+                listViewItem.ContentTemplate(dataTemplate);
+
+                if (dataTemplate == _itemTemplateSelector.NestedItemTemplate())
+                {
+                    const auto helpText = winrt::box_value(RS_(L"CommandPalette_MoreOptions/[using:Windows.UI.Xaml.Automation]AutomationProperties/HelpText"));
+                    listViewItem.SetValue(Automation::AutomationProperties::HelpTextProperty(), helpText);
+                }
+
+                args.ItemContainer(listViewItem);
+            }
+        }
+        args.IsContainerPrepared(true);
+    }
+    // Method Description:
+    // - This event is triggered when the data item associate with filteredActionView list item is changing.
+    //   We check if the item is being recycled. In this case we return it to the cache
+    // Arguments:
+    // - args: the ContainerContentChangingEventArgs describing the container change
+    // Return Value:
+    // - <none>
+    void SuggestionsControl::_containerContentChanging(
+        const Windows::UI::Xaml::Controls::ListViewBase& /*sender*/,
+        const Windows::UI::Xaml::Controls::ContainerContentChangingEventArgs& args)
+    {
+        const auto itemContainer = args.ItemContainer();
+        if (args.InRecycleQueue() && itemContainer && itemContainer.ContentTemplate())
+        {
+            _listViewItemsCache[itemContainer.ContentTemplate()].insert(itemContainer);
+            itemContainer.DataContext(nullptr);
+        }
+        else
+        {
+            itemContainer.DataContext(args.Item());
+        }
+    }
+
+    void SuggestionsControl::_setDirection(TerminalApp::SuggestionsDirection direction)
+    {
+        _direction = direction;
+        if (_direction == TerminalApp::SuggestionsDirection::TopDown)
+        {
+            Controls::Grid::SetRow(_searchBox(), 0);
+        }
+        else // BottomUp
+        {
+            Controls::Grid::SetRow(_searchBox(), 4);
+        }
+    }
+
+    void SuggestionsControl::Open(TerminalApp::SuggestionsMode mode,
+                                  const Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::Command>& commands,
+                                  Windows::Foundation::Point anchor,
+                                  Windows::Foundation::Size space,
+                                  float characterHeight)
+    {
+        Mode(mode);
+        SetCommands(commands);
+
+        // LOAD BEARING
+        // The control must become visible here, BEFORE we try to get its ActualWidth/Height.
+        Visibility(commands.Size() > 0 ? Visibility::Visible : Visibility::Collapsed);
+
+        _anchor = anchor;
+        _space = space;
+
+        const til::size actualSize{ til::math::rounding, ActualWidth(), ActualHeight() };
+        // Is there space in the window below the cursor to open the menu downwards?
+        const bool canOpenDownwards = (_anchor.Y + characterHeight + actualSize.height) < space.Height;
+        _setDirection(canOpenDownwards ? TerminalApp::SuggestionsDirection::TopDown :
+                                         TerminalApp::SuggestionsDirection::BottomUp);
+        // Set the anchor below by a character height
+        _anchor.Y += canOpenDownwards ? characterHeight : 0;
+
+        // First, position horizontally.
+        //
+        // We want to align the left edge of the text within the control to the
+        // cursor position. We'll need to scoot a little to the left, to align
+        // text with cursor
+        const auto proposedX = gsl::narrow_cast<int>(_anchor.X - 40);
+        // If the control is too wide to fit in the window, clamp it fit inside
+        // the window.
+        const auto maxX = gsl::narrow_cast<int>(space.Width - actualSize.width);
+        const auto clampedX = std::clamp(proposedX, 0, maxX);
+
+        // Create a thickness for the new margins
+        auto newMargin = Windows::UI::Xaml::ThicknessHelper::FromLengths(clampedX, 0, 0, 0);
+        // Now, position vertically.
+        if (_direction == TerminalApp::SuggestionsDirection::TopDown)
+        {
+            // The control should open right below the cursor, with the list
+            // extending below. This is easy, we can just use the cursor as the
+            // origin (more or less)
+            newMargin.Top = (_anchor.Y);
+        }
+        else
+        {
+            // Position at the cursor. The suggestions UI itself will maintain
+            // its own offset such that it's always above its origin
+            newMargin.Top = (_anchor.Y - actualSize.height);
+        }
+        Margin(newMargin);
+    }
+}
diff --git a/src/cascadia/TerminalApp/SuggestionsControl.h b/src/cascadia/TerminalApp/SuggestionsControl.h
new file mode 100644
index 00000000000..252332493b7
--- /dev/null
+++ b/src/cascadia/TerminalApp/SuggestionsControl.h
@@ -0,0 +1,132 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+#include "FilteredCommand.h"
+#include "SuggestionsControl.g.h"
+#include "AppCommandlineArgs.h"
+
+#include <til/hash.h>
+
+// fwdecl unittest classes
+namespace TerminalAppLocalTests
+{
+    class TabTests;
+};
+
+namespace winrt::TerminalApp::implementation
+{
+    struct SuggestionsControl : SuggestionsControlT<SuggestionsControl>
+    {
+        SuggestionsControl();
+
+        Windows::Foundation::Collections::IObservableVector<winrt::TerminalApp::FilteredCommand> FilteredActions();
+
+        void SetCommands(const Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::Command>& actions);
+        void SetActionMap(const Microsoft::Terminal::Settings::Model::IActionMapView& actionMap);
+
+        bool OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down);
+
+        void SelectNextItem(const bool moveDown);
+
+        void ScrollPageUp();
+        void ScrollPageDown();
+        void ScrollToTop();
+        void ScrollToBottom();
+
+        Windows::UI::Xaml::FrameworkElement SelectedItem();
+
+        TerminalApp::SuggestionsMode Mode() const;
+        void Mode(TerminalApp::SuggestionsMode mode);
+
+        void Open(TerminalApp::SuggestionsMode mode,
+                  const Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::Command>& commands,
+                  Windows::Foundation::Point anchor,
+                  Windows::Foundation::Size space,
+                  float characterHeight);
+
+        til::typed_event<winrt::TerminalApp::SuggestionsControl, Microsoft::Terminal::Settings::Model::Command> DispatchCommandRequested;
+        til::typed_event<Windows::Foundation::IInspectable, Microsoft::Terminal::Settings::Model::Command> PreviewAction;
+
+        WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
+        WINRT_OBSERVABLE_PROPERTY(winrt::hstring, NoMatchesText, _PropertyChangedHandlers);
+        WINRT_OBSERVABLE_PROPERTY(winrt::hstring, SearchBoxPlaceholderText, _PropertyChangedHandlers);
+        WINRT_OBSERVABLE_PROPERTY(winrt::hstring, ControlName, _PropertyChangedHandlers);
+        WINRT_OBSERVABLE_PROPERTY(winrt::hstring, ParentCommandName, _PropertyChangedHandlers);
+        WINRT_OBSERVABLE_PROPERTY(winrt::hstring, ParsedCommandLineText, _PropertyChangedHandlers);
+
+    private:
+        struct winrt_object_hash
+        {
+            size_t operator()(const auto& value) const noexcept
+            {
+                return til::hash(winrt::get_abi(value));
+            }
+        };
+        friend struct SuggestionsControlT<SuggestionsControl>; // for Xaml to bind events
+
+        Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _allCommands{ nullptr };
+        Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _currentNestedCommands{ nullptr };
+        Windows::Foundation::Collections::IObservableVector<winrt::TerminalApp::FilteredCommand> _filteredActions{ nullptr };
+        Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _nestedActionStack{ nullptr };
+
+        TerminalApp::SuggestionsMode _mode{ TerminalApp::SuggestionsMode::Palette };
+        TerminalApp::SuggestionsDirection _direction{ TerminalApp::SuggestionsDirection::TopDown };
+
+        bool _lastFilterTextWasEmpty{ true };
+        Windows::Foundation::Point _anchor;
+        Windows::Foundation::Size _space;
+
+        Microsoft::Terminal::Settings::Model::IActionMapView _actionMap{ nullptr };
+
+        winrt::Windows::UI::Xaml::Controls::ListView::SizeChanged_revoker _sizeChangedRevoker;
+
+        winrt::TerminalApp::PaletteItemTemplateSelector _itemTemplateSelector{ nullptr };
+        std::unordered_map<Windows::UI::Xaml::DataTemplate, std::unordered_set<Windows::UI::Xaml::Controls::Primitives::SelectorItem, winrt_object_hash>, winrt_object_hash> _listViewItemsCache;
+        Windows::UI::Xaml::DataTemplate _listItemTemplate;
+
+        void _switchToMode();
+        void _setDirection(TerminalApp::SuggestionsDirection direction);
+
+        void _scrollToIndex(uint32_t index);
+
+        void _updateUIForStackChange();
+        void _updateFilteredActions();
+
+        void _dispatchCommand(const winrt::TerminalApp::FilteredCommand& command);
+        void _close();
+        void _dismissPalette();
+
+        void _filterTextChanged(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs& args);
+        void _previewKeyDownHandler(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::Input::KeyRoutedEventArgs& e);
+        void _keyUpHandler(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::Input::KeyRoutedEventArgs& e);
+
+        void _rootPointerPressed(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::Input::PointerRoutedEventArgs& e);
+
+        void _lostFocusHandler(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs& args);
+        void _backdropPointerPressed(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::Input::PointerRoutedEventArgs& e);
+
+        void _listItemClicked(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::Controls::ItemClickEventArgs& e);
+        void _listItemSelectionChanged(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::Controls::SelectionChangedEventArgs& e);
+        void _selectedCommandChanged(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs& args);
+
+        void _moveBackButtonClicked(const Windows::Foundation::IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs&);
+        void _updateCurrentNestedCommands(const winrt::Microsoft::Terminal::Settings::Model::Command& parentCommand);
+
+        void _choosingItemContainer(const Windows::UI::Xaml::Controls::ListViewBase& sender, const Windows::UI::Xaml::Controls::ChoosingItemContainerEventArgs& args);
+        void _containerContentChanging(const Windows::UI::Xaml::Controls::ListViewBase& sender, const Windows::UI::Xaml::Controls::ContainerContentChangingEventArgs& args);
+
+        std::vector<winrt::TerminalApp::FilteredCommand> _collectFilteredActions();
+        Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _commandsToFilter();
+        std::wstring _getTrimmedInput();
+        uint32_t _getNumVisibleItems();
+
+        friend class TerminalAppLocalTests::TabTests;
+    };
+}
+
+namespace winrt::TerminalApp::factory_implementation
+{
+    BASIC_FACTORY(SuggestionsControl);
+}
diff --git a/src/cascadia/TerminalApp/SuggestionsControl.idl b/src/cascadia/TerminalApp/SuggestionsControl.idl
new file mode 100644
index 00000000000..a565bc3d8b6
--- /dev/null
+++ b/src/cascadia/TerminalApp/SuggestionsControl.idl
@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import "TabBase.idl";
+import "IDirectKeyListener.idl";
+import "HighlightedTextControl.idl";
+import "FilteredCommand.idl";
+
+namespace TerminalApp
+{
+
+    enum SuggestionsMode
+    {
+        Palette = 0,
+        Menu,
+        // Inline,
+    };
+
+    enum SuggestionsDirection {
+        TopDown,
+        BottomUp
+    };
+
+    [default_interface] runtimeclass SuggestionsControl : Windows.UI.Xaml.Controls.UserControl, Windows.UI.Xaml.Data.INotifyPropertyChanged, IDirectKeyListener
+    {
+        SuggestionsControl();
+
+        String NoMatchesText { get; };
+        String SearchBoxPlaceholderText { get; };
+        String ControlName { get; };
+        String ParentCommandName { get; };
+
+        Windows.UI.Xaml.FrameworkElement SelectedItem { get; };
+
+        Windows.Foundation.Collections.IObservableVector<FilteredCommand> FilteredActions { get; };
+
+        SuggestionsMode Mode { get; set; };
+
+        void SetCommands(Windows.Foundation.Collections.IVector<Microsoft.Terminal.Settings.Model.Command> actions);
+        void SetActionMap(Microsoft.Terminal.Settings.Model.IActionMapView actionMap);
+        void SelectNextItem(Boolean moveDown);
+
+        void Open(SuggestionsMode mode, IVector<Microsoft.Terminal.Settings.Model.Command> commands, Windows.Foundation.Point anchor, Windows.Foundation.Size space, Single characterHeight);
+
+        event Windows.Foundation.TypedEventHandler<SuggestionsControl, Microsoft.Terminal.Settings.Model.Command> DispatchCommandRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Microsoft.Terminal.Settings.Model.Command> PreviewAction;
+    }
+}
diff --git a/src/cascadia/TerminalApp/SuggestionsControl.xaml b/src/cascadia/TerminalApp/SuggestionsControl.xaml
new file mode 100644
index 00000000000..a59e2e342d9
--- /dev/null
+++ b/src/cascadia/TerminalApp/SuggestionsControl.xaml
@@ -0,0 +1,214 @@
+<!--
+    Copyright (c) Microsoft Corporation. All rights reserved. Licensed under
+    the MIT License. See LICENSE in the project root for license information.
+-->
+<UserControl x:Class="TerminalApp.SuggestionsControl"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:SettingsModel="using:Microsoft.Terminal.Settings.Model"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:local="using:TerminalApp"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:model="using:Microsoft.Terminal.Settings.Model"
+             xmlns:mux="using:Microsoft.UI.Xaml.Controls"
+             AllowFocusOnInteraction="True"
+             AutomationProperties.Name="{x:Bind ControlName, Mode=OneWay}"
+             IsTabStop="True"
+             LostFocus="_lostFocusHandler"
+             PointerPressed="_rootPointerPressed"
+             PreviewKeyDown="_previewKeyDownHandler"
+             PreviewKeyUp="_keyUpHandler"
+             TabNavigation="Cycle"
+             mc:Ignorable="d">
+
+    <UserControl.Resources>
+        <ResourceDictionary>
+            <local:EmptyStringVisibilityConverter x:Key="ParentCommandVisibilityConverter" />
+            <model:IconPathConverter x:Key="IconSourceConverter" />
+
+            <DataTemplate x:Key="ListItemTemplate"
+                          x:DataType="local:FilteredCommand">
+                <ListViewItem Height="32"
+                              MinHeight="0"
+                              Padding="16,0,12,0"
+                              HorizontalContentAlignment="Stretch"
+                              AutomationProperties.AcceleratorKey="{x:Bind Item.KeyChordText, Mode=OneWay}"
+                              AutomationProperties.Name="{x:Bind Item.Name, Mode=OneWay}"
+                              FontSize="12" />
+            </DataTemplate>
+
+            <DataTemplate x:Key="GeneralItemTemplate"
+                          x:DataType="local:FilteredCommand">
+                <Grid HorizontalAlignment="Stretch"
+                      ColumnSpacing="8">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="16" />
+                        <!--  icon  -->
+                        <ColumnDefinition Width="Auto" />
+                        <!--  command label  -->
+                        <ColumnDefinition Width="*" />
+                        <!--  key chord  -->
+                        <ColumnDefinition Width="16" />
+                        <!--  gutter for scrollbar  -->
+                    </Grid.ColumnDefinitions>
+
+                    <ContentPresenter Grid.Column="0"
+                                      Width="16"
+                                      Height="16"
+                                      Content="{x:Bind Item.ResolvedIcon, Mode=OneWay}" />
+
+                    <local:HighlightedTextControl Grid.Column="1"
+                                                  HorizontalAlignment="Left"
+                                                  Text="{x:Bind HighlightedName, Mode=OneWay}" />
+
+                </Grid>
+            </DataTemplate>
+
+            <DataTemplate x:Key="NestedItemTemplate"
+                          x:DataType="local:FilteredCommand">
+                <Grid HorizontalAlignment="Stretch"
+                      ColumnSpacing="8">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="16" />
+                        <!--  icon  -->
+                        <ColumnDefinition Width="Auto" />
+                        <!--  command label  -->
+                        <ColumnDefinition Width="*" />
+                        <!--  key chord  -->
+                        <ColumnDefinition Width="16" />
+                        <!--  gutter for scrollbar  -->
+                    </Grid.ColumnDefinitions>
+
+                    <ContentPresenter Grid.Column="0"
+                                      Width="16"
+                                      Height="16"
+                                      Content="{x:Bind Item.ResolvedIcon, Mode=OneWay}" />
+
+                    <local:HighlightedTextControl Grid.Column="1"
+                                                  HorizontalAlignment="Left"
+                                                  Text="{x:Bind HighlightedName, Mode=OneWay}" />
+
+                    <FontIcon Grid.Column="2"
+                              HorizontalAlignment="Right"
+                              FontFamily="{ThemeResource SymbolThemeFontFamily}"
+                              FontSize="12"
+                              Glyph="&#xE76C;" />
+
+                </Grid>
+            </DataTemplate>
+
+            <local:PaletteItemTemplateSelector x:Key="PaletteItemTemplateSelector"
+                                               GeneralItemTemplate="{StaticResource GeneralItemTemplate}"
+                                               NestedItemTemplate="{StaticResource NestedItemTemplate}" />
+
+        </ResourceDictionary>
+    </UserControl.Resources>
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="2*" />
+            <ColumnDefinition Width="6*" />
+            <ColumnDefinition Width="2*" />
+        </Grid.ColumnDefinitions>
+
+        <Grid.RowDefinitions>
+            <RowDefinition Height="8*" />
+            <RowDefinition Height="2*" />
+        </Grid.RowDefinitions>
+
+        <Grid x:Name="_backdrop"
+              Grid.Row="0"
+              Grid.RowSpan="2"
+              Grid.Column="0"
+              Grid.ColumnSpan="3"
+              MaxWidth="300"
+              MaxHeight="300"
+              Margin="0"
+              Padding="0,8,0,0"
+              HorizontalAlignment="Stretch"
+              VerticalAlignment="Stretch"
+              Background="{ThemeResource FlyoutPresenterBackground}"
+              BorderBrush="{ThemeResource FlyoutBorderThemeBrush}"
+              BorderThickness="{ThemeResource FlyoutBorderThemeThickness}"
+              CornerRadius="{ThemeResource OverlayCornerRadius}"
+              PointerPressed="_backdropPointerPressed"
+              Shadow="{StaticResource SharedShadow}"
+              Translation="0,0,32">
+
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto" />
+                <!--  Top-down _searchBox  -->
+                <RowDefinition Height="Auto" />
+                <!--  Top-down ParentCommandName  -->
+                <RowDefinition Height="Auto" />
+                <!--  Top-down UNUSED????????  -->
+                <RowDefinition Height="*" />
+                <!--  _filteredActionsView  -->
+                <RowDefinition Height="Auto" />
+                <!--  bottom-up _searchBox  -->
+            </Grid.RowDefinitions>
+
+            <TextBox x:Name="_searchBox"
+                     Grid.Row="0"
+                     Margin="8,0,8,8"
+                     Padding="18,8,8,8"
+                     IsSpellCheckEnabled="False"
+                     PlaceholderText="{x:Bind SearchBoxPlaceholderText, Mode=OneWay}"
+                     Text=""
+                     TextChanged="_filterTextChanged"
+                     Visibility="Collapsed" />
+
+            <StackPanel Grid.Row="1"
+                        Margin="8,0,8,8"
+                        Orientation="Horizontal"
+                        Visibility="{x:Bind ParentCommandName, Mode=OneWay, Converter={StaticResource ParentCommandVisibilityConverter}}">
+
+                <Button x:Name="_parentCommandBackButton"
+                        x:Uid="ParentCommandBackButton"
+                        VerticalAlignment="Center"
+                        Click="_moveBackButtonClicked"
+                        ClickMode="Press">
+                    <FontIcon FontFamily="{ThemeResource SymbolThemeFontFamily}"
+                              FontSize="11"
+                              Glyph="&#xE76b;" />
+                </Button>
+
+                <TextBlock x:Name="_parentCommandText"
+                           Padding="16,4"
+                           VerticalAlignment="Center"
+                           FontStyle="Italic"
+                           Text="{x:Bind ParentCommandName, Mode=OneWay}" />
+            </StackPanel>
+
+
+            <Border x:Name="_noMatchesText"
+                    Grid.Row="3"
+                    Height="36"
+                    Margin="8,0,8,8"
+                    Visibility="Collapsed">
+                <TextBlock Padding="12,0"
+                           VerticalAlignment="Center"
+                           FontStyle="Italic"
+                           Text="{x:Bind NoMatchesText, Mode=OneWay}" />
+            </Border>
+
+            <ListView x:Name="_filteredActionsView"
+                      Grid.Row="3"
+                      Padding="4,-2,4,6"
+                      HorizontalAlignment="Stretch"
+                      VerticalAlignment="Stretch"
+                      AllowDrop="False"
+                      CanReorderItems="False"
+                      ChoosingItemContainer="_choosingItemContainer"
+                      ContainerContentChanging="_containerContentChanging"
+                      IsItemClickEnabled="True"
+                      ItemClick="_listItemClicked"
+                      ItemsSource="{x:Bind FilteredActions}"
+                      SelectionChanged="_listItemSelectionChanged"
+                      SelectionMode="Single" />
+
+        </Grid>
+
+
+    </Grid>
+</UserControl>
diff --git a/src/cascadia/TerminalApp/TerminalAppLib.vcxproj b/src/cascadia/TerminalApp/TerminalAppLib.vcxproj
index e284d7abe2d..2b933ddfe91 100644
--- a/src/cascadia/TerminalApp/TerminalAppLib.vcxproj
+++ b/src/cascadia/TerminalApp/TerminalAppLib.vcxproj
@@ -68,6 +68,9 @@
     <Page Include="CommandPalette.xaml">
       <SubType>Designer</SubType>
     </Page>
+    <Page Include="SuggestionsControl.xaml">
+      <SubType>Designer</SubType>
+    </Page>
   </ItemGroup>
   <!-- ========================= Headers ======================== -->
   <ItemGroup>
@@ -159,6 +162,9 @@
       <DependentUpon>TerminalWindow.idl</DependentUpon>
     </ClInclude>
     <ClInclude Include="Toast.h" />
+    <ClInclude Include="SuggestionsControl.h">
+      <DependentUpon>SuggestionsControl.xaml</DependentUpon>
+    </ClInclude>
   </ItemGroup>
   <!-- ========================= Cpp Files ======================== -->
   <ItemGroup>
@@ -262,6 +268,9 @@
     </ClCompile>
     <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
     <ClCompile Include="Toast.cpp" />
+    <ClCompile Include="SuggestionsControl.cpp">
+      <DependentUpon>SuggestionsControl.xaml</DependentUpon>
+    </ClCompile>
   </ItemGroup>
   <!-- ========================= idl Files ======================== -->
   <ItemGroup>
@@ -325,6 +334,10 @@
       <DependentUpon>CommandPalette.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Midl>
+    <Midl Include="SuggestionsControl.idl">
+      <DependentUpon>SuggestionsControl.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Midl>
     <Midl Include="FilteredCommand.idl" />
     <Midl Include="EmptyStringVisibilityConverter.idl" />
   </ItemGroup>
diff --git a/src/cascadia/TerminalApp/TerminalPage.cpp b/src/cascadia/TerminalApp/TerminalPage.cpp
index 8140af22b3e..18515a8afa9 100644
--- a/src/cascadia/TerminalApp/TerminalPage.cpp
+++ b/src/cascadia/TerminalApp/TerminalPage.cpp
@@ -1466,6 +1466,11 @@ namespace winrt::TerminalApp::implementation
         {
             CommandPaletteElement().Visibility(Visibility::Collapsed);
         }
+        if (_suggestionsControlIs(Visibility::Visible) &&
+            cmd.ActionAndArgs().Action() != ShortcutAction::ToggleCommandPalette)
+        {
+            SuggestionsElement().Visibility(Visibility::Collapsed);
+        }
 
         // Let's assume the user has bound the dead key "^" to a sendInput command that sends "b".
         // If the user presses the two keys "^a" it'll produce "bâ", despite us marking the key event as handled.
@@ -1654,6 +1659,12 @@ namespace winrt::TerminalApp::implementation
 
         term.ShowWindowChanged({ get_weak(), &TerminalPage::_ShowWindowChangedHandler });
 
+        // Don't even register for the event if the feature is compiled off.
+        if constexpr (Feature_ShellCompletions::IsEnabled())
+        {
+            term.CompletionsChanged({ get_weak(), &TerminalPage::_ControlCompletionsChangedHandler });
+        }
+
         term.ContextMenu().Opening({ this, &TerminalPage::_ContextMenuOpened });
         term.SelectionContextMenu().Opening({ this, &TerminalPage::_SelectionMenuOpened });
     }
@@ -1825,6 +1836,37 @@ namespace winrt::TerminalApp::implementation
         return p;
     }
 
+    SuggestionsControl TerminalPage::LoadSuggestionsUI()
+    {
+        if (const auto p = SuggestionsElement())
+        {
+            return p;
+        }
+
+        return _loadSuggestionsElementSlowPath();
+    }
+    bool TerminalPage::_suggestionsControlIs(WUX::Visibility visibility)
+    {
+        const auto p = SuggestionsElement();
+        return p && p.Visibility() == visibility;
+    }
+
+    SuggestionsControl TerminalPage::_loadSuggestionsElementSlowPath()
+    {
+        const auto p = FindName(L"SuggestionsElement").as<SuggestionsControl>();
+
+        p.RegisterPropertyChangedCallback(UIElement::VisibilityProperty(), [this](auto&&, auto&&) {
+            if (SuggestionsElement().Visibility() == Visibility::Collapsed)
+            {
+                _FocusActiveControl(nullptr, nullptr);
+            }
+        });
+        p.DispatchCommandRequested({ this, &TerminalPage::_OnDispatchCommandRequested });
+        p.PreviewAction({ this, &TerminalPage::_PreviewActionHandler });
+
+        return p;
+    }
+
     // Method Description:
     // - Warn the user that they are about to close all open windows, then
     //   signal that we want to close everything.
@@ -2787,7 +2829,7 @@ namespace winrt::TerminalApp::implementation
     // Arguments:
     // - sender (not used)
     // - args: the arguments specifying how to set the display status to ShowWindow for our window handle
-    void TerminalPage::_ShowWindowChangedHandler(const IInspectable& /*sender*/, const Microsoft::Terminal::Control::ShowWindowArgs args)
+    void TerminalPage::_ShowWindowChangedHandler(const IInspectable /*sender*/, const Microsoft::Terminal::Control::ShowWindowArgs args)
     {
         _ShowWindowChangedHandlers(*this, args);
     }
@@ -4649,6 +4691,79 @@ namespace winrt::TerminalApp::implementation
         _updateThemeColors();
     }
 
+    winrt::fire_and_forget TerminalPage::_ControlCompletionsChangedHandler(const IInspectable sender,
+                                                                           const CompletionsChangedEventArgs args)
+    {
+        // This will come in on a background (not-UI, not output) thread.
+
+        // This won't even get hit if the velocity flag is disabled - we gate
+        // registering for the event based off of
+        // Feature_ShellCompletions::IsEnabled back in _RegisterTerminalEvents
+
+        // User must explicitly opt-in on Preview builds
+        if (!_settings.GlobalSettings().EnableShellCompletionMenu())
+        {
+            co_return;
+        }
+
+        // Parse the json string into a collection of actions
+        try
+        {
+            auto commandsCollection = Command::ParsePowerShellMenuComplete(args.MenuJson(),
+                                                                           args.ReplacementLength());
+
+            auto weakThis{ get_weak() };
+            Dispatcher().RunAsync(CoreDispatcherPriority::Normal, [weakThis, commandsCollection, sender]() {
+                // On the UI thread...
+                if (const auto& page{ weakThis.get() })
+                {
+                    // Open the Suggestions UI with the commands from the control
+                    page->_OpenSuggestions(sender.try_as<TermControl>(), commandsCollection, SuggestionsMode::Menu);
+                }
+            });
+        }
+        CATCH_LOG();
+    }
+
+    void TerminalPage::_OpenSuggestions(
+        const TermControl& sender,
+        IVector<Command> commandsCollection,
+        winrt::TerminalApp::SuggestionsMode mode)
+    {
+        // ON THE UI THREAD
+        assert(Dispatcher().HasThreadAccess());
+
+        if (commandsCollection == nullptr)
+        {
+            return;
+        }
+        if (commandsCollection.Size() == 0)
+        {
+            if (const auto p = SuggestionsElement())
+            {
+                p.Visibility(Visibility::Collapsed);
+            }
+            return;
+        }
+
+        const auto& control{ sender ? sender : _GetActiveControl() };
+        if (!control)
+        {
+            return;
+        }
+
+        const auto& sxnUi{ LoadSuggestionsUI() };
+
+        const auto characterSize{ control.CharacterDimensions() };
+        // This is in control-relative space. We'll need to convert it to page-relative space.
+        const auto cursorPos{ control.CursorPositionInDips() };
+        const auto controlTransform = control.TransformToVisual(this->Root());
+        const auto realCursorPos{ controlTransform.TransformPoint({ cursorPos.X, cursorPos.Y }) }; // == controlTransform + cursorPos
+        const Windows::Foundation::Size windowDimensions{ gsl::narrow_cast<float>(ActualWidth()), gsl::narrow_cast<float>(ActualHeight()) };
+
+        sxnUi.Open(mode, commandsCollection, realCursorPos, windowDimensions, characterSize.Height);
+    }
+
     void TerminalPage::_ContextMenuOpened(const IInspectable& sender,
                                           const IInspectable& /*args*/)
     {
diff --git a/src/cascadia/TerminalApp/TerminalPage.h b/src/cascadia/TerminalApp/TerminalPage.h
index 7a6866e20ec..e14b46fee72 100644
--- a/src/cascadia/TerminalApp/TerminalPage.h
+++ b/src/cascadia/TerminalApp/TerminalPage.h
@@ -117,6 +117,8 @@ namespace winrt::TerminalApp::implementation
         winrt::hstring ApplicationVersion();
 
         CommandPalette LoadCommandPalette();
+        SuggestionsControl LoadSuggestionsUI();
+
         winrt::fire_and_forget RequestQuit();
         winrt::fire_and_forget CloseWindow(bool bypassDialog);
 
@@ -280,6 +282,8 @@ namespace winrt::TerminalApp::implementation
 
         __declspec(noinline) CommandPalette _loadCommandPaletteSlowPath();
         bool _commandPaletteIs(winrt::Windows::UI::Xaml::Visibility visibility);
+        __declspec(noinline) SuggestionsControl _loadSuggestionsElementSlowPath();
+        bool _suggestionsControlIs(winrt::Windows::UI::Xaml::Visibility visibility);
 
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowDialogHelper(const std::wstring_view& name);
 
@@ -481,6 +485,7 @@ namespace winrt::TerminalApp::implementation
         void _RunRestorePreviews();
         void _PreviewColorScheme(const Microsoft::Terminal::Settings::Model::SetColorSchemeArgs& args);
         void _PreviewAdjustOpacity(const Microsoft::Terminal::Settings::Model::AdjustOpacityArgs& args);
+
         winrt::Microsoft::Terminal::Settings::Model::ActionAndArgs _lastPreviewedAction{ nullptr };
         std::vector<std::function<void()>> _restorePreviewFuncs{};
 
@@ -513,7 +518,11 @@ namespace winrt::TerminalApp::implementation
         void _updateAllTabCloseButtons(const winrt::TerminalApp::TabBase& focusedTab);
         void _updatePaneResources(const winrt::Windows::UI::Xaml::ElementTheme& requestedTheme);
 
-        void _ShowWindowChangedHandler(const IInspectable& sender, const winrt::Microsoft::Terminal::Control::ShowWindowArgs args);
+        winrt::fire_and_forget _ControlCompletionsChangedHandler(const winrt::Windows::Foundation::IInspectable sender, const winrt::Microsoft::Terminal::Control::CompletionsChangedEventArgs args);
+        void _OpenSuggestions(const Microsoft::Terminal::Control::TermControl& sender, Windows::Foundation::Collections::IVector<winrt::Microsoft::Terminal::Settings::Model::Command> commandsCollection, winrt::TerminalApp::SuggestionsMode mode);
+
+        void _ShowWindowChangedHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::ShowWindowArgs args);
+
         winrt::fire_and_forget _windowPropertyChanged(const IInspectable& sender, const winrt::Windows::UI::Xaml::Data::PropertyChangedEventArgs& args);
 
         void _onTabDragStarting(const winrt::Microsoft::UI::Xaml::Controls::TabView& sender, const winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs& e);
diff --git a/src/cascadia/TerminalApp/TerminalPage.xaml b/src/cascadia/TerminalApp/TerminalPage.xaml
index 00fb12f86b4..600ec505c67 100644
--- a/src/cascadia/TerminalApp/TerminalPage.xaml
+++ b/src/cascadia/TerminalApp/TerminalPage.xaml
@@ -175,6 +175,14 @@
                               PreviewKeyDown="_KeyDownHandler"
                               Visibility="Collapsed" />
 
+        <local:SuggestionsControl x:Name="SuggestionsElement"
+                                  Grid.Row="2"
+                                  HorizontalAlignment="Left"
+                                  VerticalAlignment="Top"
+                                  x:Load="False"
+                                  PreviewKeyDown="_KeyDownHandler"
+                                  Visibility="Collapsed" />
+
         <!--
             A TeachingTip with IsLightDismissEnabled="True" will immediately
             dismiss itself if the window is unfocused (In Xaml Islands). This is
diff --git a/src/cascadia/TerminalApp/pch.h b/src/cascadia/TerminalApp/pch.h
index 3d2aebf1f7d..0065e5278fc 100644
--- a/src/cascadia/TerminalApp/pch.h
+++ b/src/cascadia/TerminalApp/pch.h
@@ -84,3 +84,5 @@ TRACELOGGING_DECLARE_PROVIDER(g_hTerminalAppProvider);
 
 #include <cppwinrt_utils.h>
 #include <wil/cppwinrt_helpers.h> // must go after the CoreDispatcher type is defined
+
+#include <til/winrt.h>
diff --git a/src/cascadia/TerminalControl/ControlCore.cpp b/src/cascadia/TerminalControl/ControlCore.cpp
index 870b8f9fed5..3e4e3106d26 100644
--- a/src/cascadia/TerminalControl/ControlCore.cpp
+++ b/src/cascadia/TerminalControl/ControlCore.cpp
@@ -119,6 +119,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         auto pfnPlayMidiNote = std::bind(&ControlCore::_terminalPlayMidiNote, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
         _terminal->SetPlayMidiNoteCallback(pfnPlayMidiNote);
 
+        auto pfnCompletionsChanged = [=](auto&& menuJson, auto&& replaceLength) { _terminalCompletionsChanged(menuJson, replaceLength); };
+        _terminal->CompletionsChangedCallback(pfnCompletionsChanged);
+
         // MSFT 33353327: Initialize the renderer in the ctor instead of Initialize().
         // We need the renderer to be ready to accept new engines before the SwapChainPanel is ready to go.
         // If we wait, a screen reader may try to get the AutomationPeer (aka the UIA Engine), and we won't be able to attach
@@ -2228,6 +2231,16 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
     }
 
+    winrt::fire_and_forget ControlCore::_terminalCompletionsChanged(std::wstring_view menuJson,
+                                                                    unsigned int replaceLength)
+    {
+        auto args = winrt::make_self<CompletionsChangedEventArgs>(winrt::hstring{ menuJson },
+                                                                  replaceLength);
+
+        co_await winrt::resume_background();
+
+        _CompletionsChangedHandlers(*this, *args);
+    }
     void ControlCore::_selectSpan(til::point_span s)
     {
         const auto bufferSize{ _terminal->GetTextBuffer().GetSize() };
diff --git a/src/cascadia/TerminalControl/ControlCore.h b/src/cascadia/TerminalControl/ControlCore.h
index d26fb0ec541..eea115952f9 100644
--- a/src/cascadia/TerminalControl/ControlCore.h
+++ b/src/cascadia/TerminalControl/ControlCore.h
@@ -258,6 +258,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         TYPED_EVENT(ShowWindowChanged,         IInspectable, Control::ShowWindowArgs);
         TYPED_EVENT(UpdateSelectionMarkers,    IInspectable, Control::UpdateSelectionMarkersEventArgs);
         TYPED_EVENT(OpenHyperlink,             IInspectable, Control::OpenHyperlinkEventArgs);
+        TYPED_EVENT(CompletionsChanged,        IInspectable, Control::CompletionsChangedEventArgs);
+
         TYPED_EVENT(CloseTerminalRequested,    IInspectable, IInspectable);
         TYPED_EVENT(RestartTerminalRequested,    IInspectable, IInspectable);
 
@@ -347,6 +349,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void _terminalPlayMidiNote(const int noteNumber,
                                    const int velocity,
                                    const std::chrono::microseconds duration);
+
+        winrt::fire_and_forget _terminalCompletionsChanged(std::wstring_view menuJson, unsigned int replaceLength);
+
 #pragma endregion
 
         MidiAudio _midiAudio;
diff --git a/src/cascadia/TerminalControl/ControlCore.idl b/src/cascadia/TerminalControl/ControlCore.idl
index 3137424cfd7..8f8f87f2e4b 100644
--- a/src/cascadia/TerminalControl/ControlCore.idl
+++ b/src/cascadia/TerminalControl/ControlCore.idl
@@ -175,5 +175,8 @@ namespace Microsoft.Terminal.Control
         event Windows.Foundation.TypedEventHandler<Object, Object> RestartTerminalRequested;
 
         event Windows.Foundation.TypedEventHandler<Object, Object> Attached;
+
+        event Windows.Foundation.TypedEventHandler<Object, CompletionsChangedEventArgs> CompletionsChanged;
+
     };
 }
diff --git a/src/cascadia/TerminalControl/EventArgs.cpp b/src/cascadia/TerminalControl/EventArgs.cpp
index 12739e38867..36a9121957b 100644
--- a/src/cascadia/TerminalControl/EventArgs.cpp
+++ b/src/cascadia/TerminalControl/EventArgs.cpp
@@ -15,6 +15,7 @@
 #include "FoundResultsArgs.g.cpp"
 #include "ShowWindowArgs.g.cpp"
 #include "UpdateSelectionMarkersEventArgs.g.cpp"
+#include "CompletionsChangedEventArgs.g.cpp"
 #include "KeySentEventArgs.g.cpp"
 #include "CharSentEventArgs.g.cpp"
 #include "StringSentEventArgs.g.cpp"
diff --git a/src/cascadia/TerminalControl/EventArgs.h b/src/cascadia/TerminalControl/EventArgs.h
index d3588eea672..20cb222e008 100644
--- a/src/cascadia/TerminalControl/EventArgs.h
+++ b/src/cascadia/TerminalControl/EventArgs.h
@@ -15,6 +15,7 @@
 #include "FoundResultsArgs.g.h"
 #include "ShowWindowArgs.g.h"
 #include "UpdateSelectionMarkersEventArgs.g.h"
+#include "CompletionsChangedEventArgs.g.h"
 #include "KeySentEventArgs.g.h"
 #include "CharSentEventArgs.g.h"
 #include "StringSentEventArgs.g.h"
@@ -183,6 +184,19 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         WINRT_PROPERTY(bool, ClearMarkers, false);
     };
 
+    struct CompletionsChangedEventArgs : public CompletionsChangedEventArgsT<CompletionsChangedEventArgs>
+    {
+    public:
+        CompletionsChangedEventArgs(const winrt::hstring menuJson, const unsigned int replaceLength) :
+            _MenuJson(menuJson),
+            _ReplacementLength(replaceLength)
+        {
+        }
+
+        WINRT_PROPERTY(winrt::hstring, MenuJson, L"");
+        WINRT_PROPERTY(uint32_t, ReplacementLength, 0);
+    };
+
     struct KeySentEventArgs : public KeySentEventArgsT<KeySentEventArgs>
     {
     public:
diff --git a/src/cascadia/TerminalControl/EventArgs.idl b/src/cascadia/TerminalControl/EventArgs.idl
index 1b07517b32d..2f3c6adfefa 100644
--- a/src/cascadia/TerminalControl/EventArgs.idl
+++ b/src/cascadia/TerminalControl/EventArgs.idl
@@ -90,6 +90,12 @@ namespace Microsoft.Terminal.Control
         Boolean ClearMarkers { get; };
     }
 
+    runtimeclass CompletionsChangedEventArgs
+    {
+        String MenuJson { get; };
+        UInt32 ReplacementLength { get; };
+    }
+
     runtimeclass KeySentEventArgs
     {
         UInt16 VKey { get; };
diff --git a/src/cascadia/TerminalControl/TermControl.cpp b/src/cascadia/TerminalControl/TermControl.cpp
index aefe057a635..c82de3b3acd 100644
--- a/src/cascadia/TerminalControl/TermControl.cpp
+++ b/src/cascadia/TerminalControl/TermControl.cpp
@@ -104,6 +104,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _revokers.ConnectionStateChanged = _core.ConnectionStateChanged(winrt::auto_revoke, { get_weak(), &TermControl::_bubbleConnectionStateChanged });
         _revokers.ShowWindowChanged = _core.ShowWindowChanged(winrt::auto_revoke, { get_weak(), &TermControl::_bubbleShowWindowChanged });
         _revokers.CloseTerminalRequested = _core.CloseTerminalRequested(winrt::auto_revoke, { get_weak(), &TermControl::_bubbleCloseTerminalRequested });
+        _revokers.CompletionsChanged = _core.CompletionsChanged(winrt::auto_revoke, { get_weak(), &TermControl::_bubbleCompletionsChanged });
         _revokers.RestartTerminalRequested = _core.RestartTerminalRequested(winrt::auto_revoke, { get_weak(), &TermControl::_bubbleRestartTerminalRequested });
 
         _revokers.PasteFromClipboard = _interactivity.PasteFromClipboard(winrt::auto_revoke, { get_weak(), &TermControl::_bubblePasteFromClipboard });
@@ -2349,7 +2350,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
     // Method Description:
     // - Get the size of a single character of this control. The size is in
-    //   DIPs. If you need it in _pixels_, you'll need to multiply by the
+    //   _pixels_. If you want it in DIPs, you'll need to DIVIDE by the
     //   current display scaling.
     // Arguments:
     // - <none>
@@ -3471,6 +3472,34 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _core.ColorSelection(fg, bg, matchMode);
     }
 
+    // Returns the text cursor's position relative to our origin, in DIPs.
+    Windows::Foundation::Point TermControl::CursorPositionInDips()
+    {
+        const til::point cursorPos{ _core.CursorPosition() };
+
+        // CharacterDimensions returns a font size in pixels.
+        const auto fontSize{ CharacterDimensions() };
+
+        // Convert text buffer cursor position to client coordinate position
+        // within the window. This point is in _pixels_
+        const Windows::Foundation::Point clientCursorPos{ cursorPos.x * fontSize.Width,
+                                                          cursorPos.y * fontSize.Height };
+
+        // Get scale factor for view
+        const double scaleFactor = DisplayInformation::GetForCurrentView().RawPixelsPerViewPixel();
+
+        // Adjust to DIPs
+        const til::point clientCursorInDips{ til::math::rounding, clientCursorPos.X / scaleFactor, clientCursorPos.Y / scaleFactor };
+
+        // Account for the margins, which are in DIPs
+        auto padding{ GetPadding() };
+        til::point relativeToOrigin{ til::math::flooring,
+                                     clientCursorInDips.x + padding.Left,
+                                     clientCursorInDips.y + padding.Top };
+
+        return relativeToOrigin.to_winrt_point();
+    }
+
     void TermControl::_contextMenuHandler(IInspectable /*sender*/,
                                           Control::ContextMenuRequestedEventArgs args)
     {
diff --git a/src/cascadia/TerminalControl/TermControl.h b/src/cascadia/TerminalControl/TermControl.h
index 01f86a409aa..a11c3f7c469 100644
--- a/src/cascadia/TerminalControl/TermControl.h
+++ b/src/cascadia/TerminalControl/TermControl.h
@@ -51,6 +51,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         Windows::Foundation::Size MinimumSize();
         float SnapDimensionToGrid(const bool widthOrHeight, const float dimension);
 
+        Windows::Foundation::Point CursorPositionInDips();
+
         void WindowVisibilityChanged(const bool showOrHide);
 
         void ColorSelection(Control::SelectionColor fg, Control::SelectionColor bg, Core::MatchMode matchMode);
@@ -172,6 +174,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         BUBBLED_FORWARDED_TYPED_EVENT(ConnectionStateChanged, IInspectable, IInspectable);
         BUBBLED_FORWARDED_TYPED_EVENT(ShowWindowChanged,      IInspectable, Control::ShowWindowArgs);
         BUBBLED_FORWARDED_TYPED_EVENT(CloseTerminalRequested, IInspectable, IInspectable);
+        BUBBLED_FORWARDED_TYPED_EVENT(CompletionsChanged,     IInspectable, Control::CompletionsChangedEventArgs);
         BUBBLED_FORWARDED_TYPED_EVENT(RestartTerminalRequested, IInspectable, IInspectable);
 
         BUBBLED_FORWARDED_TYPED_EVENT(PasteFromClipboard, IInspectable, Control::PasteFromClipboardEventArgs);
@@ -394,7 +397,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             Control::ControlCore::ConnectionStateChanged_revoker ConnectionStateChanged;
             Control::ControlCore::ShowWindowChanged_revoker ShowWindowChanged;
             Control::ControlCore::CloseTerminalRequested_revoker CloseTerminalRequested;
+            Control::ControlCore::CompletionsChanged_revoker CompletionsChanged;
             Control::ControlCore::RestartTerminalRequested_revoker RestartTerminalRequested;
+
             // These are set up in _InitializeTerminal
             Control::ControlCore::RendererWarning_revoker RendererWarning;
             Control::ControlCore::SwapChainChanged_revoker SwapChainChanged;
diff --git a/src/cascadia/TerminalControl/TermControl.idl b/src/cascadia/TerminalControl/TermControl.idl
index ad881f233f9..11b47d8de35 100644
--- a/src/cascadia/TerminalControl/TermControl.idl
+++ b/src/cascadia/TerminalControl/TermControl.idl
@@ -53,10 +53,14 @@ namespace Microsoft.Terminal.Control
         event Windows.Foundation.TypedEventHandler<Object, Object> TabColorChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> ReadOnlyChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> FocusFollowMouseRequested;
+
+        event Windows.Foundation.TypedEventHandler<Object, CompletionsChangedEventArgs> CompletionsChanged;
+
         event Windows.Foundation.TypedEventHandler<Object, KeySentEventArgs> KeySent;
         event Windows.Foundation.TypedEventHandler<Object, CharSentEventArgs> CharSent;
         event Windows.Foundation.TypedEventHandler<Object, StringSentEventArgs> StringSent;
 
+
         Microsoft.UI.Xaml.Controls.CommandBarFlyout ContextMenu { get; };
         Microsoft.UI.Xaml.Controls.CommandBarFlyout SelectionContextMenu { get; };
 
@@ -123,6 +127,8 @@ namespace Microsoft.Terminal.Control
 
         void ColorSelection(SelectionColor fg, SelectionColor bg, Microsoft.Terminal.Core.MatchMode matchMode);
 
+        Windows.Foundation.Point CursorPositionInDips { get; };
+
         void ShowContextMenu();
 
         void Detach();
diff --git a/src/cascadia/TerminalCore/Terminal.cpp b/src/cascadia/TerminalCore/Terminal.cpp
index d475966350e..f2fdd3ecf11 100644
--- a/src/cascadia/TerminalCore/Terminal.cpp
+++ b/src/cascadia/TerminalCore/Terminal.cpp
@@ -1259,6 +1259,11 @@ const size_t Microsoft::Terminal::Core::Terminal::GetTaskbarProgress() const noe
     return _taskbarProgress;
 }
 
+void Microsoft::Terminal::Core::Terminal::CompletionsChangedCallback(std::function<void(std::wstring_view, unsigned int)> pfn) noexcept
+{
+    _pfnCompletionsChanged.swap(pfn);
+}
+
 Scheme Terminal::GetColorScheme() const
 {
     Scheme s;
diff --git a/src/cascadia/TerminalCore/Terminal.hpp b/src/cascadia/TerminalCore/Terminal.hpp
index fc392bc7e0c..c13fc7f0411 100644
--- a/src/cascadia/TerminalCore/Terminal.hpp
+++ b/src/cascadia/TerminalCore/Terminal.hpp
@@ -136,6 +136,9 @@ class Microsoft::Terminal::Core::Terminal final :
     bool IsVtInputEnabled() const noexcept override;
     void NotifyAccessibilityChange(const til::rect& changedRect) noexcept override;
     void NotifyBufferRotation(const int delta) override;
+
+    void InvokeCompletions(std::wstring_view menuJson, unsigned int replaceLength) override;
+
 #pragma endregion
 
     void ClearMark();
@@ -209,6 +212,7 @@ class Microsoft::Terminal::Core::Terminal final :
     void TaskbarProgressChangedCallback(std::function<void()> pfn) noexcept;
     void SetShowWindowCallback(std::function<void(bool)> pfn) noexcept;
     void SetPlayMidiNoteCallback(std::function<void(const int, const int, const std::chrono::microseconds)> pfn) noexcept;
+    void CompletionsChangedCallback(std::function<void(std::wstring_view, unsigned int)> pfn) noexcept;
 
     void SetCursorOn(const bool isOn);
     bool IsCursorBlinkingAllowed() const noexcept;
@@ -306,6 +310,7 @@ class Microsoft::Terminal::Core::Terminal final :
     std::function<void()> _pfnTaskbarProgressChanged;
     std::function<void(bool)> _pfnShowWindowChanged;
     std::function<void(const int, const int, const std::chrono::microseconds)> _pfnPlayMidiNote;
+    std::function<void(std::wstring_view, unsigned int)> _pfnCompletionsChanged;
 
     RenderSettings _renderSettings;
     std::unique_ptr<::Microsoft::Console::VirtualTerminal::StateMachine> _stateMachine;
diff --git a/src/cascadia/TerminalCore/TerminalApi.cpp b/src/cascadia/TerminalCore/TerminalApi.cpp
index a32a1ddb496..e19f158adf8 100644
--- a/src/cascadia/TerminalCore/TerminalApi.cpp
+++ b/src/cascadia/TerminalCore/TerminalApi.cpp
@@ -431,6 +431,14 @@ void Terminal::NotifyAccessibilityChange(const til::rect& /*changedRect*/) noexc
     // This is only needed in conhost. Terminal handles accessibility in another way.
 }
 
+void Terminal::InvokeCompletions(std::wstring_view menuJson, unsigned int replaceLength)
+{
+    if (_pfnCompletionsChanged)
+    {
+        _pfnCompletionsChanged(menuJson, replaceLength);
+    }
+}
+
 void Terminal::NotifyBufferRotation(const int delta)
 {
     // Update our selection, so it doesn't move as the buffer is cycled
diff --git a/src/cascadia/TerminalSettingsModel/Command.cpp b/src/cascadia/TerminalSettingsModel/Command.cpp
index beea1edfed8..e2eec5c95b0 100644
--- a/src/cascadia/TerminalSettingsModel/Command.cpp
+++ b/src/cascadia/TerminalSettingsModel/Command.cpp
@@ -632,4 +632,102 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
 
         return newCommands;
     }
+
+    winrt::Windows::Foundation::Collections::IVector<Model::Command> Command::ParsePowerShellMenuComplete(winrt::hstring json, int32_t replaceLength)
+    {
+        if (json.empty())
+        {
+            return nullptr;
+        }
+        auto data = winrt::to_string(json);
+
+        std::string errs;
+        static std::unique_ptr<Json::CharReader> reader{ Json::CharReaderBuilder{}.newCharReader() };
+        Json::Value root;
+        if (!reader->parse(data.data(), data.data() + data.size(), &root, &errs))
+        {
+            throw winrt::hresult_error(WEB_E_INVALID_JSON_STRING, winrt::to_hstring(errs));
+        }
+
+        std::vector<Model::Command> result;
+
+        const auto parseElement = [&](const auto& element) {
+            winrt::hstring completionText;
+            winrt::hstring listText;
+            JsonUtils::GetValueForKey(element, "CompletionText", completionText);
+            JsonUtils::GetValueForKey(element, "ListItemText", listText);
+
+            auto args = winrt::make_self<SendInputArgs>(
+                winrt::hstring{ fmt::format(FMT_COMPILE(L"{:\x7f^{}}{}"),
+                                            L"",
+                                            replaceLength,
+                                            static_cast<std::wstring_view>(completionText)) });
+
+            Model::ActionAndArgs actionAndArgs{ ShortcutAction::SendInput, *args };
+
+            auto c = winrt::make_self<Command>();
+            c->_name = listText;
+            c->_ActionAndArgs = actionAndArgs;
+
+            // Try to assign a sensible icon based on the result type. These are
+            // roughly chosen to align with the icons in
+            // https://github.com/PowerShell/PowerShellEditorServices/pull/1738
+            // as best as possible.
+            if (const auto resultType{ JsonUtils::GetValueForKey<int>(element, "ResultType") })
+            {
+                // PowerShell completion result -> Segoe Fluent icon value & name
+                switch (resultType)
+                {
+                case 1: // History          -> 0xe81c History
+                    c->_iconPath = L"\ue81c";
+                    break;
+                case 2: // Command          -> 0xecaa AppIconDefault
+                    c->_iconPath = L"\uecaa";
+                    break;
+                case 3: // ProviderItem     -> 0xe8e4 AlignLeft
+                    c->_iconPath = L"\ue8e4";
+                    break;
+                case 4: // ProviderContainer  -> 0xe838 FolderOpen
+                    c->_iconPath = L"\ue838";
+                    break;
+                case 5: // Property         -> 0xe7c1 Flag
+                    c->_iconPath = L"\ue7c1";
+                    break;
+                case 6: // Method           -> 0xecaa AppIconDefault
+                    c->_iconPath = L"\uecaa";
+                    break;
+                case 7: // ParameterName    -> 0xe7c1 Flag
+                    c->_iconPath = L"\ue7c1";
+                    break;
+                case 8: // ParameterValue   -> 0xf000 KnowledgeArticle
+                    c->_iconPath = L"\uf000";
+                    break;
+                case 10: // Namespace       -> 0xe943 Code
+                    c->_iconPath = L"\ue943";
+                    break;
+                case 13: // DynamicKeyword  -> 0xe945 LightningBolt
+                    c->_iconPath = L"\ue945";
+                    break;
+                }
+            }
+
+            result.push_back(*c);
+        };
+
+        if (root.isArray())
+        {
+            // If we got a whole array of suggestions, parse each one.
+            for (const auto& element : root)
+            {
+                parseElement(element);
+            }
+        }
+        else if (root.isObject())
+        {
+            // If we instead only got a single element back, just parse the root element.
+            parseElement(root);
+        }
+
+        return winrt::single_threaded_vector<Model::Command>(std::move(result));
+    }
 }
diff --git a/src/cascadia/TerminalSettingsModel/Command.h b/src/cascadia/TerminalSettingsModel/Command.h
index 49316d19513..b001c795671 100644
--- a/src/cascadia/TerminalSettingsModel/Command.h
+++ b/src/cascadia/TerminalSettingsModel/Command.h
@@ -66,6 +66,8 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         hstring IconPath() const noexcept;
         void IconPath(const hstring& val);
 
+        static Windows::Foundation::Collections::IVector<Model::Command> ParsePowerShellMenuComplete(winrt::hstring json, int32_t replaceLength);
+
         WINRT_PROPERTY(ExpandCommandType, IterateOn, ExpandCommandType::None);
         WINRT_PROPERTY(Model::ActionAndArgs, ActionAndArgs);
 
diff --git a/src/cascadia/TerminalSettingsModel/Command.idl b/src/cascadia/TerminalSettingsModel/Command.idl
index e582d8846cd..934df64d6cb 100644
--- a/src/cascadia/TerminalSettingsModel/Command.idl
+++ b/src/cascadia/TerminalSettingsModel/Command.idl
@@ -45,5 +45,7 @@ namespace Microsoft.Terminal.Settings.Model
 
         Boolean HasNestedCommands { get; };
         Windows.Foundation.Collections.IMapView<String, Command> NestedCommands { get; };
+
+        static IVector<Command> ParsePowerShellMenuComplete(String json, Int32 replaceLength);
     }
 }
diff --git a/src/cascadia/TerminalSettingsModel/GlobalAppSettings.idl b/src/cascadia/TerminalSettingsModel/GlobalAppSettings.idl
index 14adf38112a..02b3788b1ed 100644
--- a/src/cascadia/TerminalSettingsModel/GlobalAppSettings.idl
+++ b/src/cascadia/TerminalSettingsModel/GlobalAppSettings.idl
@@ -98,6 +98,7 @@ namespace Microsoft.Terminal.Settings.Model
         INHERITABLE_SETTING(Boolean, ShowAdminShield);
         INHERITABLE_SETTING(IVector<NewTabMenuEntry>, NewTabMenu);
         INHERITABLE_SETTING(Boolean, EnableColorSelection);
+        INHERITABLE_SETTING(Boolean, EnableShellCompletionMenu);
         INHERITABLE_SETTING(Boolean, IsolatedMode);
         INHERITABLE_SETTING(Boolean, AllowHeadless);
         INHERITABLE_SETTING(String, SearchWebDefaultQueryUrl);
diff --git a/src/cascadia/TerminalSettingsModel/MTSMSettings.h b/src/cascadia/TerminalSettingsModel/MTSMSettings.h
index 367bf389fc6..44c19aec22d 100644
--- a/src/cascadia/TerminalSettingsModel/MTSMSettings.h
+++ b/src/cascadia/TerminalSettingsModel/MTSMSettings.h
@@ -63,6 +63,7 @@ Author(s):
     X(bool, ShowAdminShield, "showAdminShield", true)                                                                                                                                                 \
     X(bool, TrimPaste, "trimPaste", true)                                                                                                                                                             \
     X(bool, EnableColorSelection, "experimental.enableColorSelection", false)                                                                                                                         \
+    X(bool, EnableShellCompletionMenu, "experimental.enableShellCompletionMenu", false)                                                                                                               \
     X(winrt::Windows::Foundation::Collections::IVector<Model::NewTabMenuEntry>, NewTabMenu, "newTabMenu", winrt::single_threaded_vector<Model::NewTabMenuEntry>({ Model::RemainingProfilesEntry{} })) \
     X(bool, AllowHeadless, "compatibility.allowHeadless", false)                                                                                                                                      \
     X(bool, IsolatedMode, "compatibility.isolatedMode", false)                                                                                                                                        \
diff --git a/src/features.xml b/src/features.xml
index adb444b65fb..121076d259f 100644
--- a/src/features.xml
+++ b/src/features.xml
@@ -163,6 +163,17 @@
         </alwaysEnabledBrandingTokens>
     </feature>
 
+    <feature>
+        <name>Feature_ShellCompletions</name>
+        <description>An experimental escape sequence for client applications to request the Terminal display a list of suggestions.</description>
+        <id>3121</id>
+        <stage>AlwaysDisabled</stage>
+        <alwaysEnabledBrandingTokens>
+            <brandingToken>Dev</brandingToken>
+            <brandingToken>Preview</brandingToken>
+        </alwaysEnabledBrandingTokens>
+    </feature>
+
     <feature>
         <name>Feature_VtChecksumReport</name>
         <description>Enables the DECRQCRA checksum report, which can be used to read the screen contents</description>
diff --git a/src/host/outputStream.cpp b/src/host/outputStream.cpp
index e20f1e73f99..3d5bb7a5f81 100644
--- a/src/host/outputStream.cpp
+++ b/src/host/outputStream.cpp
@@ -454,3 +454,7 @@ void ConhostInternalGetSet::MarkCommandFinish(std::optional<unsigned int> /*erro
 {
     // Not implemented for conhost.
 }
+void ConhostInternalGetSet::InvokeCompletions(std::wstring_view /*menuJson*/, unsigned int /*replaceLength*/)
+{
+    // Not implemented for conhost.
+}
diff --git a/src/host/outputStream.hpp b/src/host/outputStream.hpp
index 4a271685541..45ea6052e21 100644
--- a/src/host/outputStream.hpp
+++ b/src/host/outputStream.hpp
@@ -74,6 +74,8 @@ class ConhostInternalGetSet final : public Microsoft::Console::VirtualTerminal::
     void MarkOutputStart() override;
     void MarkCommandFinish(std::optional<unsigned int> error) override;
 
+    void InvokeCompletions(std::wstring_view menuJson, unsigned int replaceLength) override;
+
 private:
     Microsoft::Console::IIoProvider& _io;
 };
diff --git a/src/terminal/adapter/ITermDispatch.hpp b/src/terminal/adapter/ITermDispatch.hpp
index 7b8cf9d7a57..9221ea3cb4f 100644
--- a/src/terminal/adapter/ITermDispatch.hpp
+++ b/src/terminal/adapter/ITermDispatch.hpp
@@ -137,6 +137,8 @@ class Microsoft::Console::VirtualTerminal::ITermDispatch
 
     virtual bool DoFinalTermAction(const std::wstring_view string) = 0;
 
+    virtual bool DoVsCodeAction(const std::wstring_view string) = 0;
+
     virtual StringHandler DownloadDRCS(const VTInt fontNumber,
                                        const VTParameter startChar,
                                        const DispatchTypes::DrcsEraseControl eraseControl,
diff --git a/src/terminal/adapter/ITerminalApi.hpp b/src/terminal/adapter/ITerminalApi.hpp
index 1d81c5a182c..3375a968b04 100644
--- a/src/terminal/adapter/ITerminalApi.hpp
+++ b/src/terminal/adapter/ITerminalApi.hpp
@@ -85,5 +85,7 @@ namespace Microsoft::Console::VirtualTerminal
         virtual void MarkCommandStart() = 0;
         virtual void MarkOutputStart() = 0;
         virtual void MarkCommandFinish(std::optional<unsigned int> error) = 0;
+
+        virtual void InvokeCompletions(std::wstring_view menuJson, unsigned int replaceLength) = 0;
     };
 }
diff --git a/src/terminal/adapter/adaptDispatch.cpp b/src/terminal/adapter/adaptDispatch.cpp
index 04ce77e46cd..92af043e4f6 100644
--- a/src/terminal/adapter/adaptDispatch.cpp
+++ b/src/terminal/adapter/adaptDispatch.cpp
@@ -3738,6 +3738,86 @@ bool AdaptDispatch::DoFinalTermAction(const std::wstring_view string)
     // modify the state of that mark as we go.
     return false;
 }
+// Method Description:
+// - Performs a VsCode action
+// - Currently, the actions we support are:
+//   * Completions: An experimental protocol for passing shell completion
+//     information from the shell to the terminal. This sequence is still under
+//     active development, and subject to change.
+// - Not actually used in conhost
+// Arguments:
+// - string: contains the parameters that define which action we do
+// Return Value:
+// - false in conhost, true for the SetMark action, otherwise false.
+bool AdaptDispatch::DoVsCodeAction(const std::wstring_view string)
+{
+    // This is not implemented in conhost.
+    if (_api.IsConsolePty())
+    {
+        // Flush the frame manually to make sure this action happens at the right time.
+        _renderer.TriggerFlush(false);
+        return false;
+    }
+
+    if constexpr (!Feature_ShellCompletions::IsEnabled())
+    {
+        return false;
+    }
+
+    const auto parts = Utils::SplitString(string, L';');
+
+    if (parts.size() < 1)
+    {
+        return false;
+    }
+
+    const auto action = til::at(parts, 0);
+
+    if (action == L"Completions")
+    {
+        // The structure of the message is as follows:
+        // `e]633;
+        // 0:     Completions;
+        // 1:     $($completions.ReplacementIndex);
+        // 2:     $($completions.ReplacementLength);
+        // 3:     $($cursorIndex);
+        // 4:     $completions.CompletionMatches | ConvertTo-Json
+        unsigned int replacementIndex = 0;
+        unsigned int replacementLength = 0;
+        unsigned int cursorIndex = 0;
+
+        bool succeeded = (parts.size() >= 2) &&
+                         (Utils::StringToUint(til::at(parts, 1), replacementIndex));
+        succeeded &= (parts.size() >= 3) &&
+                     (Utils::StringToUint(til::at(parts, 2), replacementLength));
+        succeeded &= (parts.size() >= 4) &&
+                     (Utils::StringToUint(til::at(parts, 3), cursorIndex));
+
+        // VsCode is using cursorIndex and replacementIndex, but we aren't currently.
+        if (succeeded)
+        {
+            // Get the combined lengths of parts 0-3, plus the semicolons. We
+            // need this so that we can just pass the remainder of the string.
+            const auto prefixLength = til::at(parts, 0).size() + 1 +
+                                      til::at(parts, 1).size() + 1 +
+                                      til::at(parts, 2).size() + 1 +
+                                      til::at(parts, 3).size() + 1;
+            if (prefixLength > string.size())
+            {
+                return true;
+            }
+            // Get the remainder of the string
+            const auto remainder = string.substr(prefixLength);
+
+            _api.InvokeCompletions(parts.size() < 5 ? L"" : remainder,
+                                   replacementLength);
+        }
+
+        // If it's poorly formatted, just eat it
+        return true;
+    }
+    return false;
+}
 
 // Method Description:
 // - DECDLD - Downloads one or more characters of a dynamically redefinable
diff --git a/src/terminal/adapter/adaptDispatch.hpp b/src/terminal/adapter/adaptDispatch.hpp
index 87f5f11ba4d..7417f6f82fd 100644
--- a/src/terminal/adapter/adaptDispatch.hpp
+++ b/src/terminal/adapter/adaptDispatch.hpp
@@ -139,6 +139,8 @@ namespace Microsoft::Console::VirtualTerminal
 
         bool DoFinalTermAction(const std::wstring_view string) override;
 
+        bool DoVsCodeAction(const std::wstring_view string) override;
+
         StringHandler DownloadDRCS(const VTInt fontNumber,
                                    const VTParameter startChar,
                                    const DispatchTypes::DrcsEraseControl eraseControl,
diff --git a/src/terminal/adapter/termDispatch.hpp b/src/terminal/adapter/termDispatch.hpp
index 2fe1f216a3d..4f11ae8bb93 100644
--- a/src/terminal/adapter/termDispatch.hpp
+++ b/src/terminal/adapter/termDispatch.hpp
@@ -130,6 +130,8 @@ class Microsoft::Console::VirtualTerminal::TermDispatch : public Microsoft::Cons
 
     bool DoFinalTermAction(const std::wstring_view /*string*/) override { return false; }
 
+    bool DoVsCodeAction(const std::wstring_view /*string*/) override { return false; }
+
     StringHandler DownloadDRCS(const VTInt /*fontNumber*/,
                                const VTParameter /*startChar*/,
                                const DispatchTypes::DrcsEraseControl /*eraseControl*/,
diff --git a/src/terminal/adapter/ut_adapter/adapterTest.cpp b/src/terminal/adapter/ut_adapter/adapterTest.cpp
index 162142ae3e4..4661c4b7ecf 100644
--- a/src/terminal/adapter/ut_adapter/adapterTest.cpp
+++ b/src/terminal/adapter/ut_adapter/adapterTest.cpp
@@ -231,6 +231,12 @@ class TestGetSet final : public ITerminalApi
     {
         Log::Comment(L"MarkCommandFinish MOCK called...");
     }
+    void InvokeCompletions(std::wstring_view menuJson, unsigned int replaceLength) override
+    {
+        Log::Comment(L"InvokeCompletions MOCK called...");
+        VERIFY_ARE_EQUAL(_expectedMenuJson, menuJson);
+        VERIFY_ARE_EQUAL(_expectedReplaceLength, replaceLength);
+    }
 
     void PrepData()
     {
@@ -378,6 +384,9 @@ class TestGetSet final : public ITerminalApi
     bool _getConsoleOutputCPResult = false;
     bool _expectedShowWindow = false;
 
+    std::wstring _expectedMenuJson{};
+    unsigned int _expectedReplaceLength = 0;
+
 private:
     HANDLE _hCon;
 };
@@ -3005,6 +3014,33 @@ class AdapterTest
         _testGetSet->ValidateInputEvent(expectedResponse.c_str());
     }
 
+    TEST_METHOD(MenuCompletionsTests)
+    {
+        _testGetSet->PrepData();
+
+        Log::Comment(L"Not enough parameters");
+        VERIFY_IS_FALSE(_pDispatch->DoVsCodeAction(LR"(garbage)"));
+
+        Log::Comment(L"Not enough parameters");
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions)"));
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions;)"));
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions;10;)"));
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions;10;20)"));
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions;10;20;)"));
+        Log::Comment(L"No trailing semicolon");
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions;10;20;3)"));
+
+        Log::Comment(L"Normal, good case");
+        _testGetSet->_expectedMenuJson = LR"({ "foo": 1, "bar": 2 })";
+        _testGetSet->_expectedReplaceLength = 2;
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions;1;2;3;{ "foo": 1, "bar": 2 })"));
+
+        Log::Comment(L"JSON has a semicolon in it");
+        _testGetSet->_expectedMenuJson = LR"({ "foo": "what;ever", "bar": 2 })";
+        _testGetSet->_expectedReplaceLength = 20;
+        VERIFY_IS_TRUE(_pDispatch->DoVsCodeAction(LR"(Completions;10;20;30;{ "foo": "what;ever", "bar": 2 })"));
+    }
+
 private:
     TerminalInput _terminalInput;
     std::unique_ptr<TestGetSet> _testGetSet;
diff --git a/src/terminal/parser/OutputStateMachineEngine.cpp b/src/terminal/parser/OutputStateMachineEngine.cpp
index 80a77d89173..e744c95ad08 100644
--- a/src/terminal/parser/OutputStateMachineEngine.cpp
+++ b/src/terminal/parser/OutputStateMachineEngine.cpp
@@ -868,6 +868,11 @@ bool OutputStateMachineEngine::ActionOscDispatch(const wchar_t /*wch*/,
         success = _dispatch->DoFinalTermAction(string);
         break;
     }
+    case OscActionCodes::VsCodeAction:
+    {
+        success = _dispatch->DoVsCodeAction(string);
+        break;
+    }
     default:
         // If no functions to call, overall dispatch was a failure.
         success = false;
diff --git a/src/terminal/parser/OutputStateMachineEngine.hpp b/src/terminal/parser/OutputStateMachineEngine.hpp
index b078ade9fb7..1983fa9baaa 100644
--- a/src/terminal/parser/OutputStateMachineEngine.hpp
+++ b/src/terminal/parser/OutputStateMachineEngine.hpp
@@ -214,6 +214,7 @@ namespace Microsoft::Console::VirtualTerminal
             ResetBackgroundColor = 111, // Not implemented
             ResetCursorColor = 112,
             FinalTermAction = 133,
+            VsCodeAction = 633,
             ITerm2Action = 1337,
         };