fix: COM Verify/activation correctness + TUI polish from Windows COM run

First real interactive COM run on Windows surfaced two COM-backend bugs (latent
because the AOT build always fell back to CLI) plus several UX gaps:

- ComBackend.ConnectAsync: stop re-setting AcceptSourceAgreements on the *composite*
  reference (throws E_ILLEGAL_STATE_CHANGE). The source refs already accept it in
  RemoteRefs; this had blocked every COM search/list/detail the moment COM activated.
- ComBackend.VerifyInstalledAsync: CheckInstalledStatus returns a status block per
  manifest installer, and the installers that aren't the one installed legitimately
  report 'ARP entry not found' (0x8A150201). Old code flattened all installers and
  reported Issues on any failure, so healthy multi-installer/portable packages looked
  corrupt. Now grouped per installer: Ok when any one installer's checks all pass; the
  dialog shows that clean installer's checks.
- Search now reads the composite's correlated InstalledVersion: an installed search row
  shows a green '✓ Installed' badge and Uninstall/Upgrade actions instead of a bare
  Install.
- Responsive column widths: Name/Id/Version shrink toward minimums on a narrow terminal
  so the Available column stays visible; reflows on resize via ViewportChanged.
- The operation result line ('Done', etc.) now persists through the post-op list reload
  instead of being masked by 'Loading Installed…'.
- Upgrades status bar shows 'Spc Select' / 'U Upgrade sel' to make batch select
  discoverable.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: harder

src/App.cs

@@ -115,6 +115,10 @@ public App (IBackend backend)
         };
         _packageTable.Style.ShowHorizontalHeaderUnderline = true;
         _packageTable.Style.ExpandLastColumn = true;
+
+        // Reflow column widths when the table is resized (e.g. terminal resize) so the Available
+        // column stays visible on a narrow window instead of being pushed off the right edge.
+        _packageTable.ViewportChanged += (_, _) => ApplyColumnWidths ();
         _listFrame.Add (_packageTable);
 
         _detailPanel = new ()
@@ -324,7 +328,11 @@ private void StopSpinner ()
         }
     }
 
-    private void TriggerRefresh ()
+    // keepMessage: when a list reload is triggered right after an operation, pass the op's result
+    // line (e.g. "Done", "Uninstalled X") so the reload keeps showing it — with the spinner as a
+    // "refreshing" cue — instead of overwriting it with "Loading Installed…" (the slow reload would
+    // otherwise mask the brief result). Null on a normal refresh, which shows the usual messages.
+    private void TriggerRefresh (string? keepMessage = null)
     {
         _viewCts.Cancel ();
         _viewCts = new ();
@@ -356,8 +364,11 @@ private void TriggerRefresh ()
         }
 
         _state.Loading = true;
-        _state.StatusMessage = $"Loading {_state.Mode}…";
-        _state.StatusIsError = false;
+        _state.StatusMessage = keepMessage ?? $"Loading {_state.Mode}…";
+
+        // Keep the op's error styling (set by the caller) when preserving its message; a plain
+        // refresh is never an error.
+        _state.StatusIsError = keepMessage is not null && _state.StatusIsError;
         RefreshStatusBar ();
         SyncTabBar ();
 
@@ -382,14 +393,20 @@ private void TriggerRefresh ()
                                            _state.Packages = packages.ToList ();
                                            _state.ApplyFilter ();
                                            _state.Loading = false;
-                                           int n = _state.Filtered.Count;
-                                           _state.StatusMessage = n == 1 ? "1 package" : $"{n} packages";
 
-                                           // A search that hit the result cap means there's more the user can't see;
-                                           // nudge them to narrow it (only the COM backend actually caps).
-                                           if (mode == AppMode.Search && packages.Count >= AppState.SearchResultLimit)
+                                           // Keep the op's result line visible after the reload rather than replacing it
+                                           // with a package count, so the user sees what just happened.
+                                           if (keepMessage is null)
                                            {
-                                               _state.StatusMessage = $"{AppState.SearchResultLimit}+ matches — refine your search to narrow";
+                                               int n = _state.Filtered.Count;
+                                               _state.StatusMessage = n == 1 ? "1 package" : $"{n} packages";
+
+                                               // A search that hit the result cap means there's more the user can't see;
+                                               // nudge them to narrow it (only the COM backend actually caps).
+                                               if (mode == AppMode.Search && packages.Count >= AppState.SearchResultLimit)
+                                               {
+                                                   _state.StatusMessage = $"{AppState.SearchResultLimit}+ matches — refine your search to narrow";
+                                               }
                                            }
                                            RefreshTable ();
                                            RefreshStatusBar ();
