From cf0d812ec4d34ce61b64ebd157308107083a8bc9 Mon Sep 17 00:00:00 2001
From: Bob Lee <liwenbo628@gmail.com>
Date: Fri, 31 Jul 2026 05:20:54 -0700
Subject: [PATCH] fix(market): label installed MiniApps with their marketplace
 release

An installed MiniApp card showed `v{app.version}`, but that counter is the
local edit counter, which `build_created_app` always starts at 1. Installing
release v2 from the marketplace therefore rendered as "v1", reading as if the
install had silently fetched an older release. The download itself was correct:
the client requests `/listings/{slug}/releases/{n}/download` for the listing's
latest release and rejects any package whose sha256, size, or permissions do
not match the reviewed release.

Add `miniapp_market_installed_origins`, which returns the marketplace origin of
every installed app, and let the gallery label market-installed apps with the
release number they actually carry. Apps from anywhere else keep the local
counter.

Also collapse the listing detail's version history to the newest release, with
a toggle for the older ones, so a listing with several releases no longer
presents them as equally current.
---
 .../desktop/src/api/miniapp_market_api.rs     | 58 +++++++++++++++----
 .../src/api/remote_workspace_policy.rs        |  4 ++
 src/apps/desktop/src/lib.rs                   |  1 +
 .../miniapps/components/MiniAppCard.tsx       | 10 +++-
 .../miniapps/hooks/useMiniAppCatalogSync.ts   | 10 +++-
 .../app/scenes/miniapps/miniAppStore.test.ts  | 29 ++++++++++
 .../src/app/scenes/miniapps/miniAppStore.ts   | 18 ++++++
 .../utils/loadInstalledMarketOrigins.ts       | 25 ++++++++
 .../miniapps/views/MiniAppGalleryView.tsx     | 15 ++++-
 .../miniapps/views/MiniAppMarketView.scss     | 17 ++++++
 .../miniapps/views/MiniAppMarketView.tsx      | 23 +++++++-
 .../views/miniAppReleaseHistory.test.ts       | 40 +++++++++++++
 .../miniapps/views/miniAppReleaseHistory.ts   | 28 +++++++++
 .../api/service-api/MiniAppMarketAPI.ts       | 14 +++++
 .../src/locales/en-US/scenes/miniapp.json     |  2 +
 .../src/locales/zh-CN/scenes/miniapp.json     |  2 +
 .../src/locales/zh-TW/scenes/miniapp.json     |  2 +
 17 files changed, 281 insertions(+), 17 deletions(-)
 create mode 100644 src/web-ui/src/app/scenes/miniapps/utils/loadInstalledMarketOrigins.ts
 create mode 100644 src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.test.ts
 create mode 100644 src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.ts

diff --git a/src/apps/desktop/src/api/miniapp_market_api.rs b/src/apps/desktop/src/api/miniapp_market_api.rs
index 304cb4726b..d9c112d884 100644
--- a/src/apps/desktop/src/api/miniapp_market_api.rs
+++ b/src/apps/desktop/src/api/miniapp_market_api.rs
@@ -21,6 +21,7 @@ use bitfun_services_integrations::miniapp_market::{
     RatingAggregate, ValidatedMarketPackage,
 };
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use tauri::{AppHandle, Emitter, Manager, State, WebviewWindow};
 use tokio::io::AsyncWriteExt;
@@ -248,15 +249,7 @@ pub async fn miniapp_market_installed_status(
         .await
         .map_err(|error| error.to_string())?;
     for app in apps {
-        let Some(metadata) = state
-            .miniapp_manager
-            .load_customization_metadata(&app.id)
-            .await
-            .map_err(|error| error.to_string())?
-        else {
-            continue;
-        };
-        let Some(origin) = metadata.origin.market else {
+        let Some((origin, local_override)) = load_market_origin(&state, &app.id).await? else {
             continue;
         };
         if origin.listing_id == request.listing_id {
@@ -265,13 +258,58 @@ pub async fn miniapp_market_installed_status(
                 app_version: app.version,
                 permissions: app.permissions,
                 origin,
-                local_override: metadata.local_override,
+                local_override,
             }));
         }
     }
     Ok(None)
 }
 
