CmdPal: Removing Core projects (#45693)

Functionally, no differences.

- Removed Core projects.
- Core.Common => Microsoft.CmdPal.Common
- Core.ViewModels => Microsoft.CmdPal.UI.ViewModels

---------

Co-authored-by: Jiří Polášek <me@jiripolasek.com>

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/AliasManager.cs

@@ -4,7 +4,7 @@
 
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Messaging;
-using Microsoft.CmdPal.Core.ViewModels.Messages;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
 
 namespace Microsoft.CmdPal.UI.ViewModels;
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/AppExtensionHost.cs

@@ -0,0 +1,170 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using Microsoft.CmdPal.Common;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public abstract partial class AppExtensionHost : IExtensionHost
+{
+    private static readonly GlobalLogPageContext _globalLogPageContext = new();
+
+    private static ulong _hostingHwnd;
+
+    public static ObservableCollection<LogMessageViewModel> LogMessages { get; } = [];
+
+    public ulong HostingHwnd => _hostingHwnd;
+
+    public string LanguageOverride => string.Empty;
+
+    public ObservableCollection<StatusMessageViewModel> StatusMessages { get; } = [];
+
+    public static void SetHostHwnd(ulong hostHwnd) => _hostingHwnd = hostHwnd;
+
+    public void DebugLog(string message)
+    {
+#if DEBUG
+        this.ProcessLogMessage(new LogMessage(message));
+#endif
+    }
+
+    public IAsyncAction HideStatus(IStatusMessage? message)
+    {
+        if (message is null)
+        {
+            return Task.CompletedTask.AsAsyncAction();
+        }
+
+        _ = Task.Run(() =>
+        {
+            ProcessHideStatusMessage(message);
+        });
+        return Task.CompletedTask.AsAsyncAction();
+    }
+
+    public void Log(string message)
+    {
+        this.ProcessLogMessage(new LogMessage(message));
+    }
+
+    public IAsyncAction LogMessage(ILogMessage? message)
+    {
+        if (message is null)
+        {
+            return Task.CompletedTask.AsAsyncAction();
+        }
+
+        CoreLogger.LogDebug(message.Message);
+
+        _ = Task.Run(() =>
+        {
+            ProcessLogMessage(message);
+        });
+
+        // We can't just make a LogMessageViewModel : ExtensionObjectViewModel
+        // because we don't necessarily know the page context. Butts.
+        return Task.CompletedTask.AsAsyncAction();
+    }
+
+    public void ProcessHideStatusMessage(IStatusMessage message)
+    {
+        Task.Factory.StartNew(
+            () =>
+            {
+                try
+                {
+                    var vm = StatusMessages.Where(messageVM => messageVM.Model.Unsafe == message).FirstOrDefault();
+                    if (vm is not null)
+                    {
+                        StatusMessages.Remove(vm);
+                    }
+                }
+                catch
+                {
+                }
+            },
+            CancellationToken.None,
+            TaskCreationOptions.None,
+            _globalLogPageContext.Scheduler);
+    }
+
+    public void ProcessLogMessage(ILogMessage message)
+    {
+        var vm = new LogMessageViewModel(message, _globalLogPageContext);
+        vm.SafeInitializePropertiesSynchronous();
+
+        Task.Factory.StartNew(
+            () =>
+            {
+                LogMessages.Add(vm);
+            },
+            CancellationToken.None,
+            TaskCreationOptions.None,
+            _globalLogPageContext.Scheduler);
+    }
+
+    public void ProcessStatusMessage(IStatusMessage message, StatusContext context)
+    {
+        // If this message is already in the list of messages, just bring it to the top
+        var oldVm = StatusMessages.Where(messageVM => messageVM.Model.Unsafe == message).FirstOrDefault();
+        if (oldVm is not null)
+        {
+            Task.Factory.StartNew(
+                () =>
+                {
+                    StatusMessages.Remove(oldVm);
+                    StatusMessages.Add(oldVm);
+                },
+                CancellationToken.None,
+                TaskCreationOptions.None,
+                _globalLogPageContext.Scheduler);
+            return;
+        }
+
+        var vm = new StatusMessageViewModel(message, new(_globalLogPageContext));
+        vm.SafeInitializePropertiesSynchronous();
+
+        Task.Factory.StartNew(
+            () =>
+            {
+                StatusMessages.Add(vm);
+            },
+            CancellationToken.None,
+            TaskCreationOptions.None,
+            _globalLogPageContext.Scheduler);
+    }
+
+    public IAsyncAction ShowStatus(IStatusMessage? message, StatusContext context)
+    {
+        if (message is null)
+        {
+            return Task.CompletedTask.AsAsyncAction();
+        }
+
+        Debug.WriteLine(message.Message);
+
+        _ = Task.Run(() =>
+        {
+            ProcessStatusMessage(message, context);
+        });
+
+        return Task.CompletedTask.AsAsyncAction();
+    }
+
+    public abstract string? GetExtensionDisplayName();
+}
+
+public interface IAppHostService
+{
+    AppExtensionHost GetDefaultHost();
+
+    AppExtensionHost GetHostForCommand(object? context, AppExtensionHost? currentHost);
+
+    CommandProviderContext GetProviderContextForCommand(object? command, CommandProviderContext? currentContext);
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/AsyncNavigationRequest.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+/// <summary>
+/// Encapsulates a navigation request within Command Palette view models.
+/// </summary>
+/// <param name="TargetViewModel">A view model that should be navigated to.</param>
+/// <param name="NavigationToken"> A <see cref="CancellationToken"/> that can be used to cancel the pending navigation.</param>
+public record AsyncNavigationRequest(object? TargetViewModel, CancellationToken NavigationToken);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/BatchUpdateManager.cs

@@ -0,0 +1,136 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Concurrent;
+using Microsoft.CmdPal.Common;
+using Microsoft.CmdPal.Common.Helpers;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+internal static class BatchUpdateManager
+{
+    private const int ExpectedBatchSize = 32;
+
+    // 30 ms chosen empirically to balance responsiveness and batching:
+    // - Keeps perceived latency low (< ~50 ms) for user-visible updates.
+    // - Still allows multiple COM/background events to be coalesced into a single batch.
+    private static readonly TimeSpan BatchDelay = TimeSpan.FromMilliseconds(30);
+    private static readonly ConcurrentQueue<IBatchUpdateTarget> DirtyQueue = [];
+    private static readonly Timer Timer = new(static _ => Flush(), null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+
+    private static InterlockedBoolean _isFlushScheduled;
+
+    /// <summary>
+    /// Enqueue a target for batched processing. Safe to call from any thread (including COM callbacks).
+    /// </summary>
+    public static void Queue(IBatchUpdateTarget target)
+    {
+        if (!target.TryMarkBatchQueued())
+        {
+            return; // already queued in current batch window
+        }
+
+        DirtyQueue.Enqueue(target);
+        TryScheduleFlush();
+    }
+
+    private static void TryScheduleFlush()
+    {
+        if (!_isFlushScheduled.Set())
+        {
+            return;
+        }
+
+        if (DirtyQueue.IsEmpty)
+        {
+            _isFlushScheduled.Clear();
+
+            if (DirtyQueue.IsEmpty)
+            {
+                return;
+            }
+
+            if (!_isFlushScheduled.Set())
+            {
+                return;
+            }
+        }
+
+        try
+        {
+            Timer.Change(BatchDelay, Timeout.InfiniteTimeSpan);
+        }
+        catch (Exception ex)
+        {
+            _isFlushScheduled.Clear();
+            CoreLogger.LogError("Failed to arm batch timer.", ex);
+        }
+    }
+
+    private static void Flush()
+    {
+        try
+        {
+            var drained = new List<IBatchUpdateTarget>(ExpectedBatchSize);
+            while (DirtyQueue.TryDequeue(out var item))
+            {
+                drained.Add(item);
+            }
+
+            if (drained.Count == 0)
+            {
+                return;
+            }
+
+            // LOAD BEARING:
+            // ApplyPendingUpdates must run on a background thread.
+            // The VM itself is responsible for marshaling UI notifications to its _uiScheduler.
+            ApplyBatch(drained);
+        }
+        catch (Exception ex)
+        {
+            // Don't kill the timer thread.
+            CoreLogger.LogError("Batch flush failed.", ex);
+        }
+        finally
+        {
+            _isFlushScheduled.Clear();
+            TryScheduleFlush();
+        }
+    }
+
+    private static void ApplyBatch(List<IBatchUpdateTarget> items)
+    {
+        // Runs on the Timer callback thread (ThreadPool). That's fine: background work only.
+        foreach (var item in items)
+        {
+            // Allow re-queueing immediately if more COM events arrive during apply.
+            item.ClearBatchQueued();
+
+            try
+            {
+                item.ApplyPendingUpdates();
+            }
+            catch (Exception ex)
+            {
+                CoreLogger.LogError("Failed to apply pending updates for a batched target.", ex);
+            }
+        }
+    }
+}
+
+internal interface IBatchUpdateTarget
+{
+    /// <summary>Gets UI scheduler (used by targets internally for UI marshaling). Kept here for diagnostics / consistency.</summary>
+    TaskScheduler UIScheduler { get; }
+
+    /// <summary>Apply any coalesced updates. Must be safe to call on a background thread.</summary>
+    void ApplyPendingUpdates();
+
+    /// <summary>De-dupe gate: returns true only for the first enqueue until cleared.</summary>
+    bool TryMarkBatchQueued();
+
+    /// <summary>Clear the de-dupe gate so the item can be queued again.</summary>
+    void ClearBatchQueued();
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandBarViewModel.cs

@@ -0,0 +1,166 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.System;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class CommandBarViewModel : ObservableObject,
+    IRecipient<UpdateCommandBarMessage>
+{
+    public ICommandBarContext? SelectedItem
+    {
+        get => field;
+        set
+        {
+            if (field != null)
+            {
+                field.PropertyChanged -= SelectedItemPropertyChanged;
+            }
+
+            field = value;
+            SetSelectedItem(value);
+
+            OnPropertyChanged(nameof(SelectedItem));
+        }
+    }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasPrimaryCommand))]
+    public partial CommandItemViewModel? PrimaryCommand { get; set; }
+
+    public bool HasPrimaryCommand => PrimaryCommand is not null && PrimaryCommand.ShouldBeVisible;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasSecondaryCommand))]
+    public partial CommandItemViewModel? SecondaryCommand { get; set; }
+
+    public bool HasSecondaryCommand => SecondaryCommand is not null;
+
+    [ObservableProperty]
+    public partial bool ShouldShowContextMenu { get; set; } = false;
+
+    [ObservableProperty]
+    public partial PageViewModel? CurrentPage { get; set; }
+
+    public CommandBarViewModel()
+    {
+        WeakReferenceMessenger.Default.Register<UpdateCommandBarMessage>(this);
+    }
+
+    public void Receive(UpdateCommandBarMessage message) => SelectedItem = message.ViewModel;
+
+    private void SetSelectedItem(ICommandBarContext? value)
+    {
+        if (value is not null)
+        {
+            PrimaryCommand = value.PrimaryCommand;
+            value.PropertyChanged += SelectedItemPropertyChanged;
+        }
+        else
+        {
+            if (SelectedItem is not null)
+            {
+                SelectedItem.PropertyChanged -= SelectedItemPropertyChanged;
+            }
+
+            PrimaryCommand = null;
+        }
+
+        UpdateContextItems();
+    }
+
+    private void SelectedItemPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        switch (e.PropertyName)
+        {
+            case nameof(SelectedItem.HasMoreCommands):
+                UpdateContextItems();
+                break;
+        }
+    }
+
+    private void UpdateContextItems()
+    {
+        if (SelectedItem is null)
+        {
+            SecondaryCommand = null;
+            ShouldShowContextMenu = false;
+            return;
+        }
+
+        SecondaryCommand = SelectedItem.SecondaryCommand;
+
+        ShouldShowContextMenu = SelectedItem.MoreCommands
+            .OfType<CommandContextItemViewModel>()
+            .Count() > 1;
+
+        OnPropertyChanged(nameof(HasSecondaryCommand));
+        OnPropertyChanged(nameof(SecondaryCommand));
+        OnPropertyChanged(nameof(ShouldShowContextMenu));
+    }
+
+    // InvokeItemCommand is what this will be in Xaml due to source generator
+    // this comes in when an item in the list is tapped
+    // [RelayCommand]
+    public ContextKeybindingResult InvokeItem(CommandContextItemViewModel item) =>
+        PerformCommand(item);
+
+    // this comes in when the primary button is tapped
+    public void InvokePrimaryCommand()
+    {
+        PerformCommand(PrimaryCommand);
+    }
+
+    // this comes in when the secondary button is tapped
+    public void InvokeSecondaryCommand()
+    {
+        PerformCommand(SecondaryCommand);
+    }
+
+    public ContextKeybindingResult CheckKeybinding(bool ctrl, bool alt, bool shift, bool win, VirtualKey key)
+    {
+        var keybindings = SelectedItem?.Keybindings();
+        if (keybindings is not null)
+        {
+            // Does the pressed key match any of the keybindings?
+            var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrl, alt, shift, win, key, 0);
+            if (keybindings.TryGetValue(pressedKeyChord, out var matchedItem))
+            {
+                return matchedItem is not null ? PerformCommand(matchedItem) : ContextKeybindingResult.Unhandled;
+            }
+        }
+
+        return ContextKeybindingResult.Unhandled;
+    }
+
+    private ContextKeybindingResult PerformCommand(CommandItemViewModel? command)
+    {
+        if (command is null)
+        {
+            return ContextKeybindingResult.Unhandled;
+        }
+
+        WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(command.Command.Model, command.Model));
+        if (command.HasMoreCommands)
+        {
+            return ContextKeybindingResult.KeepOpen;
+        }
+        else
+        {
+            return ContextKeybindingResult.Hide;
+        }
+    }
+}
+
+public enum ContextKeybindingResult
+{
+    Unhandled,
+    Hide,
+    KeepOpen,
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandContextItemViewModel.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+public partial class CommandContextItemViewModel(ICommandContextItem contextItem, WeakReference<IPageContext> context) : CommandItemViewModel(new(contextItem), context), IContextItemViewModel
+{
+    private readonly KeyChord nullKeyChord = new(0, 0, 0);
+
+    public new ExtensionObject<ICommandContextItem> Model { get; } = new(contextItem);
+
+    public bool IsCritical { get; private set; }
+
+    public KeyChord? RequestedShortcut { get; private set; }
+
+    public bool HasRequestedShortcut => RequestedShortcut is not null && (RequestedShortcut.Value != nullKeyChord);
+
+    public override void InitializeProperties()
+    {
+        if (IsInitialized)
+        {
+            return;
+        }
+
+        base.InitializeProperties();
+
+        var contextItem = Model.Unsafe;
+        if (contextItem is null)
+        {
+            return; // throw?
+        }
+
+        IsCritical = contextItem.IsCritical;
+
+        RequestedShortcut = new(
+            contextItem.RequestedShortcut.Modifiers,
+            contextItem.RequestedShortcut.Vkey,
+            contextItem.RequestedShortcut.ScanCode);
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandItemViewModel.cs

@@ -0,0 +1,524 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CmdPal.Common;
+using Microsoft.CmdPal.Common.Helpers;
+using Microsoft.CmdPal.Common.Text;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.ApplicationModel.DataTransfer;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+public partial class CommandItemViewModel : ExtensionObjectViewModel, ICommandBarContext, IPrecomputedListItem
+{
+    public ExtensionObject<ICommandItem> Model => _commandItemModel;
+
+    private ExtensionObject<IExtendedAttributesProvider>? ExtendedAttributesProvider { get; set; }
+
+    private readonly ExtensionObject<ICommandItem> _commandItemModel = new(null);
+    private CommandContextItemViewModel? _defaultCommandContextItemViewModel;
+
+    private FuzzyTargetCache _titleCache;
+    private FuzzyTargetCache _subtitleCache;
+
+    internal InitializedState Initialized { get; private set; } = InitializedState.Uninitialized;
+
+    protected bool IsFastInitialized => IsInErrorState || Initialized.HasFlag(InitializedState.FastInitialized);
+
+    protected bool IsInitialized => IsInErrorState || Initialized.HasFlag(InitializedState.Initialized);
+
+    protected bool IsSelectedInitialized => IsInErrorState || Initialized.HasFlag(InitializedState.SelectionInitialized);
+
+    public bool IsInErrorState => Initialized.HasFlag(InitializedState.Error);
+
+    // These are properties that are "observable" from the extension object
+    // itself, in the sense that they get raised by PropChanged events from the
+    // extension. However, we don't want to actually make them
+    // [ObservableProperty]s, because PropChanged comes in off the UI thread,
+    // and ObservableProperty is not smart enough to raise the PropertyChanged
+    // on the UI thread.
+    public string Name => Command.Name;
+
+    private string _itemTitle = string.Empty;
+
+    public string Title => string.IsNullOrEmpty(_itemTitle) ? Name : _itemTitle;
+
+    public string Subtitle { get; private set; } = string.Empty;
+
+    private IconInfoViewModel _icon = new(null);
+
+    public IconInfoViewModel Icon => _icon.IsSet ? _icon : Command.Icon;
+
+    public CommandViewModel Command { get; private set; }
+
+    public List<IContextItemViewModel> MoreCommands { get; private set; } = [];
+
+    IEnumerable<IContextItemViewModel> IContextMenuContext.MoreCommands => MoreCommands;
+
+    private List<CommandContextItemViewModel> ActualCommands => MoreCommands.OfType<CommandContextItemViewModel>().ToList();
+
+    public bool HasMoreCommands => ActualCommands.Count > 0;
+
+    public string SecondaryCommandName => SecondaryCommand?.Name ?? string.Empty;
+
+    public CommandItemViewModel? PrimaryCommand => this;
+
+    public CommandItemViewModel? SecondaryCommand => HasMoreCommands ? ActualCommands[0] : null;
+
+    public bool ShouldBeVisible => !string.IsNullOrEmpty(Name);
+
+    public DataPackageView? DataPackage { get; private set; }
+
+    public List<IContextItemViewModel> AllCommands
+    {
+        get
+        {
+            List<IContextItemViewModel> l = _defaultCommandContextItemViewModel is null ?
+                new() :
+                [_defaultCommandContextItemViewModel];
+
+            l.AddRange(MoreCommands);
+            return l;
+        }
+    }
+
+    private static readonly IconInfoViewModel _errorIcon;
+
+    static CommandItemViewModel()
+    {
+        _errorIcon = new(new IconInfo("\uEA39")); // ErrorBadge
+        _errorIcon.InitializeProperties();
+    }
+
+    public CommandItemViewModel(ExtensionObject<ICommandItem> item, WeakReference<IPageContext> errorContext)
+        : base(errorContext)
+    {
+        _commandItemModel = item;
+        Command = new(null, errorContext);
+    }
+
+    public void FastInitializeProperties()
+    {
+        if (IsFastInitialized)
+        {
+            return;
+        }
+
+        var model = _commandItemModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Command = new(model.Command, PageContext);
+        Command.FastInitializeProperties();
+
+        _itemTitle = model.Title;
+        Subtitle = model.Subtitle;
+        _titleCache.Invalidate();
+        _subtitleCache.Invalidate();
+
+        Initialized |= InitializedState.FastInitialized;
+    }
+
+    //// Called from ListViewModel on background thread started in ListPage.xaml.cs
+    public override void InitializeProperties()
+    {
+        if (IsInitialized)
+        {
+            return;
+        }
+
+        if (!IsFastInitialized)
+        {
+            FastInitializeProperties();
+        }
+
+        var model = _commandItemModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Command.InitializeProperties();
+
+        var icon = model.Icon;
+        if (icon is not null)
+        {
+            _icon = new(icon);
+            _icon.InitializeProperties();
+        }
+
+        // TODO: Do these need to go into FastInit?
+        model.PropChanged += Model_PropChanged;
+        Command.PropertyChanged += Command_PropertyChanged;
+
+        UpdateProperty(nameof(Name));
+        UpdateProperty(nameof(Title));
+        UpdateProperty(nameof(Subtitle));
+        UpdateProperty(nameof(Icon));
+
+        // Load-bearing: if you don't raise a IsInitialized here, then
+        // TopLevelViewModel will never know what the command's ID is, so it
+        // will never be able to load Hotkeys & aliases
+        UpdateProperty(nameof(IsInitialized));
+
+        if (model is IExtendedAttributesProvider extendedAttributesProvider)
+        {
+            ExtendedAttributesProvider = new ExtensionObject<IExtendedAttributesProvider>(extendedAttributesProvider);
+            var properties = extendedAttributesProvider.GetProperties();
+            UpdateDataPackage(properties);
+        }
+
+        Initialized |= InitializedState.Initialized;
+    }
+
+    public virtual void SlowInitializeProperties()
+    {
+        if (IsSelectedInitialized)
+        {
+            return;
+        }
+
+        if (!IsInitialized)
+        {
+            InitializeProperties();
+        }
+
+        var model = _commandItemModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        var more = model.MoreCommands;
+        if (more is not null)
+        {
+            MoreCommands = more
+                .Select<IContextItem, IContextItemViewModel>(item =>
+                {
+                    return item is ICommandContextItem contextItem ? new CommandContextItemViewModel(contextItem, PageContext) : new SeparatorViewModel();
+                })
+                .ToList();
+        }
+
+        // Here, we're already theoretically in the async context, so we can
+        // use Initialize straight up
+        MoreCommands
+            .OfType<CommandContextItemViewModel>()
+            .ToList()
+            .ForEach(contextItem =>
+            {
+                contextItem.SlowInitializeProperties();
+            });
+
+        if (!string.IsNullOrEmpty(model.Command?.Name))
+        {
+            _defaultCommandContextItemViewModel = new CommandContextItemViewModel(new CommandContextItem(model.Command!), PageContext)
+            {
+                _itemTitle = Name,
+                Subtitle = Subtitle,
+                Command = Command,
+
+                // TODO this probably should just be a CommandContextItemViewModel(CommandItemViewModel) ctor, or a copy ctor or whatever
+                // Anything we set manually here must stay in sync with the corresponding properties on CommandItemViewModel.
+            };
+
+            // Only set the icon on the context item for us if our command didn't
+            // have its own icon
+            UpdateDefaultContextItemIcon();
+        }
+
+        Initialized |= InitializedState.SelectionInitialized;
+        UpdateProperty(nameof(MoreCommands));
+        UpdateProperty(nameof(AllCommands));
+        UpdateProperty(nameof(IsSelectedInitialized));
+    }
+
+    public bool SafeFastInit()
+    {
+        try
+        {
+            FastInitializeProperties();
+            return true;
+        }
+        catch (Exception ex)
+        {
+            CoreLogger.LogError("error fast initializing CommandItemViewModel", ex);
+            Command = new(null, PageContext);
+            _itemTitle = "Error";
+            Subtitle = "Item failed to load";
+            MoreCommands = [];
+            _icon = _errorIcon;
+            _titleCache.Invalidate();
+            _subtitleCache.Invalidate();
+            Initialized |= InitializedState.Error;
+        }
+
+        return false;
+    }
+
+    public bool SafeSlowInit()
+    {
+        try
+        {
+            SlowInitializeProperties();
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Initialized |= InitializedState.Error;
+            CoreLogger.LogError("error slow initializing CommandItemViewModel", ex);
+        }
+
+        return false;
+    }
+
+    public bool SafeInitializeProperties()
+    {
+        try
+        {
+            InitializeProperties();
+            return true;
+        }
+        catch (Exception ex)
+        {
+            CoreLogger.LogError("error initializing CommandItemViewModel", ex);
+            Command = new(null, PageContext);
+            _itemTitle = "Error";
+            Subtitle = "Item failed to load";
+            MoreCommands = [];
+            _icon = _errorIcon;
+            _titleCache.Invalidate();
+            _subtitleCache.Invalidate();
+            Initialized |= InitializedState.Error;
+        }
+
+        return false;
+    }
+
+    private void Model_PropChanged(object sender, IPropChangedEventArgs args)
+    {
+        try
+        {
+            FetchProperty(args.PropertyName);
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex, _commandItemModel?.Unsafe?.Title);
+        }
+    }
+
+    protected virtual void FetchProperty(string propertyName)
+    {
+        var model = this._commandItemModel.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        switch (propertyName)
+        {
+            case nameof(Command):
+                Command.PropertyChanged -= Command_PropertyChanged;
+                Command = new(model.Command, PageContext);
+                Command.InitializeProperties();
+                Command.PropertyChanged += Command_PropertyChanged;
+
+                // Extensions based on Command Palette SDK < 0.3 CommandItem class won't notify when Title changes because Command
+                // or Command.Name change. This is a workaround to ensure that the Title is always up-to-date for extensions with old SDK.
+                _itemTitle = model.Title;
+
+                _defaultCommandContextItemViewModel?.Command = Command;
+                _defaultCommandContextItemViewModel?.UpdateTitle(_itemTitle);
+                UpdateDefaultContextItemIcon();
+
+                UpdateProperty(nameof(Name));
+                UpdateProperty(nameof(Title));
+                UpdateProperty(nameof(Icon));
+                break;
+
+            case nameof(Title):
+                _itemTitle = model.Title;
+                _titleCache.Invalidate();
+                break;
+
+            case nameof(Subtitle):
+                var modelSubtitle = model.Subtitle;
+                this.Subtitle = modelSubtitle;
+                _defaultCommandContextItemViewModel?.Subtitle = modelSubtitle;
+                _subtitleCache.Invalidate();
+                break;
+
+            case nameof(Icon):
+                var oldIcon = _icon;
+                _icon = new(model.Icon);
+                _icon.InitializeProperties();
+                if (oldIcon.IsSet || _icon.IsSet)
+                {
+                    UpdateProperty(nameof(Icon));
+                }
+
+                UpdateDefaultContextItemIcon();
+
+                break;
+
+            case nameof(model.MoreCommands):
+                var more = model.MoreCommands;
+                if (more is not null)
+                {
+                    var newContextMenu = more
+                        .Select<IContextItem, IContextItemViewModel>(item =>
+                        {
+                            return item is ICommandContextItem contextItem ? new CommandContextItemViewModel(contextItem, PageContext) : new SeparatorViewModel();
+                        })
+                        .ToList();
+                    lock (MoreCommands)
+                    {
+                        ListHelpers.InPlaceUpdateList(MoreCommands, newContextMenu);
+                    }
+
+                    newContextMenu
+                        .OfType<CommandContextItemViewModel>()
+                        .ToList()
+                        .ForEach(contextItem =>
+                        {
+                            contextItem.InitializeProperties();
+                        });
+                }
+                else
+                {
+                    lock (MoreCommands)
+                    {
+                        MoreCommands.Clear();
+                    }
+                }
+
+                UpdateProperty(nameof(SecondaryCommand));
+                UpdateProperty(nameof(SecondaryCommandName));
+                UpdateProperty(nameof(HasMoreCommands));
+
+                break;
+            case nameof(DataPackage):
+                UpdateDataPackage(ExtendedAttributesProvider?.Unsafe?.GetProperties());
+                break;
+        }
+
+        UpdateProperty(propertyName);
+    }
+
+    private void Command_PropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        var propertyName = e.PropertyName;
+        var model = _commandItemModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        switch (propertyName)
+        {
+            case nameof(Command.Name):
+                // Extensions based on Command Palette SDK < 0.3 CommandItem class won't notify when Title changes because Command
+                // or Command.Name change. This is a workaround to ensure that the Title is always up-to-date for extensions with old SDK.
+                _itemTitle = model.Title;
+                _titleCache.Invalidate();
+                UpdateProperty(nameof(Title), nameof(Name));
+
+                _defaultCommandContextItemViewModel?.UpdateTitle(model.Command.Name);
+                break;
+
+            case nameof(Command.Icon):
+                UpdateDefaultContextItemIcon();
+                UpdateProperty(nameof(Icon));
+                break;
+        }
+    }
+
+    private void UpdateDefaultContextItemIcon()
+    {
+        // Command icon takes precedence over our icon on the primary command
+        _defaultCommandContextItemViewModel?.UpdateIcon(Command.Icon.IsSet ? Command.Icon : _icon);
+    }
+
+    private void UpdateTitle(string? title)
+    {
+        _itemTitle = title ?? string.Empty;
+        _titleCache.Invalidate();
+        UpdateProperty(nameof(Title));
+    }
+
+    private void UpdateIcon(IIconInfo? iconInfo)
+    {
+        _icon = new(iconInfo);
+        _icon.InitializeProperties();
+        UpdateProperty(nameof(Icon));
+    }
+
+    private void UpdateDataPackage(IDictionary<string, object?>? properties)
+    {
+        DataPackage =
+            properties?.TryGetValue(WellKnownExtensionAttributes.DataPackage, out var dataPackageView) == true &&
+            dataPackageView is DataPackageView view
+                ? view
+                : null;
+        UpdateProperty(nameof(DataPackage));
+    }
+
+    public FuzzyTarget GetTitleTarget(IPrecomputedFuzzyMatcher matcher)
+        => _titleCache.GetOrUpdate(matcher, Title);
+
+    public FuzzyTarget GetSubtitleTarget(IPrecomputedFuzzyMatcher matcher)
+        => _subtitleCache.GetOrUpdate(matcher, Subtitle);
+
+    protected override void UnsafeCleanup()
+    {
+        base.UnsafeCleanup();
+
+        lock (MoreCommands)
+        {
+            MoreCommands.OfType<CommandContextItemViewModel>()
+                        .ToList()
+                        .ForEach(c => c.SafeCleanup());
+            MoreCommands.Clear();
+        }
+
+        // _listItemIcon.SafeCleanup();
+        _icon = new(null); // necessary?
+
+        _defaultCommandContextItemViewModel?.SafeCleanup();
+        _defaultCommandContextItemViewModel = null;
+
+        Command.PropertyChanged -= Command_PropertyChanged;
+        Command.SafeCleanup();
+
+        var model = _commandItemModel.Unsafe;
+        if (model is not null)
+        {
+            model.PropChanged -= Model_PropChanged;
+        }
+    }
+
+    public override void SafeCleanup()
+    {
+        base.SafeCleanup();
+        Initialized |= InitializedState.CleanedUp;
+    }
+}
+
+[Flags]
+internal enum InitializedState
+{
+    Uninitialized = 0,
+    FastInitialized = 1,
+    Initialized = 2,
+    SelectionInitialized = 4,
+    Error = 8,
+    CleanedUp = 16,
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandPaletteContentPageViewModel.cs

@@ -2,7 +2,6 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CmdPal.Core.ViewModels;
 using Microsoft.CommandPalette.Extensions;
 
 namespace Microsoft.CmdPal.UI.ViewModels;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandPaletteHost.cs

@@ -2,8 +2,8 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CmdPal.Core.Common.Services;
-using Microsoft.CmdPal.Core.ViewModels;
+using Microsoft.CmdPal.Common.Services;
+using Microsoft.CmdPal.UI.ViewModels;
 using Microsoft.CommandPalette.Extensions;
 
 namespace Microsoft.CmdPal.UI.ViewModels;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandPalettePageViewModelFactory.cs

@@ -2,7 +2,6 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CmdPal.Core.ViewModels;
 using Microsoft.CommandPalette.Extensions;
 
 namespace Microsoft.CmdPal.UI.ViewModels;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandProviderContext.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public sealed class CommandProviderContext
+{
+    public required string ProviderId { get; init; }
+
+    public static CommandProviderContext Empty { get; } = new() { ProviderId = "<EMPTY>" };
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandProviderWrapper.cs

@@ -3,14 +3,12 @@
 // See the LICENSE file in the project root for more information.
 
 using ManagedCommon;
-using Microsoft.CmdPal.Core.Common.Services;
-using Microsoft.CmdPal.Core.ViewModels;
-using Microsoft.CmdPal.Core.ViewModels.Models;
+using Microsoft.CmdPal.Common.Services;
+using Microsoft.CmdPal.UI.ViewModels.Models;
 using Microsoft.CmdPal.UI.ViewModels.Services;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 using Microsoft.Extensions.DependencyInjection;
-
 using Windows.Foundation;
 
 namespace Microsoft.CmdPal.UI.ViewModels;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandSettingsViewModel.cs

@@ -2,9 +2,9 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CmdPal.Core.Common;
-using Microsoft.CmdPal.Core.ViewModels;
-using Microsoft.CmdPal.Core.ViewModels.Models;
+using Microsoft.CmdPal.Common;
+using Microsoft.CmdPal.UI.ViewModels;
+using Microsoft.CmdPal.UI.ViewModels.Models;
 using Microsoft.CommandPalette.Extensions;
 
 namespace Microsoft.CmdPal.UI.ViewModels;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandViewModel.cs

@@ -0,0 +1,171 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class CommandViewModel : ExtensionObjectViewModel
+{
+    public ExtensionObject<ICommand> Model { get; private set; } = new(null);
+
+    public bool IsSet => Model.Unsafe is not null;
+
+    protected bool IsInitialized { get; private set; }
+
+    protected bool IsFastInitialized { get; private set; }
+
+    public bool HasIcon => Icon.IsSet;
+
+    // These are properties that are "observable" from the extension object
+    // itself, in the sense that they get raised by PropChanged events from the
+    // extension. However, we don't want to actually make them
+    // [ObservableProperty]s, because PropChanged comes in off the UI thread,
+    // and ObservableProperty is not smart enough to raise the PropertyChanged
+    // on the UI thread.
+    public string Id { get; private set; } = string.Empty;
+
+    public string Name { get; private set; } = string.Empty;
+
+    public IconInfoViewModel Icon { get; private set; }
+
+    // UNDER NO CIRCUMSTANCES MAY SOMEONE WRITE TO THIS DICTIONARY.
+    // This is our copy of the data from the extension.
+    // Adding values to it does not add to the extension.
+    // Modifying it will not modify the extension
+    // (except it might, if the dictionary was passed by ref)
+    private Dictionary<string, ExtensionObject<object>>? _properties;
+
+    public IReadOnlyDictionary<string, ExtensionObject<object>>? Properties => _properties?.AsReadOnly();
+
+    public CommandViewModel(ICommand? command, WeakReference<IPageContext> pageContext)
+        : base(pageContext)
+    {
+        Model = new(command);
+        Icon = new(null);
+    }
+
+    public void FastInitializeProperties()
+    {
+        if (IsFastInitialized)
+        {
+            return;
+        }
+
+        var model = Model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Id = model.Id ?? string.Empty;
+        Name = model.Name ?? string.Empty;
+        IsFastInitialized = true;
+    }
+
+    public override void InitializeProperties()
+    {
+        if (IsInitialized)
+        {
+            return;
+        }
+
+        if (!IsFastInitialized)
+        {
+            FastInitializeProperties();
+        }
+
+        var model = Model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        var ico = model.Icon;
+        if (ico is not null)
+        {
+            Icon = new(ico);
+            Icon.InitializeProperties();
+            UpdateProperty(nameof(Icon));
+        }
+
+        if (model is IExtendedAttributesProvider command2)
+        {
+            UpdatePropertiesFromExtension(command2);
+        }
+
+        model.PropChanged += Model_PropChanged;
+    }
+
+    private void Model_PropChanged(object sender, IPropChangedEventArgs args)
+    {
+        try
+        {
+            FetchProperty(args.PropertyName);
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex, Name);
+        }
+    }
+
+    protected void FetchProperty(string propertyName)
+    {
+        var model = Model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        switch (propertyName)
+        {
+            case nameof(Name):
+                Name = model.Name;
+                break;
+            case nameof(Icon):
+                var iconInfo = model.Icon;
+                Icon = new(iconInfo);
+                Icon.InitializeProperties();
+                break;
+        }
+
+        UpdateProperty(propertyName);
+    }
+
+    protected override void UnsafeCleanup()
+    {
+        base.UnsafeCleanup();
+
+        Icon = new(null); // necessary?
+
+        var model = Model.Unsafe;
+        if (model is not null)
+        {
+            model.PropChanged -= Model_PropChanged;
+        }
+    }
+
+    private void UpdatePropertiesFromExtension(IExtendedAttributesProvider? model)
+    {
+        var propertiesFromExtension = model?.GetProperties();
+        if (propertiesFromExtension == null)
+        {
+            _properties = null;
+            return;
+        }
+
+        _properties = [];
+
+        // COPY the properties into us.
+        // The IDictionary that was passed to us may be marshalled by-ref or by-value, we _don't know_.
+        //
+        // If it's by-ref, the values are arbitrary objects that are out-of-proc.
+        // If it's bu-value, then everything is in-proc, and we can't mutate the data.
+        foreach (var property in propertiesFromExtension)
+        {
+            _properties.Add(property.Key, new(property.Value));
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/BuiltinsExtensionHost.cs

@@ -2,7 +2,7 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CmdPal.Core.Common;
+using Microsoft.CmdPal.Common;
 
 namespace Microsoft.CmdPal.UI.ViewModels.BuiltinCommands;
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/LogMessagesPage.cs

@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Specialized;
-using Microsoft.CmdPal.Core.ViewModels;
+using Microsoft.CmdPal.UI.ViewModels;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/MainListPage.cs

@@ -7,9 +7,8 @@ using System.Collections.Specialized;
 using System.Diagnostics;
 using CommunityToolkit.Mvvm.Messaging;
 using ManagedCommon;
-using Microsoft.CmdPal.Core.Common.Helpers;
-using Microsoft.CmdPal.Core.Common.Text;
-using Microsoft.CmdPal.Core.ViewModels.Messages;
+using Microsoft.CmdPal.Common.Helpers;
+using Microsoft.CmdPal.Common.Text;
 using Microsoft.CmdPal.Ext.Apps;
 using Microsoft.CmdPal.Ext.Apps.Programs;
 using Microsoft.CmdPal.Ext.Apps.State;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/MainListPageResultFactory.cs

@@ -4,7 +4,7 @@
 
 #pragma warning disable IDE0007 // Use implicit type
 
-using Microsoft.CmdPal.Core.Common.Helpers;
+using Microsoft.CmdPal.Common.Helpers;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/NewExtensionFormBase.cs

@@ -6,7 +6,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.IO.Compression;
 using System.Text.Json;
 using System.Text.Json.Nodes;
-using Microsoft.CmdPal.Core.ViewModels.Messages;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 using Windows.Foundation;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/ReloadExtensionsCommand.cs

@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using CommunityToolkit.Mvvm.Messaging;
-using Microsoft.CmdPal.Core.ViewModels.Messages;
 using Microsoft.CmdPal.UI.ViewModels.Messages;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ConfirmResultViewModel.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class ConfirmResultViewModel(IConfirmationArgs _args, WeakReference<IPageContext> context) :
+    ExtensionObjectViewModel(context)
+{
+    public ExtensionObject<IConfirmationArgs> Model { get; } = new(_args);
+
+    // Remember - "observable" properties from the model (via PropChanged)
+    // cannot be marked [ObservableProperty]
+    public string Title { get; private set; } = string.Empty;
+
+    public string Description { get; private set; } = string.Empty;
+
+    public bool IsPrimaryCommandCritical { get; private set; }
+
+    public CommandViewModel PrimaryCommand { get; private set; } = new(null, context);
+
+    public override void InitializeProperties()
+    {
+        var model = Model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Title = model.Title;
+        Description = model.Description;
+        IsPrimaryCommandCritical = model.IsPrimaryCommandCritical;
+        PrimaryCommand = new(model.PrimaryCommand, PageContext);
+        PrimaryCommand.InitializeProperties();
+
+        UpdateProperty(nameof(Title));
+        UpdateProperty(nameof(Description));
+        UpdateProperty(nameof(IsPrimaryCommandCritical));
+        UpdateProperty(nameof(PrimaryCommand));
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContentFormViewModel.cs

@@ -8,9 +8,9 @@ using AdaptiveCards.ObjectModel.WinUI3;
 using AdaptiveCards.Templating;
 using CommunityToolkit.Mvvm.Messaging;
 using ManagedCommon;
-using Microsoft.CmdPal.Core.ViewModels;
-using Microsoft.CmdPal.Core.ViewModels.Messages;
-using Microsoft.CmdPal.Core.ViewModels.Models;
+using Microsoft.CmdPal.UI.ViewModels;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
+using Microsoft.CmdPal.UI.ViewModels.Models;
 using Microsoft.CommandPalette.Extensions;
 using Windows.Data.Json;
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContentMarkdownViewModel.cs

@@ -2,8 +2,8 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CmdPal.Core.ViewModels;
-using Microsoft.CmdPal.Core.ViewModels.Models;
+using Microsoft.CmdPal.UI.ViewModels;
+using Microsoft.CmdPal.UI.ViewModels.Models;
 using Microsoft.CommandPalette.Extensions;
 
 namespace Microsoft.CmdPal.UI.ViewModels;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContentPageViewModel.cs

@@ -0,0 +1,293 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class ContentPageViewModel : PageViewModel, ICommandBarContext
+{
+    private readonly ExtensionObject<IContentPage> _model;
+
+    [ObservableProperty]
+    public partial ObservableCollection<ContentViewModel> Content { get; set; } = [];
+
+    public List<IContextItemViewModel> Commands { get; private set; } = [];
+
+    public bool HasCommands => ActualCommands.Count > 0;
+
+    public DetailsViewModel? Details { get; private set; }
+
+    [MemberNotNullWhen(true, nameof(Details))]
+    public bool HasDetails => Details is not null;
+
+    /////// ICommandBarContext ///////
+    public IEnumerable<IContextItemViewModel> MoreCommands => Commands.Skip(1);
+
+    private List<CommandContextItemViewModel> ActualCommands => Commands.OfType<CommandContextItemViewModel>().ToList();
+
+    public bool HasMoreCommands => ActualCommands.Count > 1;
+
+    public string SecondaryCommandName => SecondaryCommand?.Name ?? string.Empty;
+
+    public CommandItemViewModel? PrimaryCommand => HasCommands ? ActualCommands[0] : null;
+
+    public CommandItemViewModel? SecondaryCommand => HasMoreCommands ? ActualCommands[1] : null;
+
+    public List<IContextItemViewModel> AllCommands => Commands;
+
+    // Remember - "observable" properties from the model (via PropChanged)
+    // cannot be marked [ObservableProperty]
+    public ContentPageViewModel(IContentPage model, TaskScheduler scheduler, AppExtensionHost host, CommandProviderContext providerContext)
+        : base(model, scheduler, host, providerContext)
+    {
+        _model = new(model);
+    }
+
+    // TODO: Does this need to hop to a _different_ thread, so that we don't block the extension while we're fetching?
+    private void Model_ItemsChanged(object sender, IItemsChangedEventArgs args) => FetchContent();
+
+    //// Run on background thread, from InitializeAsync or Model_ItemsChanged
+    private void FetchContent()
+    {
+        List<ContentViewModel> newContent = [];
+        try
+        {
+            var newItems = _model.Unsafe!.GetContent();
+
+            foreach (var item in newItems)
+            {
+                var viewModel = ViewModelFromContent(item, PageContext);
+                if (viewModel is not null)
+                {
+                    viewModel.InitializeProperties();
+                    newContent.Add(viewModel);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex, _model?.Unsafe?.Name);
+            throw;
+        }
+
+        var oneContent = newContent.Count == 1;
+        newContent.ForEach(c => c.OnlyControlOnPage = oneContent);
+
+        // Now, back to a UI thread to update the observable collection
+        DoOnUiThread(
+        () =>
+        {
+            ListHelpers.InPlaceUpdateList(Content, newContent);
+        });
+    }
+
+    public virtual ContentViewModel? ViewModelFromContent(IContent content, WeakReference<IPageContext> context)
+    {
+        // The core ContentPageViewModel doesn't actually handle any content,
+        // so we just return null here.
+        // The real content is handled by the derived class CommandPaletteContentPageViewModel
+        return null;
+    }
+
+    public override void InitializeProperties()
+    {
+        base.InitializeProperties();
+
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        Commands = model.Commands
+                .ToList()
+                .Select<IContextItem, IContextItemViewModel>(item =>
+                {
+                    if (item is ICommandContextItem contextItem)
+                    {
+                        return new CommandContextItemViewModel(contextItem, PageContext);
+                    }
+                    else
+                    {
+                        return new SeparatorViewModel();
+                    }
+                })
+                .ToList();
+
+        Commands
+            .OfType<CommandContextItemViewModel>()
+            .ToList()
+            .ForEach(contextItem =>
+            {
+                contextItem.InitializeProperties();
+            });
+
+        var extensionDetails = model.Details;
+        if (extensionDetails is not null)
+        {
+            Details = new(extensionDetails, PageContext);
+            Details.InitializeProperties();
+        }
+
+        UpdateDetails();
+
+        FetchContent();
+        model.ItemsChanged += Model_ItemsChanged;
+
+        DoOnUiThread(
+        () =>
+        {
+            WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(this));
+        });
+    }
+
+    protected override void FetchProperty(string propertyName)
+    {
+        base.FetchProperty(propertyName);
+
+        var model = this._model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        switch (propertyName)
+        {
+            case nameof(Commands):
+
+                var more = model.Commands;
+                if (more is not null)
+                {
+                    var newContextMenu = more
+                            .ToList()
+                            .Select(item =>
+                            {
+                                if (item is ICommandContextItem contextItem)
+                                {
+                                    return new CommandContextItemViewModel(contextItem, PageContext) as IContextItemViewModel;
+                                }
+                                else
+                                {
+                                    return new SeparatorViewModel();
+                                }
+                            })
+                            .ToList();
+
+                    lock (Commands)
+                    {
+                        ListHelpers.InPlaceUpdateList(Commands, newContextMenu);
+                    }
+
+                    Commands
+                        .OfType<CommandContextItemViewModel>()
+                        .ToList()
+                        .ForEach(contextItem =>
+                        {
+                            contextItem.SlowInitializeProperties();
+                        });
+                }
+                else
+                {
+                    Commands.Clear();
+                }
+
+                UpdateProperty(nameof(PrimaryCommand));
+                UpdateProperty(nameof(SecondaryCommand));
+                UpdateProperty(nameof(SecondaryCommandName));
+                UpdateProperty(nameof(HasCommands));
+                UpdateProperty(nameof(HasMoreCommands));
+                UpdateProperty(nameof(AllCommands));
+                DoOnUiThread(
+                () =>
+                {
+                    WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(this));
+                });
+
+                break;
+            case nameof(Details):
+                var extensionDetails = model.Details;
+                Details = extensionDetails is not null ? new(extensionDetails, PageContext) : null;
+                UpdateDetails();
+                break;
+        }
+
+        UpdateProperty(propertyName);
+    }
+
+    private void UpdateDetails()
+    {
+        UpdateProperty(nameof(Details));
+        UpdateProperty(nameof(HasDetails));
+
+        DoOnUiThread(
+            () =>
+            {
+                if (HasDetails)
+                {
+                    WeakReferenceMessenger.Default.Send<ShowDetailsMessage>(new(Details));
+                }
+                else
+                {
+                    WeakReferenceMessenger.Default.Send<HideDetailsMessage>();
+                }
+            });
+    }
+
+    // InvokeItemCommand is what this will be in Xaml due to source generator
+    // this comes in on Enter keypresses in the SearchBox
+    [RelayCommand]
+    private void InvokePrimaryCommand(ContentPageViewModel page)
+    {
+        if (PrimaryCommand is not null)
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(PrimaryCommand.Command.Model, PrimaryCommand.Model));
+        }
+    }
+
+    // this comes in on Ctrl+Enter keypresses in the SearchBox
+    [RelayCommand]
+    private void InvokeSecondaryCommand(ContentPageViewModel page)
+    {
+        if (SecondaryCommand is not null)
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(SecondaryCommand.Command.Model, SecondaryCommand.Model));
+        }
+    }
+
+    protected override void UnsafeCleanup()
+    {
+        base.UnsafeCleanup();
+
+        Details?.SafeCleanup();
+
+        Commands
+            .OfType<CommandContextItemViewModel>()
+            .ToList()
+            .ForEach(item => item.SafeCleanup());
+
+        Commands.Clear();
+
+        foreach (var item in Content)
+        {
+            item.SafeCleanup();
+        }
+
+        Content.Clear();
+
+        var model = _model.Unsafe;
+        if (model is not null)
+        {
+            model.ItemsChanged -= Model_ItemsChanged;
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContentTreeViewModel.cs

@@ -3,8 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.ObjectModel;
-using Microsoft.CmdPal.Core.ViewModels;
-using Microsoft.CmdPal.Core.ViewModels.Models;
+using Microsoft.CmdPal.UI.ViewModels;
+using Microsoft.CmdPal.UI.ViewModels.Models;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContentViewModel.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public abstract partial class ContentViewModel(WeakReference<IPageContext> context) :
+    ExtensionObjectViewModel(context)
+{
+    public bool OnlyControlOnPage { get; internal set; }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContextMenuViewModel.cs

@@ -0,0 +1,243 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using System.Runtime.CompilerServices;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.CmdPal.Common;
+using Microsoft.CmdPal.Common.Helpers;
+using Microsoft.CmdPal.Common.Text;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.System;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class ContextMenuViewModel : ObservableObject,
+    IRecipient<UpdateCommandBarMessage>
+{
+    private readonly IFuzzyMatcherProvider _fuzzyMatcherProvider;
+
+    public ICommandBarContext? SelectedItem
+    {
+        get => field;
+        set
+        {
+            field = value;
+            UpdateContextItems();
+        }
+    }
+
+    [ObservableProperty]
+    private partial ObservableCollection<List<IContextItemViewModel>> ContextMenuStack { get; set; } = [];
+
+    private List<IContextItemViewModel>? CurrentContextMenu => ContextMenuStack.LastOrDefault();
+
+    [ObservableProperty]
+    public partial ObservableCollection<IContextItemViewModel> FilteredItems { get; set; } = [];
+
+    [ObservableProperty]
+    public partial bool FilterOnTop { get; set; } = false;
+
+    private string _lastSearchText = string.Empty;
+
+    public ContextMenuViewModel(IFuzzyMatcherProvider fuzzyMatcherProvider)
+    {
+        _fuzzyMatcherProvider = fuzzyMatcherProvider;
+        WeakReferenceMessenger.Default.Register<UpdateCommandBarMessage>(this);
+    }
+
+    public void Receive(UpdateCommandBarMessage message)
+    {
+        SelectedItem = message.ViewModel;
+    }
+
+    public void UpdateContextItems()
+    {
+        if (SelectedItem is not null)
+        {
+            if (SelectedItem.PrimaryCommand is not null || SelectedItem.HasMoreCommands)
+            {
+                ContextMenuStack.Clear();
+                PushContextStack(SelectedItem.AllCommands);
+            }
+        }
+    }
+
+    public void SetSearchText(string searchText)
+    {
+        if (searchText == _lastSearchText)
+        {
+            return;
+        }
+
+        if (SelectedItem is null)
+        {
+            return;
+        }
+
+        _lastSearchText = searchText;
+
+        if (CurrentContextMenu is null)
+        {
+            ListHelpers.InPlaceUpdateList(FilteredItems, []);
+            return;
+        }
+
+        if (string.IsNullOrEmpty(searchText))
+        {
+            ListHelpers.InPlaceUpdateList(FilteredItems, CurrentContextMenu);
+            return;
+        }
+
+        var commands = CurrentContextMenu
+                            .OfType<CommandContextItemViewModel>()
+                            .Where(c => c.ShouldBeVisible);
+
+        var query = _fuzzyMatcherProvider.Current.PrecomputeQuery(searchText);
+        var newResults = InternalListHelpers.FilterList(commands, in query, ScoreFunction);
+        ListHelpers.InPlaceUpdateList(FilteredItems, newResults);
+    }
+
+    private int ScoreFunction(in FuzzyQuery query, CommandContextItemViewModel item)
+    {
+        if (string.IsNullOrWhiteSpace(query.Original))
+        {
+            return 1;
+        }
+
+        if (string.IsNullOrEmpty(item.Title))
+        {
+            return 0;
+        }
+
+        var fuzzyMatcher = _fuzzyMatcherProvider.Current;
+        var title = item.GetTitleTarget(fuzzyMatcher);
+        var subtitle = item.GetSubtitleTarget(fuzzyMatcher);
+
+        var titleScore = fuzzyMatcher.Score(query, title);
+        var subtitleScore = (fuzzyMatcher.Score(query, subtitle) - 4) / 2;
+
+        return Max3(titleScore, subtitleScore, 0);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Max3(int a, int b, int c)
+    {
+        var m = a > b ? a : b;
+        return m > c ? m : c;
+    }
+
+    /// <summary>
+    /// Generates a mapping of key -> command item for this particular item's
+    /// MoreCommands. (This won't include the primary Command, but it will
+    /// include the secondary one). This map can be used to quickly check if a
+    /// shortcut key was pressed. In case there are duplicate keybindings, the first
+    /// one is used and the rest are ignored.
+    /// </summary>
+    /// <returns>a dictionary of KeyChord -> Context commands, for all commands
+    /// that have a shortcut key set.</returns>
+    private Dictionary<KeyChord, CommandContextItemViewModel> Keybindings()
+    {
+        var result = new Dictionary<KeyChord, CommandContextItemViewModel>();
+
+        var menu = CurrentContextMenu;
+        if (menu is null)
+        {
+            return result;
+        }
+
+        foreach (var item in menu)
+        {
+            if (item is CommandContextItemViewModel cmd && cmd.HasRequestedShortcut)
+            {
+                var key = cmd.RequestedShortcut ?? new KeyChord(0, 0, 0);
+                var added = result.TryAdd(key, cmd);
+                if (!added)
+                {
+                    CoreLogger.LogWarning($"Ignoring duplicate keyboard shortcut {KeyChordHelpers.FormatForDebug(key)} on command '{cmd.Title ?? cmd.Name ?? "(unknown)"}'");
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public ContextKeybindingResult? CheckKeybinding(bool ctrl, bool alt, bool shift, bool win, VirtualKey key)
+    {
+        var keybindings = Keybindings();
+
+        // Does the pressed key match any of the keybindings?
+        var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrl, alt, shift, win, key, 0);
+        return keybindings.TryGetValue(pressedKeyChord, out var item) ? InvokeCommand(item) : null;
+    }
+
+    public bool CanPopContextStack()
+    {
+        return ContextMenuStack.Count > 1;
+    }
+
+    public void PopContextStack()
+    {
+        if (ContextMenuStack.Count > 1)
+        {
+            ContextMenuStack.RemoveAt(ContextMenuStack.Count - 1);
+        }
+
+        OnPropertyChanging(nameof(CurrentContextMenu));
+        OnPropertyChanged(nameof(CurrentContextMenu));
+
+        ListHelpers.InPlaceUpdateList(FilteredItems, CurrentContextMenu!);
+    }
+
+    private void PushContextStack(IEnumerable<IContextItemViewModel> commands)
+    {
+        ContextMenuStack.Add(commands.ToList());
+        OnPropertyChanging(nameof(CurrentContextMenu));
+        OnPropertyChanged(nameof(CurrentContextMenu));
+
+        ListHelpers.InPlaceUpdateList(FilteredItems, CurrentContextMenu!);
+    }
+
+    public void ResetContextMenu()
+    {
+        while (ContextMenuStack.Count > 1)
+        {
+            ContextMenuStack.RemoveAt(ContextMenuStack.Count - 1);
+        }
+
+        OnPropertyChanging(nameof(CurrentContextMenu));
+        OnPropertyChanged(nameof(CurrentContextMenu));
+
+        if (CurrentContextMenu is not null)
+        {
+            ListHelpers.InPlaceUpdateList(FilteredItems, CurrentContextMenu!);
+        }
+    }
+
+    public ContextKeybindingResult InvokeCommand(CommandItemViewModel? command)
+    {
+        if (command is null)
+        {
+            return ContextKeybindingResult.Unhandled;
+        }
+
+        if (command.HasMoreCommands)
+        {
+            // Display the commands child commands
+            PushContextStack(command.AllCommands);
+            OnPropertyChanging(nameof(FilteredItems));
+            OnPropertyChanged(nameof(FilteredItems));
+            return ContextKeybindingResult.KeepOpen;
+        }
+        else
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(command.Command.Model, command.Model));
+            UpdateContextItems();
+            return ContextKeybindingResult.Hide;
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/DetailsCommandsViewModel.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class DetailsCommandsViewModel(
+    IDetailsElement _detailsElement,
+    WeakReference<IPageContext> context) : DetailsElementViewModel(_detailsElement, context)
+{
+    public List<CommandViewModel> Commands { get; private set; } = [];
+
+    public bool HasCommands => Commands.Count > 0;
+
+    private readonly ExtensionObject<IDetailsCommands> _dataModel =
+        new(_detailsElement.Data as IDetailsCommands);
+
+    public override void InitializeProperties()
+    {
+        base.InitializeProperties();
+        var model = _dataModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Commands = model
+            .Commands?
+            .Select(c =>
+            {
+                var vm = new CommandViewModel(c, PageContext);
+                vm.InitializeProperties();
+                return vm;
+            })
+            .ToList() ?? [];
+        UpdateProperty(nameof(HasCommands));
+        UpdateProperty(nameof(Commands));
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/DetailsDataViewModel.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public abstract partial class DetailsDataViewModel(IPageContext context) : ExtensionObjectViewModel(context)
+{
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/DetailsElementViewModel.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public abstract partial class DetailsElementViewModel(IDetailsElement _detailsElement, WeakReference<IPageContext> context) : ExtensionObjectViewModel(context)
+{
+    private readonly ExtensionObject<IDetailsElement> _model = new(_detailsElement);
+
+    public string Key { get; private set; } = string.Empty;
+
+    public override void InitializeProperties()
+    {
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Key = model.Key ?? string.Empty;
+        UpdateProperty(nameof(Key));
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/DetailsLinkViewModel.cs

@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class DetailsLinkViewModel(
+    IDetailsElement _detailsElement,
+    WeakReference<IPageContext> context) : DetailsElementViewModel(_detailsElement, context)
+{
+    private static readonly string[] _initProperties = [
+        nameof(Text),
+        nameof(Link),
+        nameof(IsLink),
+        nameof(IsText),
+        nameof(NavigateCommand)];
+
+    private readonly ExtensionObject<IDetailsLink> _dataModel =
+        new(_detailsElement.Data as IDetailsLink);
+
+    public string Text { get; private set; } = string.Empty;
+
+    public Uri? Link { get; private set; }
+
+    public bool IsLink => Link is not null;
+
+    public bool IsText => !IsLink;
+
+    public RelayCommand? NavigateCommand { get; private set; }
+
+    public override void InitializeProperties()
+    {
+        base.InitializeProperties();
+        var model = _dataModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Text = model.Text ?? string.Empty;
+        Link = model.Link;
+        if (string.IsNullOrEmpty(Text) && Link is not null)
+        {
+            Text = Link.ToString();
+        }
+
+        if (Link is not null)
+        {
+            // Custom command to open a link in the default browser or app,
+            // depending on the link type.
+            // Binding Link to a Hyperlink(Button).NavigateUri works only for
+            // certain URI schemes (e.g., http, https) and cannot open file:
+            // scheme URIs or local files.
+            NavigateCommand = new RelayCommand(
+                () => ShellHelpers.OpenInShell(Link.ToString()),
+                () => Link is not null);
+        }
+
+        UpdateProperty(_initProperties);
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/DetailsSeparatorViewModel.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class DetailsSeparatorViewModel(
+    IDetailsElement _detailsElement,
+    WeakReference<IPageContext> context) : DetailsElementViewModel(_detailsElement, context)
+{
+    private readonly ExtensionObject<IDetailsSeparator> _dataModel =
+        new(_detailsElement.Data as IDetailsSeparator);
+
+    public override void InitializeProperties()
+    {
+        base.InitializeProperties();
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/DetailsTagsViewModel.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class DetailsTagsViewModel(
+    IDetailsElement _detailsElement,
+    WeakReference<IPageContext> context) : DetailsElementViewModel(_detailsElement, context)
+{
+    public List<TagViewModel> Tags { get; private set; } = [];
+
+    public bool HasTags => Tags.Count > 0;
+
+    private readonly ExtensionObject<IDetailsTags> _dataModel =
+        new(_detailsElement.Data as IDetailsTags);
+
+    public override void InitializeProperties()
+    {
+        base.InitializeProperties();
+        var model = _dataModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Tags = model
+            .Tags?
+            .Select(t =>
+        {
+            var vm = new TagViewModel(t, PageContext);
+            vm.InitializeProperties();
+            return vm;
+        })
+            .ToList() ?? [];
+        UpdateProperty(nameof(HasTags));
+        UpdateProperty(nameof(Tags));
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/DetailsViewModel.cs

@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class DetailsViewModel(IDetails _details, WeakReference<IPageContext> context) : ExtensionObjectViewModel(context)
+{
+    private readonly ExtensionObject<IDetails> _detailsModel = new(_details);
+
+    // Remember - "observable" properties from the model (via PropChanged)
+    // cannot be marked [ObservableProperty]
+    public IconInfoViewModel HeroImage { get; private set; } = new(null);
+
+    public string Title { get; private set; } = string.Empty;
+
+    public string Body { get; private set; } = string.Empty;
+
+    public ContentSize? Size { get; private set; } = ContentSize.Small;
+
+    // Metadata is an array of IDetailsElement,
+    //   where IDetailsElement = {IDetailsTags, IDetailsLink, IDetailsSeparator}
+    public List<DetailsElementViewModel> Metadata { get; private set; } = [];
+
+    public override void InitializeProperties()
+    {
+        var model = _detailsModel.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Title = model.Title ?? string.Empty;
+        Body = model.Body ?? string.Empty;
+        HeroImage = new(model.HeroImage);
+        HeroImage.InitializeProperties();
+
+        UpdateProperty(nameof(Title));
+        UpdateProperty(nameof(Body));
+        UpdateProperty(nameof(HeroImage));
+
+        if (model is IExtendedAttributesProvider provider)
+        {
+            if (provider.GetProperties()?.TryGetValue("Size", out var rawValue) == true)
+            {
+                if (rawValue is int sizeAsInt)
+                {
+                    Size = (ContentSize)sizeAsInt;
+                }
+            }
+        }
+
+        Size ??= ContentSize.Small;
+
+        UpdateProperty(nameof(Size));
+
+        var meta = model.Metadata;
+        if (meta is not null)
+        {
+            foreach (var element in meta)
+            {
+                DetailsElementViewModel? vm = element.Data switch
+                {
+                    IDetailsSeparator => new DetailsSeparatorViewModel(element, this.PageContext),
+                    IDetailsLink => new DetailsLinkViewModel(element, this.PageContext),
+                    IDetailsCommands => new DetailsCommandsViewModel(element, this.PageContext),
+                    IDetailsTags => new DetailsTagsViewModel(element, this.PageContext),
+                    _ => null,
+                };
+                if (vm is not null)
+                {
+                    vm.InitializeProperties();
+                    Metadata.Add(vm);
+                }
+            }
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ExtensionObjectViewModel.cs

@@ -0,0 +1,285 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using System.Collections.Concurrent;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Microsoft.CmdPal.Common;
+using Microsoft.CmdPal.Common.Helpers;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public abstract partial class ExtensionObjectViewModel : ObservableObject, IBatchUpdateTarget, IBackgroundPropertyChangedNotification
+{
+    private const int InitialPropertyBatchingBufferSize = 16;
+
+    // Raised on the background thread before UI notifications. It's raised on the background thread to prevent
+    // blocking the COM proxy.
+    public event PropertyChangedEventHandler? PropertyChangedBackground;
+
+    private readonly ConcurrentQueue<string> _pendingProps = [];
+
+    private readonly TaskScheduler _uiScheduler;
+
+    private InterlockedBoolean _batchQueued;
+
+    public WeakReference<IPageContext> PageContext { get; private set; } = null!;
+
+    TaskScheduler IBatchUpdateTarget.UIScheduler => _uiScheduler;
+
+    void IBatchUpdateTarget.ApplyPendingUpdates() => ApplyPendingUpdates();
+
+    bool IBatchUpdateTarget.TryMarkBatchQueued() => _batchQueued.Set();
+
+    void IBatchUpdateTarget.ClearBatchQueued() => _batchQueued.Clear();
+
+    private protected ExtensionObjectViewModel(TaskScheduler scheduler)
+    {
+        if (this is not IPageContext)
+        {
+            throw new InvalidOperationException($"Constructor overload without IPageContext can only be used when the derived class implements IPageContext. Type: {GetType().FullName}");
+        }
+
+        _uiScheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
+
+        // Defer PageContext assignment - derived constructor MUST call InitializePageContext()
+        // or we set it lazily on first access
+    }
+
+    private protected ExtensionObjectViewModel(IPageContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+
+        PageContext = new WeakReference<IPageContext>(context);
+        _uiScheduler = context.Scheduler;
+
+        LogIfDefaultScheduler();
+    }
+
+    private protected ExtensionObjectViewModel(WeakReference<IPageContext> contextRef)
+    {
+        ArgumentNullException.ThrowIfNull(contextRef);
+
+        if (!contextRef.TryGetTarget(out var context))
+        {
+            throw new ArgumentException("IPageContext must be alive when creating view models.", nameof(contextRef));
+        }
+
+        PageContext = contextRef;
+        _uiScheduler = context.Scheduler;
+
+        LogIfDefaultScheduler();
+    }
+
+    protected void InitializeSelfAsPageContext()
+    {
+        if (this is not IPageContext self)
+        {
+            throw new InvalidOperationException("This method can only be called when the class implements IPageContext.");
+        }
+
+        PageContext = new WeakReference<IPageContext>(self);
+    }
+
+    private void LogIfDefaultScheduler()
+    {
+        if (_uiScheduler == TaskScheduler.Default)
+        {
+            CoreLogger.LogDebug($"ExtensionObjectViewModel created with TaskScheduler.Default. Type: {GetType().FullName}");
+        }
+    }
+
+    public virtual Task InitializePropertiesAsync()
+        => Task.Run(SafeInitializePropertiesSynchronous);
+
+    public void SafeInitializePropertiesSynchronous()
+    {
+        try
+        {
+            InitializeProperties();
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex);
+        }
+    }
+
+    public abstract void InitializeProperties();
+
+    protected void UpdateProperty(string propertyName) => MarkPropertyDirty(propertyName);
+
+    protected void UpdateProperty(string propertyName1, string propertyName2)
+    {
+        MarkPropertyDirty(propertyName1);
+        MarkPropertyDirty(propertyName2);
+    }
+
+    protected void UpdateProperty(params string[] propertyNames)
+    {
+        foreach (var p in propertyNames)
+        {
+            MarkPropertyDirty(p);
+        }
+    }
+
+    internal void MarkPropertyDirty(string? propertyName)
+    {
+        if (string.IsNullOrEmpty(propertyName))
+        {
+            return;
+        }
+
+        // We should re-consider if this worth deduping
+        _pendingProps.Enqueue(propertyName);
+        BatchUpdateManager.Queue(this);
+    }
+
+    public void ApplyPendingUpdates()
+    {
+        ((IBatchUpdateTarget)this).ClearBatchQueued();
+
+        var buffer = ArrayPool<string>.Shared.Rent(InitialPropertyBatchingBufferSize);
+        var count = 0;
+        var transferred = false;
+
+        try
+        {
+            while (_pendingProps.TryDequeue(out var name))
+            {
+                if (count == buffer.Length)
+                {
+                    var bigger = ArrayPool<string>.Shared.Rent(buffer.Length * 2);
+                    Array.Copy(buffer, bigger, buffer.Length);
+                    ArrayPool<string>.Shared.Return(buffer, clearArray: true);
+                    buffer = bigger;
+                }
+
+                buffer[count++] = name;
+            }
+
+            if (count == 0)
+            {
+                return;
+            }
+
+            // 1) Background subscribers (must be raised before UI notifications).
+            var propertyChangedEventHandler = PropertyChangedBackground;
+            if (propertyChangedEventHandler is not null)
+            {
+                RaiseBackground(propertyChangedEventHandler, this, buffer, count);
+            }
+
+            // 2) UI-facing PropertyChanged: ALWAYS marshal to UI scheduler.
+            // Hand-off pooled buffer to UI task (UI task returns it).
+            //
+            // It would be lovely to do nothing if no one is actually listening on PropertyChanged,
+            // but ObservableObject doesn't expose that information.
+            _ = Task.Factory.StartNew(
+                static state =>
+                {
+                    var p = (UiBatch)state!;
+                    try
+                    {
+                        p.Owner.RaiseUi(p.Names, p.Count);
+                    }
+                    catch (Exception ex)
+                    {
+                        CoreLogger.LogError("Failed to raise property change notifications on UI thread.", ex);
+                    }
+                    finally
+                    {
+                        ArrayPool<string>.Shared.Return(p.Names, clearArray: true);
+                    }
+                },
+                new UiBatch(this, buffer, count),
+                CancellationToken.None,
+                TaskCreationOptions.DenyChildAttach,
+                _uiScheduler);
+
+            transferred = true;
+        }
+        catch (Exception ex)
+        {
+            CoreLogger.LogError("Failed to apply pending property updates.", ex);
+        }
+        finally
+        {
+            if (!transferred)
+            {
+                ArrayPool<string>.Shared.Return(buffer, clearArray: true);
+            }
+        }
+    }
+
+    private void RaiseUi(string[] names, int count)
+    {
+        for (var i = 0; i < count; i++)
+        {
+            OnPropertyChanged(Args(names[i]));
+        }
+    }
+
+    private static void RaiseBackground(PropertyChangedEventHandler handlers, object sender, string[] names, int count)
+    {
+        try
+        {
+            for (var i = 0; i < count; i++)
+            {
+                handlers(sender, Args(names[i]));
+            }
+        }
+        catch (Exception ex)
+        {
+            CoreLogger.LogError("Failed to raise PropertyChangedBackground notifications.", ex);
+        }
+    }
+
+    private sealed record UiBatch(ExtensionObjectViewModel Owner, string[] Names, int Count);
+
+    protected void ShowException(Exception ex, string? extensionHint = null)
+    {
+        if (PageContext.TryGetTarget(out var pageContext))
+        {
+            pageContext.ShowException(ex, extensionHint);
+        }
+        else
+        {
+            CoreLogger.LogError("Failed to show exception because PageContext is no longer available.", ex);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static PropertyChangedEventArgs Args(string name) => new(name);
+
+    protected void DoOnUiThread(Action action)
+    {
+        if (PageContext.TryGetTarget(out var pageContext))
+        {
+            Task.Factory.StartNew(
+                action,
+                CancellationToken.None,
+                TaskCreationOptions.None,
+                pageContext.Scheduler);
+        }
+    }
+
+    protected virtual void UnsafeCleanup()
+    {
+        // base doesn't do anything, but sub-classes should override this.
+    }
+
+    public virtual void SafeCleanup()
+    {
+        try
+        {
+            UnsafeCleanup();
+        }
+        catch (Exception ex)
+        {
+            CoreLogger.LogDebug(ex.ToString());
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/FallbackSettingsViewModel.cs

@@ -4,7 +4,6 @@
 
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Messaging;
-using Microsoft.CmdPal.Core.ViewModels;
 using Microsoft.CmdPal.UI.ViewModels.Messages;
 
 namespace Microsoft.CmdPal.UI.ViewModels;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/FilterItemViewModel.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class FilterItemViewModel : ExtensionObjectViewModel, IFilterItemViewModel
+{
+    private readonly ExtensionObject<IFilter> _model;
+
+    public string Id { get; set; } = string.Empty;
+
+    public string Name { get; set; } = string.Empty;
+
+    public IconInfoViewModel Icon { get; set; } = new(null);
+
+    internal InitializedState Initialized { get; private set; } = InitializedState.Uninitialized;
+
+    protected bool IsInitialized => IsInErrorState || Initialized.HasFlag(InitializedState.Initialized);
+
+    public bool IsInErrorState => Initialized.HasFlag(InitializedState.Error);
+
+    public FilterItemViewModel(IFilter filter, WeakReference<IPageContext> context)
+        : base(context)
+    {
+        _model = new(filter);
+    }
+
+    public override void InitializeProperties()
+    {
+        if (IsInitialized)
+        {
+            return;
+        }
+
+        var filter = _model.Unsafe;
+        if (filter == null)
+        {
+            return; // throw?
+        }
+
+        Id = filter.Id;
+        Name = filter.Name;
+        Icon = new(filter.Icon);
+        if (Icon is not null)
+        {
+            Icon.InitializeProperties();
+        }
+
+        UpdateProperty(nameof(Id));
+        UpdateProperty(nameof(Name));
+        UpdateProperty(nameof(Icon));
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/FiltersViewModel.cs

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class FiltersViewModel : ExtensionObjectViewModel
+{
+    private readonly ExtensionObject<IFilters> _filtersModel;
+
+    public string CurrentFilterId { get; private set; } = string.Empty;
+
+    public IFilterItemViewModel? CurrentFilter { get; private set; }
+
+    public IFilterItemViewModel[] Filters { get; private set; } = [];
+
+    public bool ShouldShowFilters => Filters.Length > 0;
+
+    public FiltersViewModel(ExtensionObject<IFilters> filters, WeakReference<IPageContext> context)
+        : base(context)
+    {
+        _filtersModel = filters;
+    }
+
+    public override void InitializeProperties()
+    {
+        try
+        {
+            if (_filtersModel.Unsafe is not null)
+            {
+                var filters = _filtersModel.Unsafe.GetFilters();
+                var currentFilterId = _filtersModel.Unsafe.CurrentFilterId ?? string.Empty;
+
+                var result = BuildFilters(filters ?? [], currentFilterId);
+                Filters = result.Items;
+                CurrentFilterId = currentFilterId;
+                CurrentFilter = result.Selected;
+                UpdateProperty(nameof(Filters), nameof(ShouldShowFilters), nameof(CurrentFilterId), nameof(CurrentFilter));
+
+                return;
+            }
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex, _filtersModel.Unsafe?.GetType().Name);
+        }
+
+        Filters = [];
+        CurrentFilterId = string.Empty;
+        CurrentFilter = null;
+        UpdateProperty(nameof(Filters), nameof(ShouldShowFilters), nameof(CurrentFilterId), nameof(CurrentFilter));
+    }
+
+    private (IFilterItemViewModel[] Items, IFilterItemViewModel? Selected) BuildFilters(IFilterItem[] filters, string currentFilterId)
+    {
+        if (filters is null || filters.Length == 0)
+        {
+            return ([], null);
+        }
+
+        var items = new List<IFilterItemViewModel>(filters.Length);
+        FilterItemViewModel? firstFilterItem = null;
+        FilterItemViewModel? selectedFilterItem = null;
+
+        foreach (var filter in filters)
+        {
+            if (filter is IFilter filterItem)
+            {
+                var filterItemViewModel = new FilterItemViewModel(filterItem, PageContext);
+                filterItemViewModel.InitializeProperties();
+
+                if (firstFilterItem is null)
+                {
+                    firstFilterItem = filterItemViewModel;
+                }
+
+                if (selectedFilterItem is null && filterItemViewModel.Id == currentFilterId)
+                {
+                    selectedFilterItem = filterItemViewModel;
+                }
+
+                items.Add(filterItemViewModel);
+            }
+            else
+            {
+                items.Add(new SeparatorViewModel());
+            }
+        }
+
+        return (items.ToArray(), selectedFilterItem ?? firstFilterItem);
+    }
+
+    public override void SafeCleanup()
+    {
+        base.SafeCleanup();
+
+        foreach (var filter in Filters)
+        {
+            if (filter is FilterItemViewModel filterItemViewModel)
+            {
+                filterItemViewModel.SafeCleanup();
+            }
+        }
+
+        Filters = [];
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/GalleryGridPropertiesViewModel.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public class GalleryGridPropertiesViewModel : IGridPropertiesViewModel
+{
+    private readonly ExtensionObject<IGalleryGridLayout> _model;
+
+    public bool ShowTitle { get; private set; }
+
+    public bool ShowSubtitle { get; private set; }
+
+    public GalleryGridPropertiesViewModel(IGalleryGridLayout galleryGridLayout)
+    {
+        _model = new(galleryGridLayout);
+    }
+
+    public void InitializeProperties()
+    {
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        ShowTitle = model.ShowTitle;
+        ShowSubtitle = model.ShowSubtitle;
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/GlobalLogPageContext.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public class GlobalLogPageContext : IPageContext
+{
+    public TaskScheduler Scheduler { get; private init; }
+
+    public void ShowException(Exception ex, string? extensionHint)
+    { /*do nothing*/
+    }
+
+    public GlobalLogPageContext()
+    {
+        Scheduler = TaskScheduler.FromCurrentSynchronizationContext();
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/IBackgroundPropertyChangedNotification.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+/// <summary>
+/// Provides a notification mechanism for property changes that fires
+/// synchronously on the calling thread.
+/// </summary>
+public interface IBackgroundPropertyChangedNotification
+{
+    /// <summary>
+    /// Occurs when the value of a property changes.
+    /// </summary>
+    event PropertyChangedEventHandler? PropertyChangedBackground;
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/IContextItemViewModel.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+public interface IContextItemViewModel
+{
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/IFilterItemViewModel.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public interface IFilterItemViewModel
+{
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/IGridPropertiesViewModel.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public interface IGridPropertiesViewModel
+{
+    bool ShowTitle { get; }
+
+    bool ShowSubtitle { get; }
+
+    void InitializeProperties();
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/IRootPageService.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public interface IRootPageService
+{
+    /// <summary>
+    /// Gets the root page of the command palette. Return any IPage implementation that
+    /// represents the root view of this instance of the command palette.
+    /// </summary>
+    Microsoft.CommandPalette.Extensions.IPage GetRootPage();
+
+    /// <summary>
+    /// Pre-loads any necessary data or state before the root page is loaded.
+    /// This will be awaited before the root page and the user can do anything,
+    /// so ideally it should be quick and not block the UI thread for long.
+    /// </summary>
+    Task PreLoadAsync();
+
+    /// <summary>
+    /// Do any loading work that can be done after the root page is loaded and
+    /// displayed to the user.
+    /// This is run asynchronously, on a background thread.
+    /// </summary>
+    Task PostLoadRootPageAsync();
+
+    /// <summary>
+    /// Called when a command is performed. The context is the
+    /// sender context for the invoked command. This is typically the IListItem
+    /// or ICommandContextItem that was used to invoke the command.
+    /// </summary>
+    void OnPerformCommand(object? context, bool topLevel, AppExtensionHost? currentHost);
+
+    void GoHome();
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/IconDataViewModel.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Mvvm.ComponentModel;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Storage.Streams;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class IconDataViewModel : ObservableObject, IIconData
+{
+    private readonly ExtensionObject<IIconData> _model = new(null);
+
+    // If the extension previously gave us a Data, then died, the data will
+    // throw if we actually try to read it, but the pointer itself won't be
+    // null, so this is relatively safe.
+    public bool HasIcon => !string.IsNullOrEmpty(Icon) || Data.Unsafe is not null;
+
+    // Locally cached properties from IIconData.
+    public string Icon { get; private set; } = string.Empty;
+
+    // Streams are not trivially copy-able, so we can't copy the data locally
+    // first. Hence why we're sticking this into an ExtensionObject
+    public ExtensionObject<IRandomAccessStreamReference> Data { get; private set; } = new(null);
+
+    IRandomAccessStreamReference? IIconData.Data => Data.Unsafe;
+
+    public string? FontFamily { get; private set; }
+
+    public IconDataViewModel(IIconData? icon)
+    {
+        _model = new(icon);
+    }
+
+    // Unsafe, needs to be called on BG thread
+    public void InitializeProperties()
+    {
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Icon = model.Icon;
+        Data = new(model.Data);
+
+        if (model is IExtendedAttributesProvider icon2)
+        {
+            var props = icon2.GetProperties();
+
+            // From Raymond Chen:
+            // Make sure you don't try do do something like
+            //    icon2.GetProperties().TryGetValue("awesomeKey", out var awesomeValue);
+            //    icon2.GetProperties().TryGetValue("slackerKey", out var slackerValue);
+            // because each call to GetProperties() is a cross process hop, and if you
+            // marshal-by-value the property set, then you don't want to throw it away and
+            // re-marshal it for every property. MAKE SURE YOU CACHE IT.
+            if (props?.TryGetValue(WellKnownExtensionAttributes.FontFamily, out var family) ?? false)
+            {
+                FontFamily = family as string;
+            }
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/IconInfoViewModel.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Mvvm.ComponentModel;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class IconInfoViewModel : ObservableObject, IIconInfo
+{
+    private readonly ExtensionObject<IIconInfo> _model = new(null);
+
+    // These are properties that are "observable" from the extension object
+    // itself, in the sense that they get raised by PropChanged events from the
+    // extension. However, we don't want to actually make them
+    // [ObservableProperty]s, because PropChanged comes in off the UI thread,
+    // and ObservableProperty is not smart enough to raise the PropertyChanged
+    // on the UI thread.
+    public IconDataViewModel Light { get; private set; }
+
+    public IconDataViewModel Dark { get; private set; }
+
+    public IconDataViewModel IconForTheme(bool light) => Light = light ? Light : Dark;
+
+    public bool HasIcon(bool light) => IconForTheme(light).HasIcon;
+
+    public bool IsSet => _model.Unsafe is not null;
+
+    IIconData? IIconInfo.Dark => Dark;
+
+    IIconData? IIconInfo.Light => Light;
+
+    public IconInfoViewModel(IIconInfo? icon)
+    {
+        _model = new(icon);
+        Light = new(null);
+        Dark = new(null);
+    }
+
+    // Unsafe, needs to be called on BG thread
+    public void InitializeProperties()
+    {
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        Light = new(model.Light);
+        Light.InitializeProperties();
+
+        Dark = new(model.Dark);
+        Dark.InitializeProperties();
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ListItemType.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public enum ListItemType
+{
+    Item,
+    SectionHeader,
+    Separator,
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ListItemViewModel.cs

@@ -0,0 +1,311 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CmdPal.UI.ViewModels.Commands;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class ListItemViewModel : CommandItemViewModel
+{
+    public new ExtensionObject<IListItem> Model { get; }
+
+    public List<TagViewModel>? Tags { get; set; }
+
+    // Remember - "observable" properties from the model (via PropChanged)
+    // cannot be marked [ObservableProperty]
+    public bool HasTags => (Tags?.Count ?? 0) > 0;
+
+    public string TextToSuggest { get; private set; } = string.Empty;
+
+    public string Section { get; private set; } = string.Empty;
+
+    public ListItemType Type { get; private set; }
+
+    public bool IsInteractive => Type == ListItemType.Item;
+
+    public DetailsViewModel? Details { get; private set; }
+
+    [MemberNotNullWhen(true, nameof(Details))]
+    public bool HasDetails => Details is not null;
+
+    public string AccessibleName { get; private set; } = string.Empty;
+
+    public bool ShowTitle { get; private set; }
+
+    public bool ShowSubtitle { get; private set; }
+
+    public bool LayoutShowsTitle
+    {
+        get;
+        set
+        {
+            if (SetProperty(ref field, value))
+            {
+                UpdateShowsTitle();
+            }
+        }
+    }
+
+    public bool LayoutShowsSubtitle
+    {
+        get;
+        set
+        {
+            if (SetProperty(ref field, value))
+            {
+                UpdateShowsSubtitle();
+            }
+        }
+    }
+
+    public ListItemViewModel(IListItem model, WeakReference<IPageContext> context)
+        : base(new(model), context)
+    {
+        Model = new ExtensionObject<IListItem>(model);
+    }
+
+    public override void InitializeProperties()
+    {
+        if (IsInitialized)
+        {
+            return;
+        }
+
+        // This sets IsInitialized = true
+        base.InitializeProperties();
+
+        var li = Model.Unsafe;
+        if (li is null)
+        {
+            return; // throw?
+        }
+
+        UpdateTags(li.Tags);
+        Section = li.Section ?? string.Empty;
+        Type = EvaluateType();
+        UpdateProperty(nameof(Section), nameof(Type), nameof(IsInteractive));
+
+        UpdateAccessibleName();
+    }
+
+    private ListItemType EvaluateType()
+    {
+        return Command.IsSet
+            ? ListItemType.Item
+            : string.IsNullOrEmpty(Section) ? ListItemType.Separator : ListItemType.SectionHeader;
+    }
+
+    public override void SlowInitializeProperties()
+    {
+        base.SlowInitializeProperties();
+        var model = Model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        var extensionDetails = model.Details;
+        if (extensionDetails is not null)
+        {
+            Details = new(extensionDetails, PageContext);
+            Details.InitializeProperties();
+            UpdateProperty(nameof(Details), nameof(HasDetails));
+        }
+
+        AddShowDetailsCommands();
+
+        TextToSuggest = model.TextToSuggest;
+        UpdateProperty(nameof(TextToSuggest));
+    }
+
+    protected override void FetchProperty(string propertyName)
+    {
+        base.FetchProperty(propertyName);
+
+        var model = this.Model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        switch (propertyName)
+        {
+            case nameof(model.Tags):
+                UpdateTags(model.Tags);
+                break;
+            case nameof(model.TextToSuggest):
+                TextToSuggest = model.TextToSuggest ?? string.Empty;
+                UpdateProperty(nameof(TextToSuggest));
+                break;
+            case nameof(model.Section):
+                Section = model.Section ?? string.Empty;
+                Type = EvaluateType();
+                UpdateProperty(nameof(Section), nameof(Type), nameof(IsInteractive));
+                break;
+            case nameof(model.Command):
+                Type = EvaluateType();
+                UpdateProperty(nameof(Type), nameof(IsInteractive));
+                break;
+            case nameof(Details):
+                var extensionDetails = model.Details;
+                Details = extensionDetails is not null ? new(extensionDetails, PageContext) : null;
+                Details?.InitializeProperties();
+                UpdateProperty(nameof(Details), nameof(HasDetails));
+                UpdateShowDetailsCommand();
+                break;
+            case nameof(model.MoreCommands):
+                UpdateProperty(nameof(MoreCommands));
+                AddShowDetailsCommands();
+                break;
+            case nameof(model.Title):
+                UpdateProperty(nameof(Title));
+                UpdateShowsTitle();
+                UpdateAccessibleName();
+                break;
+            case nameof(model.Subtitle):
+                UpdateProperty(nameof(Subtitle));
+                UpdateShowsSubtitle();
+                UpdateAccessibleName();
+                break;
+            default:
+                UpdateProperty(propertyName);
+                break;
+        }
+    }
+
+    // TODO: Do we want filters to match descriptions and other properties? Tags, etc... Yes?
+    // TODO: Do we want to save off the score here so we can sort by it in our ListViewModel?
+    public override string ToString() => $"{Name} ListItemViewModel";
+
+    public override bool Equals(object? obj) => obj is ListItemViewModel vm && vm.Model.Equals(this.Model);
+
+    public override int GetHashCode() => Model.GetHashCode();
+
+    private void AddShowDetailsCommands()
+    {
+        // If the parent page has ShowDetails = false and we have details,
+        // then we should add a show details action in the context menu.
+        if (HasDetails &&
+            PageContext.TryGetTarget(out var pageContext) &&
+            pageContext is ListViewModel listViewModel &&
+            !listViewModel.ShowDetails)
+        {
+            // Check if "Show Details" action already exists to prevent duplicates
+            if (!MoreCommands.Any(cmd => cmd is CommandContextItemViewModel contextItemViewModel &&
+                                        contextItemViewModel.Command.Id == ShowDetailsCommand.ShowDetailsCommandId))
+            {
+                // Create the view model for the show details command
+                var showDetailsCommand = new ShowDetailsCommand(Details);
+                var showDetailsContextItem = new CommandContextItem(showDetailsCommand);
+                var showDetailsContextItemViewModel = new CommandContextItemViewModel(showDetailsContextItem, PageContext);
+                showDetailsContextItemViewModel.SlowInitializeProperties();
+                MoreCommands.Add(showDetailsContextItemViewModel);
+            }
+
+            UpdateProperty(nameof(MoreCommands), nameof(AllCommands));
+        }
+    }
+
+    // This method is called when the details change to make sure we
+    // have the latest details in the show details command.
+    private void UpdateShowDetailsCommand()
+    {
+        // If the parent page has ShowDetails = false and we have details,
+        // then we should add a show details action in the context menu.
+        if (HasDetails &&
+            PageContext.TryGetTarget(out var pageContext) &&
+            pageContext is ListViewModel listViewModel &&
+            !listViewModel.ShowDetails)
+        {
+            var existingCommand = MoreCommands.FirstOrDefault(cmd =>
+                                        cmd is CommandContextItemViewModel contextItemViewModel &&
+                                        contextItemViewModel.Command.Id == ShowDetailsCommand.ShowDetailsCommandId);
+
+            // If the command already exists, remove it to update with the new details
+            if (existingCommand is not null)
+            {
+                MoreCommands.Remove(existingCommand);
+            }
+
+            // Create the view model for the show details command
+            var showDetailsCommand = new ShowDetailsCommand(Details);
+            var showDetailsContextItem = new CommandContextItem(showDetailsCommand);
+            var showDetailsContextItemViewModel = new CommandContextItemViewModel(showDetailsContextItem, PageContext);
+            showDetailsContextItemViewModel.SlowInitializeProperties();
+            MoreCommands.Add(showDetailsContextItemViewModel);
+
+            UpdateProperty(nameof(MoreCommands), nameof(AllCommands));
+        }
+    }
+
+    private void UpdateTags(ITag[]? newTagsFromModel)
+    {
+        var newTags = newTagsFromModel?.Select(t =>
+        {
+            var vm = new TagViewModel(t, PageContext);
+            vm.InitializeProperties();
+            return vm;
+        })
+            .ToList() ?? [];
+
+        DoOnUiThread(
+            () =>
+            {
+                // Tags being an ObservableCollection instead of a List lead to
+                // many COM exception issues.
+                Tags = [.. newTags];
+
+                // We're already in UI thread, so just raise the events
+                OnPropertyChanged(nameof(Tags));
+                OnPropertyChanged(nameof(HasTags));
+            });
+    }
+
+    private void UpdateShowsTitle()
+    {
+        var oldShowTitle = ShowTitle;
+        ShowTitle = LayoutShowsTitle;
+        if (oldShowTitle != ShowTitle)
+        {
+            UpdateProperty(nameof(ShowTitle));
+        }
+    }
+
+    private void UpdateShowsSubtitle()
+    {
+        var oldShowSubtitle = ShowSubtitle;
+        ShowSubtitle = LayoutShowsSubtitle && !string.IsNullOrWhiteSpace(Subtitle);
+        if (oldShowSubtitle != ShowSubtitle)
+        {
+            UpdateProperty(nameof(ShowSubtitle));
+        }
+    }
+
+    protected override void UnsafeCleanup()
+    {
+        base.UnsafeCleanup();
+
+        // Tags don't have event handlers or anything to cleanup
+        Tags?.ForEach(t => t.SafeCleanup());
+        Details?.SafeCleanup();
+
+        var model = Model.Unsafe;
+        if (model is not null)
+        {
+            // We don't need to revoke the PropChanged event handler here,
+            // because we are just overriding CommandItem's FetchProperty and
+            // piggy-backing off their PropChanged
+        }
+    }
+
+    protected void UpdateAccessibleName()
+    {
+        AccessibleName = Title + ", " + Subtitle;
+        UpdateProperty(nameof(AccessibleName));
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ListViewModel.cs

@@ -0,0 +1,802 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.CmdPal.Common.Helpers;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Foundation;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class ListViewModel : PageViewModel, IDisposable
+{
+    // private readonly HashSet<ListItemViewModel> _itemCache = [];
+    private readonly TaskFactory filterTaskFactory = new(new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler);
+
+    // TODO: Do we want a base "ItemsPageViewModel" for anything that's going to have items?
+
+    // Observable from MVVM Toolkit will auto create public properties that use INotifyPropertyChange change
+    // https://learn.microsoft.com/dotnet/communitytoolkit/mvvm/observablegroupedcollections for grouping support
+    public ObservableCollection<ListItemViewModel> FilteredItems { get; } = [];
+
+    public FiltersViewModel? Filters { get; set; }
+
+    private ObservableCollection<ListItemViewModel> Items { get; set; } = [];
+
+    private readonly ExtensionObject<IListPage> _model;
+
+    private readonly Lock _listLock = new();
+
+    private InterlockedBoolean _isLoading;
+    private bool _isFetching;
+
+    public event TypedEventHandler<ListViewModel, object>? ItemsUpdated;
+
+    public bool ShowEmptyContent =>
+        IsInitialized &&
+        FilteredItems.Count == 0 &&
+        (!_isFetching) &&
+        IsLoading == false;
+
+    public bool IsGridView { get; private set; }
+
+    public IGridPropertiesViewModel? GridProperties { get; private set; }
+
+    // Remember - "observable" properties from the model (via PropChanged)
+    // cannot be marked [ObservableProperty]
+    public bool ShowDetails { get; private set; }
+
+    private string _modelPlaceholderText = string.Empty;
+
+    public override string PlaceholderText => _modelPlaceholderText;
+
+    public string SearchText { get; private set; } = string.Empty;
+
+    public string InitialSearchText { get; private set; } = string.Empty;
+
+    public CommandItemViewModel EmptyContent { get; private set; }
+
+    public bool IsMainPage { get; init; }
+
+    private bool _isDynamic;
+
+    private Task? _initializeItemsTask;
+
+    // For cancelling the task to load the properties from the items in the list
+    private CancellationTokenSource? _cancellationTokenSource;
+
+    // For cancelling the task for calling GetItems on the extension
+    private CancellationTokenSource? _fetchItemsCancellationTokenSource;
+
+    // For cancelling ongoing calls to update the extension's SearchText
+    private CancellationTokenSource? filterCancellationTokenSource;
+
+    private ListItemViewModel? _lastSelectedItem;
+
+    public override bool IsInitialized
+    {
+        get => base.IsInitialized; protected set
+        {
+            base.IsInitialized = value;
+            UpdateEmptyContent();
+        }
+    }
+
+    public ListViewModel(IListPage model, TaskScheduler scheduler, AppExtensionHost host, CommandProviderContext providerContext)
+        : base(model, scheduler, host, providerContext)
+    {
+        _model = new(model);
+        EmptyContent = new(new(null), PageContext);
+    }
+
+    private void FiltersPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(FiltersViewModel.Filters))
+        {
+            var filtersViewModel = sender as FiltersViewModel;
+            var hasFilters = filtersViewModel?.Filters.Length > 0;
+            HasFilters = hasFilters;
+            UpdateProperty(nameof(HasFilters));
+        }
+    }
+
+    // TODO: Does this need to hop to a _different_ thread, so that we don't block the extension while we're fetching?
+    private void Model_ItemsChanged(object sender, IItemsChangedEventArgs args) => FetchItems();
+
+    protected override void OnSearchTextBoxUpdated(string searchTextBox)
+    {
+        //// TODO: Just temp testing, need to think about where we want to filter, as AdvancedCollectionView in View could be done, but then grouping need CollectionViewSource, maybe we do grouping in view
+        //// and manage filtering below, but we should be smarter about this and understand caching and other requirements...
+        //// Investigate if we re-use src\modules\cmdpal\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\ListHelpers.cs InPlaceUpdateList and FilterList?
+
+        // Dynamic pages will handler their own filtering. They will tell us if
+        // something needs to change, by raising ItemsChanged.
+        if (_isDynamic)
+        {
+            filterCancellationTokenSource?.Cancel();
+            filterCancellationTokenSource?.Dispose();
+            filterCancellationTokenSource = new CancellationTokenSource();
+
+            // Hop off to an exclusive scheduler background thread to update the
+            // extension. We do this to ensure that all filter update requests
+            // are serialized and in-order, so providers know to cancel previous
+            // requests when a new one comes in. Otherwise, they may execute
+            // concurrently.
+            _ = filterTaskFactory.StartNew(
+                () =>
+            {
+                filterCancellationTokenSource.Token.ThrowIfCancellationRequested();
+
+                try
+                {
+                    if (_model.Unsafe is IDynamicListPage dynamic)
+                    {
+                        dynamic.SearchText = searchTextBox;
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                }
+                catch (Exception ex)
+                {
+                    ShowException(ex, _model?.Unsafe?.Name);
+                }
+            },
+                filterCancellationTokenSource.Token,
+                TaskCreationOptions.None,
+                filterTaskFactory.Scheduler!);
+        }
+        else
+        {
+            // But for all normal pages, we should run our fuzzy match on them.
+            lock (_listLock)
+            {
+                ApplyFilterUnderLock();
+            }
+
+            ItemsUpdated?.Invoke(this, EventArgs.Empty);
+            UpdateEmptyContent();
+            _isLoading.Clear();
+        }
+    }
+
+    public void UpdateCurrentFilter(string currentFilterId)
+    {
+        // We're getting called on the UI thread.
+        // Hop off to a BG thread to update the extension.
+        _ = Task.Run(() =>
+        {
+            try
+            {
+                if (_model.Unsafe is IListPage listPage)
+                {
+                    listPage.Filters?.CurrentFilterId = currentFilterId;
+                }
+            }
+            catch (Exception ex)
+            {
+                ShowException(ex, _model?.Unsafe?.Name);
+            }
+        });
+    }
+
+    //// Run on background thread, from InitializeAsync or Model_ItemsChanged
+    private void FetchItems()
+    {
+        // Cancel any previous FetchItems operation
+        _fetchItemsCancellationTokenSource?.Cancel();
+        _fetchItemsCancellationTokenSource?.Dispose();
+        _fetchItemsCancellationTokenSource = new CancellationTokenSource();
+
+        var cancellationToken = _fetchItemsCancellationTokenSource.Token;
+
+        // TEMPORARY: just plop all the items into a single group
+        // see 9806fe5d8 for the last commit that had this with sections
+        _isFetching = true;
+
+        // Collect all the items into new viewmodels
+        Collection<ListItemViewModel> newViewModels = [];
+
+        try
+        {
+            // Check for cancellation before starting expensive operations
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
+            var newItems = _model.Unsafe!.GetItems();
+
+            // Check for cancellation after getting items from extension
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
+            // TODO we can probably further optimize this by also keeping a
+            // HashSet of every ExtensionObject we currently have, and only
+            // building new viewmodels for the ones we haven't already built.
+            var showsTitle = GridProperties?.ShowTitle ?? true;
+            var showsSubtitle = GridProperties?.ShowSubtitle ?? true;
+            foreach (var item in newItems)
+            {
+                // Check for cancellation during item processing
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                ListItemViewModel viewModel = new(item, new(this));
+
+                // If an item fails to load, silently ignore it.
+                if (viewModel.SafeFastInit())
+                {
+                    viewModel.LayoutShowsTitle = showsTitle;
+                    viewModel.LayoutShowsSubtitle = showsSubtitle;
+                    newViewModels.Add(viewModel);
+                }
+            }
+
+            // Check for cancellation before initializing first twenty items
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
+            var firstTwenty = newViewModels.Take(20);
+            foreach (var item in firstTwenty)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                item?.SafeInitializeProperties();
+            }
+
+            // Cancel any ongoing search
+            _cancellationTokenSource?.Cancel();
+
+            // Check for cancellation before updating the list
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
+            List<ListItemViewModel> removedItems = [];
+            lock (_listLock)
+            {
+                // Now that we have new ViewModels for everything from the
+                // extension, smartly update our list of VMs
+                ListHelpers.InPlaceUpdateList(Items, newViewModels, out removedItems);
+
+                // DO NOT ThrowIfCancellationRequested AFTER THIS! If you do,
+                // you'll clean up list items that we've now transferred into
+                // .Items
+            }
+
+            // If we removed items, we need to clean them up, to remove our event handlers
+            foreach (var removedItem in removedItems)
+            {
+                removedItem.SafeCleanup();
+            }
+
+            // TODO: Iterate over everything in Items, and prune items from the
+            // cache if we don't need them anymore
+        }
+        catch (OperationCanceledException)
+        {
+            // Cancellation is expected, don't treat as error
+
+            // However, if we were cancelled, we didn't actually add these items to
+            // our Items list. Before we release them to the GC, make sure we clean
+            // them up
+            foreach (var vm in newViewModels)
+            {
+                vm.SafeCleanup();
+            }
+
+            return;
+        }
+        catch (Exception ex)
+        {
+            // TODO: Move this within the for loop, so we can catch issues with individual items
+            // Create a special ListItemViewModel for errors and use an ItemTemplateSelector in the ListPage to display error items differently.
+            ShowException(ex, _model?.Unsafe?.Name);
+            throw;
+        }
+        finally
+        {
+            _isFetching = false;
+        }
+
+        _cancellationTokenSource = new CancellationTokenSource();
+
+        _initializeItemsTask = new Task(() =>
+        {
+            InitializeItemsTask(_cancellationTokenSource.Token);
+        });
+        _initializeItemsTask.Start();
+
+        DoOnUiThread(
+            () =>
+            {
+                lock (_listLock)
+                {
+                    // Now that our Items contains everything we want, it's time for us to
+                    // re-evaluate our Filter on those items.
+                    if (!_isDynamic)
+                    {
+                        // A static list? Great! Just run the filter.
+                        ApplyFilterUnderLock();
+                    }
+                    else
+                    {
+                        // A dynamic list? Even better! Just stick everything into
+                        // FilteredItems. The extension already did any filtering it cared about.
+                        ListHelpers.InPlaceUpdateList(FilteredItems, Items.Where(i => !i.IsInErrorState));
+                    }
+
+                    UpdateEmptyContent();
+                }
+
+                ItemsUpdated?.Invoke(this, EventArgs.Empty);
+                _isLoading.Clear();
+            });
+    }
+
+    private void InitializeItemsTask(CancellationToken ct)
+    {
+        // Were we already canceled?
+        if (ct.IsCancellationRequested)
+        {
+            return;
+        }
+
+        ListItemViewModel[] iterable;
+        lock (_listLock)
+        {
+            iterable = Items.ToArray();
+        }
+
+        foreach (var item in iterable)
+        {
+            if (ct.IsCancellationRequested)
+            {
+                return;
+            }
+
+            // TODO: GH #502
+            // We should probably remove the item from the list if it
+            // entered the error state. I had issues doing that without having
+            // multiple threads muck with `Items` (and possibly FilteredItems!)
+            // at once.
+            item.SafeInitializeProperties();
+
+            if (ct.IsCancellationRequested)
+            {
+                return;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Apply our current filter text to the list of items, and update
+    /// FilteredItems to match the results.
+    /// </summary>
+    private void ApplyFilterUnderLock() => ListHelpers.InPlaceUpdateList(FilteredItems, FilterList(Items, SearchTextBox));
+
+    /// <summary>
+    /// Helper to generate a weighting for a given list item, based on title,
+    /// subtitle, etc. Largely a copy of the version in ListHelpers, but
+    /// operating on ViewModels instead of extension objects.
+    /// </summary>
+    private static int ScoreListItem(string query, CommandItemViewModel listItem)
+    {
+        if (string.IsNullOrEmpty(query))
+        {
+            return 1;
+        }
+
+        var nameMatch = FuzzyStringMatcher.ScoreFuzzy(query, listItem.Title);
+        var descriptionMatch = FuzzyStringMatcher.ScoreFuzzy(query, listItem.Subtitle);
+        return new[] { nameMatch, (descriptionMatch - 4) / 2, 0 }.Max();
+    }
+
+    private struct ScoredListItemViewModel
+    {
+        public int Score;
+        public ListItemViewModel ViewModel;
+    }
+
+    // Similarly stolen from ListHelpers.FilterList
+    public static IEnumerable<ListItemViewModel> FilterList(IEnumerable<ListItemViewModel> items, string query)
+    {
+        var scores = items
+            .Where(i => !i.IsInErrorState)
+            .Select(li => new ScoredListItemViewModel() { ViewModel = li, Score = ScoreListItem(query, li) })
+            .Where(score => score.Score > 0)
+            .OrderByDescending(score => score.Score);
+        return scores
+            .Select(score => score.ViewModel);
+    }
+
+    // InvokeItemCommand is what this will be in Xaml due to source generator
+    // This is what gets invoked when the user presses <enter>
+    [RelayCommand]
+    private void InvokeItem(ListItemViewModel? item)
+    {
+        if (item is not null)
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(item.Command.Model, item.Model));
+        }
+        else if (ShowEmptyContent && EmptyContent.PrimaryCommand?.Model.Unsafe is not null)
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(
+                EmptyContent.PrimaryCommand.Command.Model,
+                EmptyContent.PrimaryCommand.Model));
+        }
+    }
+
+    // This is what gets invoked when the user presses <ctrl+enter>
+    [RelayCommand]
+    private void InvokeSecondaryCommand(ListItemViewModel? item)
+    {
+        if (item is not null)
+        {
+            if (item.SecondaryCommand is not null)
+            {
+                WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(item.SecondaryCommand.Command.Model, item.Model));
+            }
+        }
+        else if (ShowEmptyContent && EmptyContent.SecondaryCommand?.Model.Unsafe is not null)
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(
+                EmptyContent.SecondaryCommand.Command.Model,
+                EmptyContent.SecondaryCommand.Model));
+        }
+    }
+
+    [RelayCommand]
+    private void UpdateSelectedItem(ListItemViewModel? item)
+    {
+        if (_lastSelectedItem is not null)
+        {
+            _lastSelectedItem.PropertyChanged -= SelectedItemPropertyChanged;
+        }
+
+        if (item is not null)
+        {
+            SetSelectedItem(item);
+        }
+        else
+        {
+            ClearSelectedItem();
+        }
+    }
+
+    private void SetSelectedItem(ListItemViewModel item)
+    {
+        if (!item.SafeSlowInit())
+        {
+            // Even if initialization fails, we need to hide any previously shown details
+            DoOnUiThread(() =>
+            {
+                WeakReferenceMessenger.Default.Send<HideDetailsMessage>();
+            });
+            return;
+        }
+
+        // GH #322:
+        // For inexplicable reasons, if you try updating the command bar and
+        // the details on the same UI thread tick as updating the list, we'll
+        // explode
+        DoOnUiThread(
+           () =>
+           {
+               WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(item));
+
+               if (ShowDetails && item.HasDetails)
+               {
+                   WeakReferenceMessenger.Default.Send<ShowDetailsMessage>(new(item.Details));
+               }
+               else
+               {
+                   WeakReferenceMessenger.Default.Send<HideDetailsMessage>();
+               }
+
+               TextToSuggest = item.TextToSuggest;
+               WeakReferenceMessenger.Default.Send<UpdateSuggestionMessage>(new(item.TextToSuggest));
+           });
+
+        _lastSelectedItem = item;
+        _lastSelectedItem.PropertyChanged += SelectedItemPropertyChanged;
+    }
+
+    private void SelectedItemPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        var item = _lastSelectedItem;
+        if (item is null)
+        {
+            return;
+        }
+
+        // already on the UI thread here
+        switch (e.PropertyName)
+        {
+            case nameof(item.Command):
+            case nameof(item.SecondaryCommand):
+            case nameof(item.AllCommands):
+            case nameof(item.Name):
+                WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(item));
+                break;
+            case nameof(item.Details):
+                if (ShowDetails && item.HasDetails)
+                {
+                    WeakReferenceMessenger.Default.Send<ShowDetailsMessage>(new(item.Details));
+                }
+                else
+                {
+                    WeakReferenceMessenger.Default.Send<HideDetailsMessage>();
+                }
+
+                break;
+            case nameof(item.TextToSuggest):
+                TextToSuggest = item.TextToSuggest;
+                break;
+        }
+    }
+
+    private void ClearSelectedItem()
+    {
+        // GH #322:
+        // For inexplicable reasons, if you try updating the command bar and
+        // the details on the same UI thread tick as updating the list, we'll
+        // explode
+        DoOnUiThread(
+           () =>
+           {
+               WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(null));
+
+               WeakReferenceMessenger.Default.Send<HideDetailsMessage>();
+
+               WeakReferenceMessenger.Default.Send<UpdateSuggestionMessage>(new(string.Empty));
+
+               TextToSuggest = string.Empty;
+           });
+    }
+
+    public override void InitializeProperties()
+    {
+        base.InitializeProperties();
+
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        _isDynamic = model is IDynamicListPage;
+
+        IsGridView = model.GridProperties is not null;
+        UpdateProperty(nameof(IsGridView));
+
+        GridProperties = LoadGridPropertiesViewModel(model.GridProperties);
+        GridProperties?.InitializeProperties();
+        UpdateProperty(nameof(GridProperties));
+        ApplyLayoutToItems();
+
+        ShowDetails = model.ShowDetails;
+        UpdateProperty(nameof(ShowDetails));
+
+        _modelPlaceholderText = model.PlaceholderText;
+        UpdateProperty(nameof(PlaceholderText));
+
+        InitialSearchText = SearchText = model.SearchText;
+        UpdateProperty(nameof(SearchText));
+        UpdateProperty(nameof(InitialSearchText));
+
+        EmptyContent = new(new(model.EmptyContent), PageContext);
+        EmptyContent.SlowInitializeProperties();
+
+        Filters?.PropertyChanged -= FiltersPropertyChanged;
+        Filters = new(new(model.Filters), PageContext);
+        Filters?.PropertyChanged += FiltersPropertyChanged;
+
+        Filters?.InitializeProperties();
+        UpdateProperty(nameof(Filters));
+
+        FetchItems();
+        model.ItemsChanged += Model_ItemsChanged;
+    }
+
+    private static IGridPropertiesViewModel? LoadGridPropertiesViewModel(IGridProperties? gridProperties)
+    {
+        return gridProperties switch
+        {
+            IMediumGridLayout mediumGridLayout => new MediumGridPropertiesViewModel(mediumGridLayout),
+            IGalleryGridLayout galleryGridLayout => new GalleryGridPropertiesViewModel(galleryGridLayout),
+            ISmallGridLayout smallGridLayout => new SmallGridPropertiesViewModel(smallGridLayout),
+            _ => null,
+        };
+    }
+
+    public void LoadMoreIfNeeded()
+    {
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return;
+        }
+
+        if (!_isLoading.Set())
+        {
+            return;
+
+            // NOTE: May miss newly available items until next scroll if model
+            // state changes between our check and this reset
+        }
+
+        _ = Task.Run(() =>
+        {
+            // Execute all COM calls on background thread to avoid reentrancy issues with UI
+            // with the UI thread when COM starts inner message pump
+            try
+            {
+                if (model.HasMoreItems)
+                {
+                    model.LoadMore();
+
+                    // _isLoading flag will be set as a result of LoadMore,
+                    // which must raise ItemsChanged to end the loading.
+                }
+                else
+                {
+                    _isLoading.Clear();
+                }
+            }
+            catch (Exception ex)
+            {
+                _isLoading.Clear();
+                ShowException(ex, model.Name);
+            }
+        });
+    }
+
+    protected override void FetchProperty(string propertyName)
+    {
+        base.FetchProperty(propertyName);
+
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        switch (propertyName)
+        {
+            case nameof(GridProperties):
+                IsGridView = model.GridProperties is not null;
+                GridProperties = LoadGridPropertiesViewModel(model.GridProperties);
+                GridProperties?.InitializeProperties();
+                UpdateProperty(nameof(IsGridView));
+                ApplyLayoutToItems();
+                break;
+            case nameof(ShowDetails):
+                ShowDetails = model.ShowDetails;
+                break;
+            case nameof(PlaceholderText):
+                _modelPlaceholderText = model.PlaceholderText;
+                break;
+            case nameof(SearchText):
+                SearchText = model.SearchText;
+                break;
+            case nameof(EmptyContent):
+                EmptyContent = new(new(model.EmptyContent), PageContext);
+                EmptyContent.SlowInitializeProperties();
+                break;
+            case nameof(Filters):
+                Filters?.PropertyChanged -= FiltersPropertyChanged;
+                Filters = new(new(model.Filters), PageContext);
+                Filters?.PropertyChanged += FiltersPropertyChanged;
+                Filters?.InitializeProperties();
+                break;
+            case nameof(IsLoading):
+                UpdateEmptyContent();
+                break;
+        }
+
+        UpdateProperty(propertyName);
+    }
+
+    private void UpdateEmptyContent()
+    {
+        UpdateProperty(nameof(ShowEmptyContent));
+        if (!ShowEmptyContent || EmptyContent.Model.Unsafe is null)
+        {
+            return;
+        }
+
+        UpdateProperty(nameof(EmptyContent));
+
+        DoOnUiThread(
+           () =>
+           {
+               WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(EmptyContent));
+           });
+    }
+
+    private void ApplyLayoutToItems()
+    {
+        lock (_listLock)
+        {
+            var showsTitle = GridProperties?.ShowTitle ?? true;
+            var showsSubtitle = GridProperties?.ShowSubtitle ?? true;
+
+            foreach (var item in Items)
+            {
+                item.LayoutShowsTitle = showsTitle;
+                item.LayoutShowsSubtitle = showsSubtitle;
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        GC.SuppressFinalize(this);
+        _cancellationTokenSource?.Cancel();
+        _cancellationTokenSource?.Dispose();
+        _cancellationTokenSource = null;
+
+        filterCancellationTokenSource?.Cancel();
+        filterCancellationTokenSource?.Dispose();
+        filterCancellationTokenSource = null;
+
+        _fetchItemsCancellationTokenSource?.Cancel();
+        _fetchItemsCancellationTokenSource?.Dispose();
+        _fetchItemsCancellationTokenSource = null;
+    }
+
+    protected override void UnsafeCleanup()
+    {
+        base.UnsafeCleanup();
+
+        EmptyContent?.SafeCleanup();
+        EmptyContent = new(new(null), PageContext); // necessary?
+
+        _cancellationTokenSource?.Cancel();
+        filterCancellationTokenSource?.Cancel();
+        _fetchItemsCancellationTokenSource?.Cancel();
+
+        lock (_listLock)
+        {
+            foreach (var item in Items)
+            {
+                item.SafeCleanup();
+            }
+
+            Items.Clear();
+            foreach (var item in FilteredItems)
+            {
+                item.SafeCleanup();
+            }
+
+            FilteredItems.Clear();
+        }
+
+        Filters?.PropertyChanged -= FiltersPropertyChanged;
+        Filters?.SafeCleanup();
+
+        var model = _model.Unsafe;
+        if (model is not null)
+        {
+            model.ItemsChanged -= Model_ItemsChanged;
+        }
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/LoadingPageViewModel.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class LoadingPageViewModel : PageViewModel
+{
+    public LoadingPageViewModel(IPage? model, TaskScheduler scheduler, AppExtensionHost host)
+        : base(model, scheduler, host, CommandProviderContext.Empty)
+    {
+        ModelIsLoading = true;
+        IsInitialized = false;
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/LogMessageViewModel.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class LogMessageViewModel : ExtensionObjectViewModel
+{
+    private readonly ExtensionObject<ILogMessage> _model;
+
+    public string Message { get; private set; } = string.Empty;
+
+    public LogMessageViewModel(ILogMessage message, IPageContext context)
+        : base(context)
+    {
+        _model = new(message);
+    }
+
+    public override void InitializeProperties()
+    {
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        Message = model.Message;
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/MediumGridPropertiesViewModel.cs

@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public class MediumGridPropertiesViewModel : IGridPropertiesViewModel
+{
+    private readonly ExtensionObject<IMediumGridLayout> _model;
+
+    public bool ShowTitle { get; private set; }
+
+    public bool ShowSubtitle => false;
+
+    public MediumGridPropertiesViewModel(IMediumGridLayout mediumGridLayout)
+    {
+        _model = new(mediumGridLayout);
+    }
+
+    public void InitializeProperties()
+    {
+        var model = _model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        ShowTitle = model.ShowTitle;
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ActivateSecondaryCommandMessage.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to perform a list item's secondary command when the user presses ctrl+enter in the search box
+/// </summary>
+public record ActivateSecondaryCommandMessage;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ActivateSelectedListItemMessage.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to perform a list item's command when the user presses enter in the search box
+/// </summary>
+public record ActivateSelectedListItemMessage;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/BeginInvokeMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record BeginInvokeMessage;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ClearSearchMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record ClearSearchMessage();

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/CloseContextMenuMessage.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to announce that a context menu should close
+/// </summary>
+public record CloseContextMenuMessage;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/CmdPalInvokeResultMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record CmdPalInvokeResultMessage(Microsoft.CommandPalette.Extensions.CommandResultKind Kind);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/DismissMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record DismissMessage(bool ForceGoHome = false);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ErrorOccurredMessage.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Message sent when an error occurs during command execution.
+/// Used to track session error count for telemetry.
+/// </summary>
+public record ErrorOccurredMessage();

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ExtensionInvokedMessage.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Message sent when an extension command or page is invoked.
+/// Captures extension usage metrics for telemetry tracking.
+/// </summary>
+public record ExtensionInvokedMessage(string ExtensionId, string CommandId, string CommandName, bool Success, ulong ExecutionTimeMs);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/FocusSearchBoxMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record FocusSearchBoxMessage();

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/GoBackMessage.cs

@@ -0,0 +1,8 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+// TODO! sticking these properties here feels like leaking the UI into the models
+public record GoBackMessage(bool WithAnimation = true, bool FocusSearch = true);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/GoHomeMessage.cs

@@ -0,0 +1,8 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+// TODO! sticking these properties here feels like leaking the UI into the models
+public record GoHomeMessage(bool WithAnimation = true, bool FocusSearch = true);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/HandleCommandResultMessage.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record HandleCommandResultMessage(ExtensionObject<ICommandResult> Result);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/HideDetailsMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record HideDetailsMessage();

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/LaunchUriMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record LaunchUriMessage(Uri Uri);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigateBackMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record NavigateBackMessage(bool FromBackspace = false);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigateLeftCommand.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to navigate left in a grid view when pressing the Left arrow key in the SearchBox.
+/// </summary>
+public record NavigateLeftCommand;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigateNextCommand.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Commands;
+
+/// <summary>
+/// Used to navigate to the next command in the page when pressing the Down key in the SearchBox.
+/// </summary>
+public record NavigateNextCommand;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigatePageDownCommand.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to navigate down one page in the page when pressing the PageDown key in the SearchBox.
+/// </summary>
+public record NavigatePageDownCommand;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigatePageUpCommand.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to navigate up one page in the page when pressing the PageUp key in the SearchBox.
+/// </summary>
+public record NavigatePageUpCommand;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigatePreviousCommand.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to navigate to the previous command in the page when pressing the Down key in the SearchBox.
+/// </summary>
+public record NavigatePreviousCommand;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigateRightCommand.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to navigate right in a grid view when pressing the Right arrow key in the SearchBox.
+/// </summary>
+public record NavigateRightCommand;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigateToPageMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record NavigateToPageMessage(PageViewModel Page, bool WithAnimation, CancellationToken CancellationToken);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/NavigationDepthMessage.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Message containing the current navigation depth (BackStack count) when navigating to a page.
+/// Used to track maximum navigation depth reached during a session for telemetry.
+/// </summary>
+public record NavigationDepthMessage(int Depth);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/PerformCommandMessage.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to do a command - navigate to a page or invoke it
+/// </summary>
+public record PerformCommandMessage
+{
+    public ExtensionObject<ICommand> Command { get; }
+
+    public object? Context { get; }
+
+    public bool WithAnimation { get; set; } = true;
+
+    public PerformCommandMessage(ExtensionObject<ICommand> command)
+    {
+        Command = command;
+        Context = null;
+    }
+
+    public PerformCommandMessage(ExtensionObject<ICommand> command, ExtensionObject<IListItem> context)
+    {
+        Command = command;
+        Context = context.Unsafe;
+    }
+
+    public PerformCommandMessage(ExtensionObject<ICommand> command, ExtensionObject<ICommandItem> context)
+    {
+        Command = command;
+        Context = context.Unsafe;
+    }
+
+    public PerformCommandMessage(ExtensionObject<ICommand> command, ExtensionObject<ICommandContextItem> context)
+    {
+        Command = command;
+        Context = context.Unsafe;
+    }
+
+    public PerformCommandMessage(CommandContextItemViewModel contextCommand)
+    {
+        Command = contextCommand.Command.Model;
+        Context = contextCommand.Model.Unsafe;
+    }
+
+    public PerformCommandMessage(ConfirmResultViewModel vm)
+    {
+        Command = vm.PrimaryCommand.Model;
+        Context = null;
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/SearchQueryMessage.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Message sent when a search query is executed in the Command Palette.
+/// Used to track session search activity for telemetry.
+/// </summary>
+public record SearchQueryMessage();

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/SessionDurationMessage.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Message containing session telemetry data from Command Palette launch to dismissal.
+/// Used to aggregate metrics like duration, commands executed, pages visited, and search activity.
+/// </summary>
+public record SessionDurationMessage(ulong DurationMs, int CommandsExecuted, int PagesVisited, string DismissalReason, int SearchQueriesCount, int MaxNavigationDepth, int ErrorCount);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ShowConfirmationMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record ShowConfirmationMessage(Microsoft.CommandPalette.Extensions.IConfirmationArgs? Args);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ShowDetailsMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record ShowDetailsMessage(DetailsViewModel Details);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ShowToastMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record ShowToastMessage(string Message);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/ShowWindowMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record ShowWindowMessage(IntPtr Hwnd);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/TelemetryBeginInvokeMessage.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Telemetry message sent when command invocation begins.
+/// </summary>
+public record TelemetryBeginInvokeMessage;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/TelemetryExtensionInvokedMessage.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Telemetry message sent when an extension command or page is invoked.
+/// Captures extension usage metrics for telemetry tracking.
+/// </summary>
+public record TelemetryExtensionInvokedMessage(string ExtensionId, string CommandId, string CommandName, bool Success, ulong ExecutionTimeMs);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/TelemetryInvokeResultMessage.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Telemetry message sent when command invocation completes with a result.
+/// </summary>
+public record TelemetryInvokeResultMessage(Microsoft.CommandPalette.Extensions.CommandResultKind Kind);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/TryCommandKeybindingMessage.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Windows.System;
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record TryCommandKeybindingMessage(bool Ctrl, bool Alt, bool Shift, bool Win, VirtualKey Key)
+{
+    public bool Handled { get; set; }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/UpdateCommandBarMessage.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel;
+using Microsoft.CmdPal.Common;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+/// <summary>
+/// Used to update the command bar at the bottom to reflect the commands for a list item
+/// </summary>
+public record UpdateCommandBarMessage(ICommandBarContext? ViewModel)
+{
+}
+
+public interface IContextMenuContext : INotifyPropertyChanged
+{
+    public IEnumerable<IContextItemViewModel> MoreCommands { get; }
+
+    public bool HasMoreCommands { get; }
+
+    public List<IContextItemViewModel> AllCommands { get; }
+
+    /// <summary>
+    /// Generates a mapping of key -> command item for this particular item's
+    /// MoreCommands. (This won't include the primary Command, but it will
+    /// include the secondary one). This map can be used to quickly check if a
+    /// shortcut key was pressed
+    /// </summary>
+    /// <returns>a dictionary of KeyChord -> Context commands, for all commands
+    /// that have a shortcut key set.</returns>
+    public Dictionary<KeyChord, CommandContextItemViewModel> Keybindings()
+    {
+        var result = new Dictionary<KeyChord, CommandContextItemViewModel>();
+
+        var menu = MoreCommands;
+        if (menu is null)
+        {
+            return result;
+        }
+
+        foreach (var item in menu)
+        {
+            if (item is CommandContextItemViewModel cmd && cmd.HasRequestedShortcut)
+            {
+                var key = cmd.RequestedShortcut ?? new KeyChord(0, 0, 0);
+                var added = result.TryAdd(key, cmd);
+                if (!added)
+                {
+                    CoreLogger.LogWarning($"Ignoring duplicate keyboard shortcut {KeyChordHelpers.FormatForDebug(key)} on command '{cmd.Title ?? cmd.Name ?? "(unknown)"}'");
+                }
+            }
+        }
+
+        return result;
+    }
+}
+
+// Represents everything the command bar needs to know about to show command
+// buttons at the bottom.
+//
+// This is implemented by both ListItemViewModel and ContentPageViewModel,
+// the two things with sub-commands.
+public interface ICommandBarContext : IContextMenuContext
+{
+    public string SecondaryCommandName { get; }
+
+    public CommandItemViewModel? PrimaryCommand { get; }
+
+    public CommandItemViewModel? SecondaryCommand { get; }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/UpdateSuggestionMessage.cs

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Messages;
+
+public record UpdateSuggestionMessage(string TextToSuggest);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Microsoft.CmdPal.UI.ViewModels.csproj

@@ -56,8 +56,6 @@
 	</ItemGroup>
 	
   <ItemGroup>
-    <ProjectReference Include="..\Core\Microsoft.CmdPal.Core.Common\Microsoft.CmdPal.Core.Common.csproj" />
-    <ProjectReference Include="..\Core\Microsoft.CmdPal.Core.ViewModels\Microsoft.CmdPal.Core.ViewModels.csproj" />
     <ProjectReference Include="..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
 
     <ProjectReference Include="..\ext\Microsoft.CmdPal.Ext.Apps\Microsoft.CmdPal.Ext.Apps.csproj" />

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Models/ExtensionObject`1.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels.Models;
+
+public class ExtensionObject<T>(T? value) // where T : IInspectable
+{
+    public T? Unsafe { get; } = value;
+
+    public override bool Equals(object? obj) => obj is ExtensionObject<T> ext && ext.Unsafe?.Equals(this.Unsafe) == true;
+
+    public override int GetHashCode() => Unsafe?.GetHashCode() ?? base.GetHashCode();
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Models/ExtensionService.cs

@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using ManagedCommon;
-using Microsoft.CmdPal.Core.Common.Services;
+using Microsoft.CmdPal.Common.Services;
 using Microsoft.CommandPalette.Extensions;
 using Windows.ApplicationModel;
 using Windows.ApplicationModel.AppExtensions;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Models/ExtensionWrapper.cs

@@ -4,7 +4,7 @@
 
 using System.Runtime.InteropServices;
 using ManagedCommon;
-using Microsoft.CmdPal.Core.Common.Services;
+using Microsoft.CmdPal.Common.Services;
 using Microsoft.CommandPalette.Extensions;
 using Windows.ApplicationModel;
 using Windows.ApplicationModel.AppExtensions;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/NullPageViewModel.cs

@@ -0,0 +1,8 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+internal sealed partial class NullPageViewModel(TaskScheduler scheduler, AppExtensionHost extensionHost)
+    : PageViewModel(null, scheduler, extensionHost, CommandProviderContext.Empty);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/PageViewModel.cs

@@ -0,0 +1,282 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.CmdPal.Common.Helpers;
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class PageViewModel : ExtensionObjectViewModel, IPageContext
+{
+    public TaskScheduler Scheduler { get; private set; }
+
+    private readonly ExtensionObject<IPage> _pageModel;
+
+    public bool IsLoading => ModelIsLoading || (!IsInitialized);
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsLoading))]
+    public virtual partial bool IsInitialized { get; protected set; }
+
+    [ObservableProperty]
+    public partial string ErrorMessage { get; protected set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial bool IsNested { get; set; } = true;
+
+    // This is set from the SearchBar
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowSuggestion))]
+    public partial string SearchTextBox { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public virtual partial string PlaceholderText { get; private set; } = "Type here to search...";
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowSuggestion))]
+    public virtual partial string TextToSuggest { get; protected set; } = string.Empty;
+
+    public bool ShowSuggestion => !string.IsNullOrEmpty(TextToSuggest) && TextToSuggest != SearchTextBox;
+
+    [ObservableProperty]
+    public partial AppExtensionHost ExtensionHost { get; private set; }
+
+    public bool HasStatusMessage => MostRecentStatusMessage is not null;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasStatusMessage))]
+    public partial StatusMessageViewModel? MostRecentStatusMessage { get; private set; } = null;
+
+    public ObservableCollection<StatusMessageViewModel> StatusMessages => ExtensionHost.StatusMessages;
+
+    // These are properties that are "observable" from the extension object
+    // itself, in the sense that they get raised by PropChanged events from the
+    // extension. However, we don't want to actually make them
+    // [ObservableProperty]s, because PropChanged comes in off the UI thread,
+    // and ObservableProperty is not smart enough to raise the PropertyChanged
+    // on the UI thread.
+    public string Name { get; protected set; } = string.Empty;
+
+    public string Title { get => string.IsNullOrEmpty(field) ? Name : field; protected set; } = string.Empty;
+
+    public string Id { get; protected set; } = string.Empty;
+
+    // This property maps to `IPage.IsLoading`, but we want to expose our own
+    // `IsLoading` property as a combo of this value and `IsInitialized`
+    public bool ModelIsLoading { get; protected set; } = true;
+
+    public bool HasSearchBox { get; protected set; } = true;
+
+    public bool HasFilters { get; protected set; }
+
+    public IconInfoViewModel Icon { get; protected set; }
+
+    public CommandProviderContext ProviderContext { get; protected set; }
+
+    public PageViewModel(IPage? model, TaskScheduler scheduler, AppExtensionHost extensionHost, CommandProviderContext providerContext)
+        : base(scheduler)
+    {
+        InitializeSelfAsPageContext();
+        _pageModel = new(model);
+        Scheduler = scheduler;
+        ExtensionHost = extensionHost;
+        ProviderContext = providerContext;
+        Icon = new(null);
+
+        ExtensionHost.StatusMessages.CollectionChanged += StatusMessages_CollectionChanged;
+        UpdateHasStatusMessage();
+    }
+
+    private void StatusMessages_CollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => UpdateHasStatusMessage();
+
+    private void UpdateHasStatusMessage()
+    {
+        if (ExtensionHost.StatusMessages.Any())
+        {
+            var last = ExtensionHost.StatusMessages.Last();
+            MostRecentStatusMessage = last;
+        }
+        else
+        {
+            MostRecentStatusMessage = null;
+        }
+    }
+
+    //// Run on background thread from ListPage.xaml.cs
+    [RelayCommand]
+    internal Task<bool> InitializeAsync()
+    {
+        // TODO: We may want a SemaphoreSlim lock here.
+
+        // TODO: We may want to investigate using some sort of AsyncEnumerable or populating these as they come into the UI layer
+        //       Though we have to think about threading here and circling back to the UI thread with a TaskScheduler.
+        try
+        {
+            InitializeProperties();
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex, _pageModel?.Unsafe?.Name);
+            return Task.FromResult(false);
+        }
+
+        // Notify we're done back on the UI Thread.
+        Task.Factory.StartNew(
+            () =>
+            {
+                IsInitialized = true;
+
+                // TODO: Do we want an event/signal here that the Page Views can listen to? (i.e. ListPage setting the selected index to 0, however, in async world the user may have already started navigating around page...)
+            },
+            CancellationToken.None,
+            TaskCreationOptions.None,
+            Scheduler);
+        return Task.FromResult(true);
+    }
+
+    public override void InitializeProperties()
+    {
+        var page = _pageModel.Unsafe;
+        if (page is null)
+        {
+            return; // throw?
+        }
+
+        Id = page.Id;
+        Name = page.Name;
+        ModelIsLoading = page.IsLoading;
+        Title = page.Title;
+        Icon = new(page.Icon);
+        Icon.InitializeProperties();
+
+        HasSearchBox = page is IListPage;
+
+        // Let the UI know about our initial properties too.
+        UpdateProperty(nameof(Name));
+        UpdateProperty(nameof(Title));
+        UpdateProperty(nameof(ModelIsLoading));
+        UpdateProperty(nameof(IsLoading));
+        UpdateProperty(nameof(Icon));
+        UpdateProperty(nameof(HasSearchBox));
+
+        page.PropChanged += Model_PropChanged;
+    }
+
+    private void Model_PropChanged(object sender, IPropChangedEventArgs args)
+    {
+        try
+        {
+            var propName = args.PropertyName;
+            FetchProperty(propName);
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex, _pageModel?.Unsafe?.Name);
+        }
+    }
+
+    partial void OnSearchTextBoxChanged(string oldValue, string newValue) => OnSearchTextBoxUpdated(newValue);
+
+    protected virtual void OnSearchTextBoxUpdated(string searchTextBox)
+    {
+        // The base page has no notion of data, so we do nothing here...
+        // subclasses should override.
+    }
+
+    protected virtual void FetchProperty(string propertyName)
+    {
+        var model = this._pageModel.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        var updateProperty = true;
+        switch (propertyName)
+        {
+            case nameof(Name):
+                this.Name = model.Name ?? string.Empty;
+                UpdateProperty(nameof(Title));
+                break;
+            case nameof(Title):
+                this.Title = model.Title ?? string.Empty;
+                break;
+            case nameof(IsLoading):
+                this.ModelIsLoading = model.IsLoading;
+                UpdateProperty(nameof(ModelIsLoading));
+                break;
+            case nameof(Icon):
+                this.Icon = new(model.Icon);
+                break;
+            default:
+                updateProperty = false;
+                break;
+        }
+
+        // GH #38829: If we always UpdateProperty here, then there's a possible
+        // race condition, where we raise the PropertyChanged(SearchText)
+        // before the subclass actually retrieves the new SearchText from the
+        // model. In that race situation, if the UI thread handles the
+        // PropertyChanged before ListViewModel fetches the SearchText, it'll
+        // think that the old search text is the _new_ value.
+        if (updateProperty)
+        {
+            UpdateProperty(propertyName);
+        }
+    }
+
+    public new void ShowException(Exception ex, string? extensionHint = null)
+    {
+        // Set the extensionHint to the Page Title (if we have one, and one not provided).
+        // extensionHint ??= _pageModel?.Unsafe?.Title;
+        extensionHint ??= ExtensionHost.GetExtensionDisplayName() ?? Title;
+        Task.Factory.StartNew(
+            () =>
+            {
+                var message = DiagnosticsHelper.BuildExceptionMessage(ex, extensionHint);
+                ErrorMessage += message;
+            },
+            CancellationToken.None,
+            TaskCreationOptions.None,
+            Scheduler);
+    }
+
+    public override string ToString() => $"{Title} ViewModel";
+
+    protected override void UnsafeCleanup()
+    {
+        base.UnsafeCleanup();
+
+        ExtensionHost.StatusMessages.CollectionChanged -= StatusMessages_CollectionChanged;
+
+        var model = _pageModel.Unsafe;
+        if (model is not null)
+        {
+            model.PropChanged -= Model_PropChanged;
+        }
+    }
+}
+
+public interface IPageContext
+{
+    void ShowException(Exception ex, string? extensionHint = null);
+
+    TaskScheduler Scheduler { get; }
+}
+
+public interface IPageViewModelFactoryService
+{
+    /// <summary>
+    /// Creates a new instance of the page view model for the given page type.
+    /// </summary>
+    /// <param name="page">The page for which to create the view model.</param>
+    /// <param name="nested">Indicates whether the page is not the top-level page.</param>
+    /// <param name="host">The command palette host that will host the page (for status messages)</param>
+    /// <returns>A new instance of the page view model.</returns>
+    PageViewModel? TryCreatePageViewModel(IPage page, bool nested, AppExtensionHost host, CommandProviderContext providerContext);
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ProgressViewModel.cs

@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CmdPal.UI.ViewModels.Models;
+using Microsoft.CommandPalette.Extensions;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class ProgressViewModel : ExtensionObjectViewModel
+{
+    public ExtensionObject<IProgressState> Model { get; }
+
+    public bool IsIndeterminate { get; private set; }
+
+    public uint ProgressPercent { get; private set; }
+
+    public ProgressViewModel(IProgressState progress, WeakReference<IPageContext> context)
+        : base(context)
+    {
+        Model = new(progress);
+    }
+
+    public override void InitializeProperties()
+    {
+        var model = Model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        IsIndeterminate = model.IsIndeterminate;
+        ProgressPercent = model.ProgressPercent;
+
+        model.PropChanged += Model_PropChanged;
+    }
+
+    private void Model_PropChanged(object sender, IPropChangedEventArgs args)
+    {
+        try
+        {
+            FetchProperty(args.PropertyName);
+        }
+        catch (Exception ex)
+        {
+            ShowException(ex);
+        }
+    }
+
+    protected virtual void FetchProperty(string propertyName)
+    {
+        var model = this.Model.Unsafe;
+        if (model is null)
+        {
+            return; // throw?
+        }
+
+        switch (propertyName)
+        {
+            case nameof(IsIndeterminate):
+                this.IsIndeterminate = model.IsIndeterminate;
+                break;
+            case nameof(ProgressPercent):
+                this.ProgressPercent = model.ProgressPercent;
+                break;
+        }
+
+        UpdateProperty(propertyName);
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Properties/Resources.Designer.cs

@@ -19,7 +19,7 @@ namespace Microsoft.CmdPal.UI.ViewModels.Properties {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     public class Resources {
@@ -473,5 +473,14 @@ namespace Microsoft.CmdPal.UI.ViewModels.Properties {
                 return ResourceManager.GetString("fallbacks", resourceCulture);
             }
         }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Show details.
+        /// </summary>
+        public static string ShowDetailsCommand {
+            get {
+                return ResourceManager.GetString("ShowDetailsCommand", resourceCulture);
+            }
+        }
     }
 }

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Properties/Resources.resx

@@ -260,4 +260,8 @@
   <data name="fallbacks" xml:space="preserve">
     <value>Fallbacks</value>
   </data>
+  <data name="ShowDetailsCommand" xml:space="preserve">
+    <value>Show details</value>
+    <comment>Name for the command that shows details of an item</comment>
+  </data>
 </root>

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ProviderSettingsViewModel.cs

@@ -7,8 +7,7 @@ using System.Globalization;
 using System.Text;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Messaging;
-using Microsoft.CmdPal.Core.Common.Services;
-using Microsoft.CmdPal.Core.ViewModels;
+using Microsoft.CmdPal.Common.Services;
 using Microsoft.CmdPal.UI.ViewModels.Messages;
 using Microsoft.CmdPal.UI.ViewModels.Properties;