@@ -516,37 +533,8 @@ private void ApplyColumnStyles (MarkedTableSource marked)
                 Focus = new (Theme.Accent, Theme.Surface, TextStyle.Bold)
             };
 
-            // Pin column widths by setting MinWidth = MaxWidth. Otherwise TableView's
-            // CalculateMaxCellWidth scans the visible viewport and recomputes widths every
-            // frame from the max content width — so when the user presses Down arrow and
-            // a new row enters the viewport with different content widths, all columns
-            // shift. Fixed widths avoid that visual jump.
-            string name = marked.ColumnNames [i];
-
-            if (name.StartsWith ("Name", StringComparison.Ordinal))
-            {
-                s.MinWidth = 24;
-                s.MaxWidth = 24;
-            }
-            else if (name.StartsWith ("Id", StringComparison.Ordinal))
-            {
-                s.MinWidth = 28;
-                s.MaxWidth = 28;
-            }
-            else if (name.StartsWith ("Version", StringComparison.Ordinal))
-            {
-                s.MinWidth = 14;
-                s.MaxWidth = 14;
-            }
-            else if (name == "Available")
-            {
-                s.MinWidth = 14;
-                s.MaxWidth = 14;
-            }
-            else if (name == "Source")
+            if (marked.ColumnNames [i] == "Source")
             {
-                s.MinWidth = 8;
-                s.MaxWidth = 8;
                 s.ColorGetter = args =>
                 {
                     string val = args.CellValue?.ToString () ?? string.Empty;
@@ -568,6 +556,81 @@ private void ApplyColumnStyles (MarkedTableSource marked)
                 };
             }
         }
+
+        // Pin per-column widths (MinWidth = MaxWidth). Otherwise TableView's CalculateMaxCellWidth
+        // recomputes widths every frame from the visible rows' content, so scrolling jumps columns
+        // around. Width depends on the table's current size, so re-run on resize (ViewportChanged).
+        ApplyColumnWidths (force: true);
+    }
+
+    private int _lastColumnLayoutWidth = -1;
+
+    /// <summary>
+    /// Sizes the data columns to the table's current width. Name/Id/Version shrink toward minimums
+    /// when the terminal is narrow so the <b>Available</b> column stays visible — it sits just
+    /// before the expanding Source column and is otherwise the first to be pushed off-screen, so a
+    /// user on a small window can't tell it exists. Wired to ViewportChanged to reflow on resize.
+    /// </summary>
+    private void ApplyColumnWidths (bool force = false)
+    {
+        ITableSource? table = _packageTable.Table;
+
+        if (table is null)
+        {
+            return;
+        }
+
+        int avail = _packageTable.Viewport.Width;
+
+        if (avail <= 0 || (!force && avail == _lastColumnLayoutWidth))
+        {
+            return;
+        }
+
+        _lastColumnLayoutWidth = avail;
+
+        string [] names = table.ColumnNames;
+
+        // Preferred widths, and how far each may shrink. Available/Source are not shrunk so they
+        // survive; Source is the ExpandLastColumn target and fills whatever remains.
+        int nameW = 24, idW = 28, verW = 14;
+        const int availW = 14, sourceW = 8, srcReserve = 6;
+        const int nameMin = 14, idMin = 16, verMin = 9;
+
+        bool hasAvailable = names.Contains ("Available");
+        int dataCols = Math.Max (0, names.Length - 1); // exclude the 1-wide marker column
+
+        // Reserve the marker, rough inter-column padding, and a minimum for the expanding Source
+        // column, then shrink Id → Name → Version (in that order) to fit Name+Id+Version+Available.
+        int budget = avail - 1 - (dataCols + 1) - srcReserve;
+        int deficit = nameW + idW + verW + (hasAvailable ? availW : 0) - budget;
+
+        if (deficit > 0) { int c = Math.Min (deficit, idW - idMin); idW -= c; deficit -= c; }
+        if (deficit > 0) { int c = Math.Min (deficit, nameW - nameMin); nameW -= c; deficit -= c; }
+        if (deficit > 0) { int c = Math.Min (deficit, verW - verMin); verW -= c; deficit -= c; }
+
+        for (int i = 1; i < names.Length; i++)
+        {
+            string name = names [i];
+
+            int? w = name.StartsWith ("Name", StringComparison.Ordinal) ? nameW
+                   : name.StartsWith ("Id", StringComparison.Ordinal) ? idW
+                   : name.StartsWith ("Version", StringComparison.Ordinal) ? verW
+                   : name == "Available" ? availW
+                   : name == "Source" ? sourceW
+                   : null;
+
+            if (w is null)
+            {
+                continue;
+            }
+
+            ColumnStyle s = _packageTable.Style.GetOrCreateColumnStyle (i);
+            s.MinWidth = w.Value;
+            s.MaxWidth = w.Value;
+        }
+
+        _packageTable.SetNeedsDraw ();
     }
 
     private string HeaderWithSort (string label, SortField field)