+/// Marketplace origins of every installed MiniApp, keyed by local app id.
+///
+/// The local `MiniApp::version` counter tracks edits to the installed copy and
+/// is deliberately independent from the marketplace release number, so any
+/// surface that wants to name the release a user installed has to read it from
+/// the origin instead of from the app itself.
+#[tauri::command]
+pub async fn miniapp_market_installed_origins(
+    state: State<'_, AppState>,
+) -> Result<HashMap<String, InstalledMarketOrigin>, String> {
+    let apps = state
+        .miniapp_manager
+        .list()
+        .await
+        .map_err(|error| error.to_string())?;
+    let mut origins = HashMap::new();
+    for app in apps {
+        if let Some((origin, _)) = load_market_origin(&state, &app.id).await? {
+            origins.insert(app.id, origin);
+        }
+    }
+    Ok(origins)
+}
+
+/// Reads an app's marketplace origin plus its local-override flag, or `None`
+/// when the app did not come from the marketplace.
+async fn load_market_origin(
+    state: &AppState,
+    app_id: &str,
+) -> Result<Option<(InstalledMarketOrigin, bool)>, String> {
+    let Some(metadata) = state
+        .miniapp_manager
+        .load_customization_metadata(app_id)
+        .await
+        .map_err(|error| error.to_string())?
+    else {
+        return Ok(None);
+    };
+    let local_override = metadata.local_override;
+    Ok(metadata
+        .origin
+        .market
+        .map(|origin| (origin, local_override)))
+}
+
 #[tauri::command]
 pub async fn miniapp_market_install(
     state: State<'_, AppState>,
diff --git a/src/apps/desktop/src/api/remote_workspace_policy.rs b/src/apps/desktop/src/api/remote_workspace_policy.rs
index 23dae7d282..d04b4b7018 100644
--- a/src/apps/desktop/src/api/remote_workspace_policy.rs
+++ b/src/apps/desktop/src/api/remote_workspace_policy.rs
@@ -1149,6 +1149,10 @@ pub const REMOTE_WORKSPACE_COMMAND_POLICIES: &[(&str, RemoteWorkspacePolicy)] =
         RemoteWorkspacePolicy::LocalOnly,
     ),
     ("miniapp_market_install", RemoteWorkspacePolicy::LocalOnly),