@@ -1833,7 +1896,7 @@ private void AskBatchUpgrade ()
                                            _state.StatusIsError = false;
                                        }
 
-                                       TriggerRefresh ();
+                                       TriggerRefresh (_state.StatusMessage);
                                    });
                   });
     }
@@ -1904,7 +1967,7 @@ private void RunOperation (string activity, Func<IProgress<OpProgress>, Cancella
                                            }
                                        }
 
-                                       TriggerRefresh ();
+                                       TriggerRefresh (_state.StatusMessage);
                                    });
                   });
     }

src/ComBackend.cs

@@ -90,13 +90,21 @@ public async Task<IReadOnlyList<Package>> SearchAsync (string query, string? sou
                 CatalogPackage pkg = m.CatalogPackage;
                 string version = SafeVersion (SafeDefaultInstallVersion (pkg)) ?? LatestAvailableVersion (pkg) ?? string.Empty;
 
+                // The search composite (RemotePackagesFromRemoteCatalogs) correlates installed
+                // status, so a search row knows whether it's installed and whether an upgrade is
+                // available — surfaced so the UI can offer Uninstall/Upgrade rather than Install.
+                string? installedVersion = SafeVersion (SafeInstalledVersion (pkg));
+                bool updateAvailable = installedVersion is not null && SafeIsUpdateAvailable (pkg);
+
                 packages.Add (new ()
                 {
                     Id = pkg.Id,
                     Name = pkg.Name,
                     Version = version,
                     Source = SourceOf (pkg),
-                    MatchField = NotableMatchField (m)
+                    MatchField = NotableMatchField (m),
+                    InstalledVersion = installedVersion,
+                    AvailableVersion = updateAvailable ? LatestAvailableVersion (pkg) : null
                 });
             }
             catch
@@ -233,6 +241,7 @@ private async Task<IReadOnlyList<Package>> ListLocalAsync (string? source, bool
                 Name = Coalesce (meta?.PackageName, pkg.Name) ?? pkg.Id,
                 Version = SafeVersion (SafeInstalledVersion (pkg)) ?? SafeVersion (versionInfo) ?? string.Empty,
                 AvailableVersion = LatestAvailableVersion (pkg),
+                InstalledVersion = SafeVersion (installed),
                 Source = SourceOf (pkg),
                 Publisher = NullIfEmpty (meta?.Publisher),
                 Author = NullIfEmpty (meta?.Author),
@@ -615,8 +624,15 @@ public async Task<OpResult> RepairAsync (string id, IProgress<OpProgress>? progr
                 return new () { Outcome = VerifyOutcome.Error };
             }
 
-            List<VerifyCheck> checks = [];
-            bool anyFailed = false;
+            // CheckInstalledStatus returns one status block PER installer in the package's manifest
+            // (x64/arm64/x86 × user/machine, the portable variant, etc.). Only the installer that's
+            // actually present passes its checks; the others legitimately report "Apps & Features
+            // entry not found" (0x8A150201) and the like. So evaluate each installer independently
+            // and treat the package as installed correctly when ANY single installer's checks all
+            // pass — rather than flagging the package because some *other* manifest installer (which
+            // was never installed) didn't match. (The old code flattened all installers and reported
+            // Issues if any one check failed, so multi-installer packages always looked corrupt.)
+            List<List<VerifyCheck>> perInstaller = [];
             bool hadReadError = false;
 
             // Two nested projected vectors — indexed via Materialize (AOT rule).
@@ -635,6 +651,8 @@ public async Task<OpResult> RepairAsync (string id, IProgress<OpProgress>? progr
                     continue;
                 }
 
+                List<VerifyCheck> checks = [];
+
                 foreach (InstalledStatus entry in entries)
                 {
                     try
@@ -643,30 +661,35 @@ public async Task<OpResult> RepairAsync (string id, IProgress<OpProgress>? progr
                         bool ok = entry.Status is null;
                         string? path = NullIfEmpty (entry.Path);
                         checks.Add (new (StatusTypeName (entry.Type), ok, ok ? path : Coalesce (path, $"hr 0x{HResultOf (entry.Status):X8}")));
-
-                        if (!ok)
-                        {
-                            anyFailed = true;
-                        }
                     }
                     catch
                     {
                         hadReadError = true;
                     }
                 }
+
+                if (checks.Count > 0)
+                {
+                    perInstaller.Add (checks);
+                }
             }
 