+    (
+        "miniapp_market_installed_origins",
+        RemoteWorkspacePolicy::LocalOnly,
+    ),
     (
         "miniapp_market_installed_status",
         RemoteWorkspacePolicy::LocalOnly,
diff --git a/src/apps/desktop/src/lib.rs b/src/apps/desktop/src/lib.rs
index 181c4878f8..cdf42d1c3e 100644
--- a/src/apps/desktop/src/lib.rs
+++ b/src/apps/desktop/src/lib.rs
@@ -1679,6 +1679,7 @@ pub async fn run() {
             api::miniapp_market_api::miniapp_market_list_submissions,
             api::miniapp_market_api::miniapp_market_withdraw_submission,
             api::miniapp_market_api::miniapp_market_installed_status,
+            api::miniapp_market_api::miniapp_market_installed_origins,
             api::miniapp_market_api::miniapp_market_install,
             api::miniapp_market_api::miniapp_market_import_package,
             api::miniapp_market_api::miniapp_market_inspect_package,
diff --git a/src/web-ui/src/app/scenes/miniapps/components/MiniAppCard.tsx b/src/web-ui/src/app/scenes/miniapps/components/MiniAppCard.tsx
index 2bda9cc72d..7132a385a5 100644
--- a/src/web-ui/src/app/scenes/miniapps/components/MiniAppCard.tsx
+++ b/src/web-ui/src/app/scenes/miniapps/components/MiniAppCard.tsx
@@ -12,6 +12,13 @@ interface MiniAppCardProps {
   index?: number;
   isRunning?: boolean;
   isCustomizing?: boolean;
+  /**
+   * Marketplace release this copy was installed from, when it came from the
+   * marketplace. It takes over the version label because `app.version` is a
+   * local edit counter that always starts at 1 — showing it made a freshly
+   * installed v2 read as "v1".
+   */
+  marketReleaseNumber?: number;
   onOpenDetails: (app: MiniAppMeta) => void;
   onOpen: (id: string) => void;
   onDelete: (id: string) => void;
@@ -26,6 +33,7 @@ const MiniAppCard: React.FC<MiniAppCardProps> = ({
   index = 0,
   isRunning = false,
   isCustomizing = false,
+  marketReleaseNumber,
   onOpenDetails,
   onOpen,
   onDelete,
@@ -82,7 +90,7 @@ const MiniAppCard: React.FC<MiniAppCardProps> = ({
         </div>
         <div className="miniapp-card__title-group">
           <span className="miniapp-card__name">{localizedName}</span>
-          <span className="miniapp-card__version">v{app.version}</span>
+          <span className="miniapp-card__version">v{marketReleaseNumber ?? app.version}</span>
         </div>
         {(isRunning || isCustomizing) && (
           <span className="miniapp-card__status-dots" aria-hidden="true">
diff --git a/src/web-ui/src/app/scenes/miniapps/hooks/useMiniAppCatalogSync.ts b/src/web-ui/src/app/scenes/miniapps/hooks/useMiniAppCatalogSync.ts
index a9e0e84f9a..7c7e360360 100644
--- a/src/web-ui/src/app/scenes/miniapps/hooks/useMiniAppCatalogSync.ts
+++ b/src/web-ui/src/app/scenes/miniapps/hooks/useMiniAppCatalogSync.ts
@@ -7,6 +7,7 @@ import { miniAppAPI } from '@/infrastructure/api/service-api/MiniAppAPI';
 import { BackgroundTaskCancelledError } from '@/shared/utils/backgroundTaskScheduler';
 import { createLogger } from '@/shared/utils/logger';
 import { useMiniAppStore } from '../miniAppStore';
+import { loadInstalledMarketOrigins } from '../utils/loadInstalledMarketOrigins';
 import { scheduleMiniAppCatalogStartupRefresh } from './miniAppCatalogStartupRefresh';
 
 const log = createLogger('useMiniAppCatalogSync');
@@ -20,6 +21,7 @@ export function useMiniAppCatalogSync(options: UseMiniAppCatalogSyncOptions = {}
   const { enabled = true, initialLoad = 'immediate' } = options;
   const setApps = useMiniAppStore((state) => state.setApps);
   const setLoading = useMiniAppStore((state) => state.setLoading);
+  const setMarketOrigins = useMiniAppStore((state) => state.setMarketOrigins);
   const setRunningWorkerIds = useMiniAppStore((state) => state.setRunningWorkerIds);
   const markWorkerRunning = useMiniAppStore((state) => state.markWorkerRunning);
   const markWorkerStopped = useMiniAppStore((state) => state.markWorkerStopped);
@@ -27,14 +29,18 @@ export function useMiniAppCatalogSync(options: UseMiniAppCatalogSyncOptions = {}
   const refreshApps = useCallback(async () => {
     setLoading(true);
     try {
-      const apps = await miniAppAPI.listMiniApps();
+      const [apps, origins] = await Promise.all([
+        miniAppAPI.listMiniApps(),
+        loadInstalledMarketOrigins(),
+      ]);
       setApps(apps);
+      setMarketOrigins(origins);
     } catch (error) {
       log.error('Failed to load miniapps', error);
     } finally {
       setLoading(false);
     }
-  }, [setApps, setLoading]);
+  }, [setApps, setLoading, setMarketOrigins]);
 
   const refreshRunningWorkers = useCallback(async () => {
     try {
diff --git a/src/web-ui/src/app/scenes/miniapps/miniAppStore.test.ts b/src/web-ui/src/app/scenes/miniapps/miniAppStore.test.ts
index 8ea42df292..e8b0d69c31 100644
--- a/src/web-ui/src/app/scenes/miniapps/miniAppStore.test.ts
+++ b/src/web-ui/src/app/scenes/miniapps/miniAppStore.test.ts
@@ -13,6 +13,7 @@ describe('miniAppStore customization state', () => {
       runningWorkerIds: [],
       customizingAppIds: [],
       composerClaims: {},
+      marketOrigins: {},
     });
   });
 
@@ -54,6 +55,34 @@ describe('miniAppStore customization state', () => {
     expect(useMiniAppStore.getState().runningWorkerIds).toEqual(['gomoku']);
   });
 
+  it('keeps market origins only for apps still in the catalog', () => {
+    const origin = {
+      listingId: 'listing-1',
+      releaseId: 'release-2',
+      releaseNumber: 2,
+      packageSha256: 'a'.repeat(64),
+    };
+    useMiniAppStore.getState().setMarketOrigin('gomoku', origin);
+    useMiniAppStore.getState().setMarketOrigin('removed-app', origin);
+
+    useMiniAppStore.getState().setApps([
+      {
+        id: 'gomoku',
+        name: 'Gomoku',
+        description: '',
+        category: 'game',
+        version: 1,
+        icon: 'box',
+        tags: [],
+        created_at: 1,
+        updated_at: 1,
+        permissions: {},
+      },
+    ]);
+
+    expect(useMiniAppStore.getState().marketOrigins).toEqual({ gomoku: origin });
+  });
+
   it('adds and updates an installed app without waiting for a catalog reload', () => {
     const installed = {
       id: 'market-app',
diff --git a/src/web-ui/src/app/scenes/miniapps/miniAppStore.ts b/src/web-ui/src/app/scenes/miniapps/miniAppStore.ts
index 26654ad5d9..024c8512c3 100644
--- a/src/web-ui/src/app/scenes/miniapps/miniAppStore.ts
+++ b/src/web-ui/src/app/scenes/miniapps/miniAppStore.ts
@@ -3,6 +3,7 @@
  */
 import { create } from 'zustand';
 import type { MiniAppMeta } from '@/infrastructure/api/service-api/MiniAppAPI';
+import type { InstalledMarketOrigin } from '@/infrastructure/api/service-api/MiniAppMarketAPI';
 
 /**
  * Window event dispatched after the shared ChatInput routes a submission to a
@@ -146,10 +147,20 @@ interface MiniAppState {
   customizingAppIds: string[];
   /** Floating bubble registrations, keyed by app ID (`app.chat.claimComposer`). */
   composerClaims: Record<string, MiniAppComposerClaim>;
+  /**
+   * Marketplace origin of each installed app, keyed by app ID. Apps installed
+   * from anywhere else are simply absent. The local `version` counter on a
+   * MiniApp is independent from the marketplace release number, so this is what
+   * the gallery reads to name the release a user actually installed.
+   */
+  marketOrigins: Record<string, InstalledMarketOrigin>;
 
   setApps: (apps: MiniAppMeta[]) => void;
   upsertApp: (app: MiniAppMeta) => void;
   setLoading: (loading: boolean) => void;
+  setMarketOrigins: (origins: Record<string, InstalledMarketOrigin>) => void;
+  /** Records the origin of a single app right after a market install/update. */
+  setMarketOrigin: (appId: string, origin: InstalledMarketOrigin) => void;
   openApp: (id: string) => void;
   closeApp: (id: string) => void;
   setRunningWorkerIds: (ids: string[]) => void;
@@ -173,6 +184,7 @@ export const useMiniAppStore = create<MiniAppState>((set) => ({
   runningWorkerIds: [],
   customizingAppIds: [],
   composerClaims: {},
+  marketOrigins: {},
 
   setApps: (apps) =>
     set((state) => {
@@ -185,6 +197,9 @@ export const useMiniAppStore = create<MiniAppState>((set) => ({
         composerClaims: Object.fromEntries(
           Object.entries(state.composerClaims).filter(([id]) => validIds.has(id))
         ),
+        marketOrigins: Object.fromEntries(
+          Object.entries(state.marketOrigins).filter(([id]) => validIds.has(id))
+        ),
       };
     }),
   upsertApp: (app) =>
@@ -198,6 +213,9 @@ export const useMiniAppStore = create<MiniAppState>((set) => ({
       return { apps };
     }),
   setLoading: (loading) => set({ loading }),
+  setMarketOrigins: (marketOrigins) => set({ marketOrigins }),
+  setMarketOrigin: (appId, origin) =>
+    set((state) => ({ marketOrigins: { ...state.marketOrigins, [appId]: origin } })),
 
   openApp: (id) =>
     set((state) =>
diff --git a/src/web-ui/src/app/scenes/miniapps/utils/loadInstalledMarketOrigins.ts b/src/web-ui/src/app/scenes/miniapps/utils/loadInstalledMarketOrigins.ts
new file mode 100644
index 0000000000..124d0decc8
--- /dev/null
+++ b/src/web-ui/src/app/scenes/miniapps/utils/loadInstalledMarketOrigins.ts
@@ -0,0 +1,25 @@
+import {
+  miniAppMarketAPI,
+  type InstalledMarketOrigin,
+} from '@/infrastructure/api/service-api/MiniAppMarketAPI';
+import { createLogger } from '@/shared/utils/logger';
+
+const log = createLogger('installedMarketOrigins');
+
+/**
+ * Marketplace origins for the installed catalog, keyed by app id.
+ *
+ * Every catalog load pairs with this so version labels can name the release a
+ * user installed instead of the local edit counter. A failure degrades those
+ * labels back to the local counter rather than taking the catalog down with it.
+ */
+export async function loadInstalledMarketOrigins(): Promise<
+  Record<string, InstalledMarketOrigin>
+> {
+  try {
+    return await miniAppMarketAPI.installedOrigins();
+  } catch (error) {
+    log.warn('Failed to read installed MiniApp market origins', error);
+    return {};
+  }
+}
diff --git a/src/web-ui/src/app/scenes/miniapps/views/MiniAppGalleryView.tsx b/src/web-ui/src/app/scenes/miniapps/views/MiniAppGalleryView.tsx
index 4df307f31a..4b22a9d65a 100644
--- a/src/web-ui/src/app/scenes/miniapps/views/MiniAppGalleryView.tsx
+++ b/src/web-ui/src/app/scenes/miniapps/views/MiniAppGalleryView.tsx
@@ -32,6 +32,7 @@ import {
 } from '@/app/components';
 import type { SceneTabId } from '@/app/components/SceneBar/types';
 import { getMiniAppIconGradient, renderMiniAppIcon } from '../utils/miniAppIcons';
+import { loadInstalledMarketOrigins } from '../utils/loadInstalledMarketOrigins';
 import { pickLocalizedString, pickLocalizedTags } from '../utils/pickLocalizedString';
 import { useCurrentWorkspace } from '@/infrastructure/contexts/WorkspaceContext';
 import { useMiniAppStore } from '../miniAppStore';
@@ -47,8 +48,10 @@ const MiniAppGalleryView: React.FC = () => {
   const loading = useMiniAppStore((state) => state.loading);
   const runningWorkerIds = useMiniAppStore((state) => state.runningWorkerIds);
   const customizingAppIds = useMiniAppStore((state) => state.customizingAppIds);
+  const marketOrigins = useMiniAppStore((state) => state.marketOrigins);
   const setApps = useMiniAppStore((state) => state.setApps);
   const setLoading = useMiniAppStore((state) => state.setLoading);
+  const setMarketOrigins = useMiniAppStore((state) => state.setMarketOrigins);
   const setRunningWorkerIds = useMiniAppStore((state) => state.setRunningWorkerIds);
   const markWorkerStopped = useMiniAppStore((state) => state.markWorkerStopped);
   const { workspacePath } = useCurrentWorkspace();
@@ -160,18 +163,20 @@ const MiniAppGalleryView: React.FC = () => {
   const refetchMiniAppGallery = useCallback(async () => {
     setLoading(true);
     try {
-      const [refreshed, running] = await Promise.all([
+      const [refreshed, running, origins] = await Promise.all([
         miniAppAPI.listMiniApps(),
         miniAppAPI.workerListRunning(),
+        loadInstalledMarketOrigins(),
       ]);
       setApps(refreshed);
       setRunningWorkerIds(running);
+      setMarketOrigins(origins);
     } catch (error) {
       log.error('Failed to refresh miniapp gallery', error);
     } finally {
       setLoading(false);
     }
-  }, [setApps, setLoading, setRunningWorkerIds]);
+  }, [setApps, setLoading, setMarketOrigins, setRunningWorkerIds]);
 
   useGallerySceneAutoRefresh({
     sceneId: 'miniapps',
@@ -294,6 +299,7 @@ const MiniAppGalleryView: React.FC = () => {
             index={index}
             isRunning={runningIdSet.has(app.id)}
             isCustomizing={customizingIdSet.has(app.id)}
+            marketReleaseNumber={marketOrigins[app.id]?.releaseNumber}
             onOpenDetails={setSelectedApp}
             onOpen={handleOpenApp}
             onDelete={handleDeleteRequest}
@@ -347,6 +353,7 @@ const MiniAppGalleryView: React.FC = () => {
                   index={index}
                   isRunning
                   isCustomizing={customizingIdSet.has(app.id)}
+                  marketReleaseNumber={marketOrigins[app.id]?.releaseNumber}
                   onOpenDetails={setSelectedApp}
                   onOpen={handleOpenApp}
                   onDelete={handleDeleteRequest}
@@ -400,7 +407,9 @@ const MiniAppGalleryView: React.FC = () => {
         title={selectedApp ? pickLocalizedString(selectedApp, currentLanguage, 'name') : ''}
         badges={selectedApp?.category ? <Badge variant="info">{selectedApp.category}</Badge> : null}
         description={selectedApp ? pickLocalizedString(selectedApp, currentLanguage, 'description') : undefined}
-        meta={selectedApp ? <span>v{selectedApp.version}</span> : null}
+        meta={selectedApp ? (
+          <span>v{marketOrigins[selectedApp.id]?.releaseNumber ?? selectedApp.version}</span>
+        ) : null}
         actions={selectedApp ? (
           <>
             {runningIdSet.has(selectedApp.id) ? (
diff --git a/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.scss b/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.scss
index 17d90514e7..11594e0e7b 100644
--- a/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.scss
+++ b/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.scss
@@ -232,6 +232,23 @@
       font-size: var(--font-size-sm);
     }
   }
+
+  &__releases-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: $size-gap-1;
+    margin-top: $size-gap-2;
+    padding: 0;
+    border: 0;
+    background: transparent;
+    color: var(--color-text-muted);
+    font-size: var(--font-size-xs);
+    cursor: pointer;
+
+    &:hover {
+      color: var(--color-text-secondary);
+    }
+  }
 }
 
 @media (max-width: 720px) {
diff --git a/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.tsx b/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.tsx
index 14c630d2ad..57903ea351 100644
--- a/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.tsx
+++ b/src/web-ui/src/app/scenes/miniapps/views/MiniAppMarketView.tsx
@@ -3,6 +3,8 @@ import {
   AlertTriangle,
   ArrowUpRight,
   Check,
+  ChevronDown,
+  ChevronUp,
   Download,
   ExternalLink,
   Heart,
@@ -51,6 +53,7 @@ import { useNotification } from '@/shared/notification-system';
 import { getMiniAppIconGradient, renderMiniAppIcon } from '../utils/miniAppIcons';
 import { useMiniAppStore } from '../miniAppStore';
 import { pickLocalizedString } from '../utils/pickLocalizedString';
+import { buildReleaseHistory } from './miniAppReleaseHistory';
 import './MiniAppMarketView.scss';
 
 const log = createLogger('MiniAppMarketView');
@@ -72,6 +75,7 @@ const MiniAppMarketView: React.FC = () => {
   const { workspace } = useCurrentWorkspace();
   const { openScene, activateScene, openTabs } = useSceneManager();
   const upsertApp = useMiniAppStore((state) => state.upsertApp);
+  const setMarketOrigin = useMiniAppStore((state) => state.setMarketOrigin);
   const [query, setQuery] = useState('');
   const [category, setCategory] = useState<(typeof CATEGORIES)[number]>('all');
   const [sort, setSort] = useState<MarketSort>('newest');
@@ -87,6 +91,7 @@ const MiniAppMarketView: React.FC = () => {
   const [authBusy, setAuthBusy] = useState(false);
   const [actionBusy, setActionBusy] = useState(false);
   const [installPrompt, setInstallPrompt] = useState(false);
+  const [releasesExpanded, setReleasesExpanded] = useState(false);
 
   const openTabIds = useMemo(() => new Set(openTabs.map((tab) => tab.id)), [openTabs]);
 
@@ -143,6 +148,7 @@ const MiniAppMarketView: React.FC = () => {
     setDetailLoading(true);
     setDetail(undefined);
     setInstalled(null);
+    setReleasesExpanded(false);
     try {
       const loaded = await miniAppMarketAPI.getListing(summary.slug);
       setDetail(loaded);
@@ -254,6 +260,7 @@ const MiniAppMarketView: React.FC = () => {
         confirmOverwrite: Boolean(installed?.localOverride),
       });
       upsertApp(result.app);
+      setMarketOrigin(result.app.id, result.origin);
       notification.success(
         t(result.updated ? 'market.messages.updated' : 'market.messages.installed'),
       );
@@ -288,6 +295,7 @@ const MiniAppMarketView: React.FC = () => {
       && isRemoteWorkspace(workspace)
       && requiresWorkspace(detail.permissions),
   );
+  const releaseHistory = buildReleaseHistory(detail?.releases ?? [], releasesExpanded);
   const canUpdate = Boolean(installed && detail && detail.latestRelease > installed.origin.releaseNumber);
   // The install button only renders for the actionable states: fresh install or update.
   const installLabel = canUpdate ? t('market.detail.update') : t('market.detail.install');
@@ -561,7 +569,7 @@ const MiniAppMarketView: React.FC = () => {
             <section>
               <h4>{t('market.detail.releases')}</h4>
               <div className="miniapp-market-detail__releases">
-                {detail.releases.map((release) => (
+                {releaseHistory.visible.map((release) => (
                   <div key={release.releaseId}>
                     <span>v{release.releaseNumber}</span>
                     <span>{release.minBitfunVersion}+</span>
@@ -569,6 +577,19 @@ const MiniAppMarketView: React.FC = () => {
                   </div>
                 ))}
               </div>
+              {detail.releases.length > 1 ? (
+                <button
+                  type="button"
+                  className="miniapp-market-detail__releases-toggle"
+                  aria-expanded={releasesExpanded}
+                  onClick={() => setReleasesExpanded((current) => !current)}
+                >
+                  {releasesExpanded ? <ChevronUp size={13} /> : <ChevronDown size={13} />}
+                  {releasesExpanded
+                    ? t('market.detail.releasesCollapse')
+                    : t('market.detail.releasesExpand', { count: releaseHistory.hiddenCount })}
+                </button>
+              ) : null}
             </section>
             {detail.repositoryUrl ? (
               <Button
diff --git a/src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.test.ts b/src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.test.ts
new file mode 100644
index 0000000000..cee19442d8
--- /dev/null
+++ b/src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { buildReleaseHistory } from './miniAppReleaseHistory';
+
+describe('MiniApp market release history', () => {
+  it('collapses to the newest release', () => {
+    const history = buildReleaseHistory(
+      [{ releaseNumber: 2 }, { releaseNumber: 1 }],
+      false,
+    );
+
+    expect(history.visible).toEqual([{ releaseNumber: 2 }]);
+    expect(history.hiddenCount).toBe(1);
+  });
+
+  it('shows every release newest-first once expanded', () => {
+    const history = buildReleaseHistory(
+      [{ releaseNumber: 1 }, { releaseNumber: 3 }, { releaseNumber: 2 }],
+      true,
+    );
+
+    expect(history.visible.map((release) => release.releaseNumber)).toEqual([3, 2, 1]);
+    expect(history.hiddenCount).toBe(0);
+  });
+
+  it('keeps the newest release visible when the list arrives out of order', () => {
+    const history = buildReleaseHistory(
+      [{ releaseNumber: 1 }, { releaseNumber: 4 }],
+      false,
+    );
+
+    expect(history.visible).toEqual([{ releaseNumber: 4 }]);
+  });
+
+  it('offers nothing to expand for a single release', () => {
+    const history = buildReleaseHistory([{ releaseNumber: 1 }], false);
+
+    expect(history.visible).toEqual([{ releaseNumber: 1 }]);
+    expect(history.hiddenCount).toBe(0);
+  });
+});
diff --git a/src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.ts b/src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.ts
new file mode 100644
index 0000000000..477743408a
--- /dev/null
+++ b/src/web-ui/src/app/scenes/miniapps/views/miniAppReleaseHistory.ts
@@ -0,0 +1,28 @@
+/** A release entry as far as the version history list is concerned. */
+export interface ReleaseHistoryEntry {
+  releaseNumber: number;
+}
+
+export interface ReleaseHistoryView<T extends ReleaseHistoryEntry> {
+  /** Releases to render, newest first. */
+  visible: T[];
+  /** Older releases folded away while collapsed. */
+  hiddenCount: number;
+}
+
+/**
+ * Only the newest release matters to someone deciding whether to install, so
+ * the history collapses to that single row until it is expanded. The server
+ * already returns releases newest-first, but the order is re-established here
+ * so the visible row is the newest one regardless of how the list arrived.
+ */
+export function buildReleaseHistory<T extends ReleaseHistoryEntry>(
+  releases: T[],
+  expanded: boolean,
+): ReleaseHistoryView<T> {
+  const ordered = [...releases].sort((a, b) => b.releaseNumber - a.releaseNumber);
+  if (expanded || ordered.length <= 1) {
+    return { visible: ordered, hiddenCount: 0 };
+  }
+  return { visible: ordered.slice(0, 1), hiddenCount: ordered.length - 1 };
+}
diff --git a/src/web-ui/src/infrastructure/api/service-api/MiniAppMarketAPI.ts b/src/web-ui/src/infrastructure/api/service-api/MiniAppMarketAPI.ts
index 1d90c11f3c..bbe419a751 100644
--- a/src/web-ui/src/infrastructure/api/service-api/MiniAppMarketAPI.ts
+++ b/src/web-ui/src/infrastructure/api/service-api/MiniAppMarketAPI.ts
@@ -281,6 +281,20 @@ export class MiniAppMarketAPI {
     }
   }
 
+  /**
+   * Marketplace origins of every installed MiniApp, keyed by local app id.
+   * Installed apps carry a local version counter that is independent from the
+   * marketplace release number, so surfaces that want to name the installed
+   * release read it from here.
+   */
+  async installedOrigins(): Promise<Record<string, InstalledMarketOrigin>> {
+    try {
+      return await api.invoke('miniapp_market_installed_origins', {});
+    } catch (error) {
+      throw createTauriCommandError('miniapp_market_installed_origins', error);
+    }
+  }
+
   async install(
     slug: string,
     releaseNumber: number,
diff --git a/src/web-ui/src/locales/en-US/scenes/miniapp.json b/src/web-ui/src/locales/en-US/scenes/miniapp.json
index 2d0adaf5aa..7f49342529 100644
--- a/src/web-ui/src/locales/en-US/scenes/miniapp.json
+++ b/src/web-ui/src/locales/en-US/scenes/miniapp.json
@@ -80,6 +80,8 @@
       "rating": "Rating",
       "changelog": "What's new",
       "releases": "Version history",
+      "releasesExpand": "Show older releases ({{count}})",
+      "releasesCollapse": "Show only the latest release",
       "yanked": "Permanently yanked",
       "repository": "View public repository",
       "remoteWorkspaceUnsupported": "This app requires {workspace}; installing and running it is unavailable in remote workspaces.",
diff --git a/src/web-ui/src/locales/zh-CN/scenes/miniapp.json b/src/web-ui/src/locales/zh-CN/scenes/miniapp.json
index baaa76abf1..7e3518f1f9 100644
--- a/src/web-ui/src/locales/zh-CN/scenes/miniapp.json
+++ b/src/web-ui/src/locales/zh-CN/scenes/miniapp.json
@@ -80,6 +80,8 @@
       "rating": "评分",
       "changelog": "版本说明",
       "releases": "版本历史",
+      "releasesExpand": "展开历史版本（{{count}}）",
+      "releasesCollapse": "仅显示最新版本",
       "yanked": "已永久撤回",
       "repository": "查看公开仓库",
       "remoteWorkspaceUnsupported": "此应用需要 {workspace}，远程工作区暂不支持安装或运行。",
diff --git a/src/web-ui/src/locales/zh-TW/scenes/miniapp.json b/src/web-ui/src/locales/zh-TW/scenes/miniapp.json
index d9038f0d01..c1d75e8ea5 100644
--- a/src/web-ui/src/locales/zh-TW/scenes/miniapp.json
+++ b/src/web-ui/src/locales/zh-TW/scenes/miniapp.json
@@ -80,6 +80,8 @@
       "rating": "評分",
       "changelog": "版本說明",
       "releases": "版本歷史",
+      "releasesExpand": "展開歷史版本（{{count}}）",
+      "releasesCollapse": "僅顯示最新版本",
       "yanked": "已永久撤回",
       "repository": "查看公開儲存庫",
       "remoteWorkspaceUnsupported": "此應用需要 {workspace}，遠端工作區暫不支援安裝或執行。",