-            // A confirmed failed check → Issues. Otherwise, if any read errored we can't honestly
-            // claim the install is clean, so report Error rather than Ok/NotApplicable.
-            VerifyOutcome outcome = anyFailed
-                                        ? VerifyOutcome.Issues
-                                        : hadReadError
-                                            ? VerifyOutcome.Error
-                                            : checks.Count == 0
-                                                ? VerifyOutcome.NotApplicable
-                                                : VerifyOutcome.Ok;
+            if (perInstaller.Count == 0)
+            {
+                // No installer yielded a readable check: can't honestly verify if a read errored.
+                return new () { Outcome = hadReadError ? VerifyOutcome.Error : VerifyOutcome.NotApplicable };
+            }
+
+            // Best-matching installer = the one with the fewest failing checks. If it has none, the
+            // package is installed correctly and we show that installer's clean checks; otherwise we
+            // surface the closest installer so the user sees the most relevant failures.
+            List<VerifyCheck> best = perInstaller.OrderBy (cs => cs.Count (c => !c.Ok)).First ();
 
-            return new () { Outcome = outcome, Checks = checks };
+            return new ()
+            {
+                Outcome = best.TrueForAll (c => c.Ok) ? VerifyOutcome.Ok : VerifyOutcome.Issues,
+                Checks = best
+            };
         }
         catch
         {
@@ -937,7 +960,11 @@ private PackageCatalogReference CompositeRef (List<PackageCatalogReference> refs
 
     private static async Task<PackageCatalog> ConnectAsync (PackageCatalogReference reference, CancellationToken ct)
     {
-        reference.AcceptSourceAgreements = true;
+        // NOTE: do NOT set AcceptSourceAgreements here. Every reference passed in is a *composite*
+        // (from CompositeRef), and setting AcceptSourceAgreements on a composite reference throws
+        // E_ILLEGAL_STATE_CHANGE. The API-correct place is each *source* reference before it's
+        // composited — RemoteRefs already does that. (This only surfaced once COM actually
+        // activated; under AOT the backend silently fell back to CLI, so the path was never run.)
         ConnectResult result = await reference.ConnectAsync ().AsTask (ct);
 
         if (result.Status != ConnectResultStatus.Ok || result.PackageCatalog is null)

src/DetailPanel.cs

@@ -68,6 +68,13 @@ public void SetDetail (PackageDetail? detail, bool loading)
             AddKv ("Available", detail.AvailableVersion, ValueScheme.Success);
         }
 
+        // On the Search tab a row can be one the user already has installed — make that obvious
+        // (the Installed/Upgrades tabs are installed by definition, so the badge is search-only).
+        if (Mode == AppMode.Search && !string.IsNullOrEmpty (detail.InstalledVersion))
+        {
+            AddSingle ($"✓ Installed ({detail.InstalledVersion})", Theme.Success, TextStyle.Bold);
+        }
+
         if (!string.IsNullOrEmpty (detail.Publisher))
         {
             AddKv ("Publisher", detail.Publisher);
@@ -201,8 +208,24 @@ public void SetDetail (PackageDetail? detail, bool loading)
         switch (Mode)
         {
             case AppMode.Search:
-                AddAction ("i", "Install");
-                AddAction ("I", "Install specific version");
+                if (!string.IsNullOrEmpty (detail.InstalledVersion))
+                {
+                    // Already installed: offer manage actions instead of a bare Install. Show
+                    // Upgrade only when the catalog's latest differs from what's installed.
+                    if (!string.IsNullOrEmpty (detail.AvailableVersion)
+                        && !string.Equals (detail.AvailableVersion, detail.InstalledVersion, StringComparison.OrdinalIgnoreCase))
+                    {
+                        AddAction ("u", "Upgrade");
+                    }
+
+                    AddAction ("x", "Uninstall");
+                    AddAction ("I", "Install specific version");
+                }
+                else
+                {
+                    AddAction ("i", "Install");
+                    AddAction ("I", "Install specific version");
+                }
 
                 break;
             case AppMode.Installed: