@@ -162,6 +162,14 @@ were often broken in a way that only showed up on somebody else's machine.
 
 ### Changed
 
+- **The Microsoft Store version tells you when the Store has a newer one.** It used to
+  say only that the Store keeps it up to date, even when the Store hadn't got to it yet.
+  Now **Check for updates**, and a quiet check at start, ask the Store which version it
+  offers. When that is newer than yours, a bar at the top and Settings say which version
+  is there and which you have, with an **Open the Microsoft Store** button; press Update
+  on that page. The app still downloads and installs nothing itself in a Store copy, and
+  the request carries only the app's Store ID.
+
 - **A watched channel's re-sends keep its first choice of clips.** Retry failed and the
   re-send of posts a platform rejected now send only clips the video's first publish
   chose, even if processing the video again changed the scores or made new clips in
 
@@ -303,7 +303,8 @@ Running from source needs the things the installer would otherwise bundle for yo
 **The easiest way is the [Microsoft Store](https://apps.microsoft.com/detail/9NB6XT7DSQZZ).**
 One click, it updates itself, and Windows raises no security prompt. Microsoft
 certified and signed the package, so the SmartScreen warning described below
-does not appear at all.
+does not appear at all. The Store installs new versions when it gets to them; to have
+one at once, open Clips Kitty's page in the Microsoft Store and press **Update**.
 
 **Or grab the installer.** The latest **Web Setup** from
 [Releases](../../releases) and run it. It carries the app, the Python engine, every
 
@@ -386,7 +386,7 @@ reality:
 
 | | Standalone | Store |
 |---|---|---|
-| Updates | electron-updater, Hugging Face feed | the Store |
+| Updates | electron-updater, Hugging Face feed | the Store installs them; the app asks the Store's catalog which version it offers and, when this copy is behind, says so with a button to the Store page (`ui/src/main/storeVersion.ts`) |
 | Donate button | PayPal in a locked-down in-app window | PayPal in the system browser |
 
 Everything else (the engine, the models, the pipeline, the data directory) is
 
@@ -62,7 +62,7 @@ <h1>Clips Kitty does not collect anything about you</h1>
             service you have connected. This page explains exactly what is stored, what can
             leave your machine, and what triggers it.
           </p>
-          <p><strong>Last updated:</strong> 7 October 2026</p>
+          <p><strong>Last updated:</strong> 8 October 2026</p>
         </div>
       </div>
 
@@ -112,7 +112,7 @@ <h3>Because you asked it to</h3>
 
           <h3>On its own, and you can switch it off</h3>
           <ul>
-            <li><strong>Checking for updates.</strong> The desktop app asks a static file on Hugging Face whether a newer version exists. This is a plain file fetch with no identifier attached, and it can be turned off in Settings. Copies installed from the Microsoft Store do not do this at all, because the Store handles updates.</li>
+            <li><strong>Checking for updates.</strong> The desktop app asks a static file on Hugging Face whether a newer version exists. This is a plain file fetch with no identifier attached, and it can be turned off in Settings. Copies installed from the Microsoft Store ask Microsoft's Store catalog instead which version the Store offers, when the app starts and when you press Check for updates: one plain request that carries the app's Store ID and nothing about you or your computer. The Store itself downloads and installs the update.</li>
             <li><strong>Checking for new pipelines.</strong> When you open the Marketplace, or start Clips Kitty with a pipeline installed, and the app's copy of the list of pipelines is more than a day old, the app downloads Clips Kitty's current list: one file from raw.githubusercontent.com, where GitHub serves the files of Clips Kitty's public code. It brings new pipelines and warnings about pipelines found to be harmful. This is a plain file fetch with no identifier attached; nothing about what you browse, search or have installed is sent. It can be switched off at the bottom of the Marketplace's Browse tab, and the Check for new pipelines button there fetches the list when you press it.</li>
           </ul>
 
 
@@ -0,0 +1,132 @@
+"""A Microsoft Store copy says when the Store has a newer version.
+
+The Store updates a Store copy, on its own schedule; the app never downloads
+or installs anything there. What it does is ask the Store's public catalog
+which version is offered and compare that with the one running, so somebody
+whose Store has not updated yet is told, with a button to the Store page.
+
+The two decisions in that (which version the catalog's answer names, and
+whether one version is newer than another) are in ui/src/main/storeVersion.ts,
+which has no Electron in it and is run here under Node. The rest is checked as
+text: the ids match the ones the package and the README use, and a Store copy
+still never reaches for the installer's updater.
+"""
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent.parent
+MAIN = ROOT / "ui" / "src" / "main"
+
+
+def _node() -> str:
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("Node isn't available")
+    return node
+
+
+def _run(tmp_path, cases: list, body: str) -> list:
+    """Run `body` (JavaScript: `m` is the module, `c` one case) over the cases."""
+    (tmp_path / "storeVersion.ts").write_text((MAIN / "storeVersion.ts").read_text(encoding="utf-8"), encoding="utf-8")
+    (tmp_path / "cases.json").write_text(json.dumps(cases), encoding="utf-8")
+    script = (
+        f"const m = await import({json.dumps((tmp_path / 'storeVersion.ts').as_uri())});"
+        "const fs = await import('node:fs');"
+        f"const cases = JSON.parse(fs.readFileSync({json.dumps(str(tmp_path / 'cases.json'))}, 'utf8'));"
+        f"console.log(JSON.stringify(cases.map((c) => {{ {body} }})));"
+    )
+    r = subprocess.run([_node(), "--experimental-strip-types", "--no-warnings", "--input-type=module", "-e", script],
+                       capture_output=True, text=True, encoding="utf-8", timeout=120)
+    if r.returncode != 0 and "strip-types" in r.stderr:
+        pytest.skip("this Node can't run TypeScript directly")
+    assert r.returncode == 0, r.stderr
+    return json.loads(r.stdout)
+
+
+def _catalog(*full_names):
+    """The catalog's answer, cut down to the part that names packages."""
+    return {"Product": {"ProductId": "9NB6XT7DSQZZ", "DisplaySkuAvailabilities": [
+        {"Sku": {"Properties": {"Packages": [{"PackageFullName": n, "MaxDownloadSizeInBytes": 1}]}}}
+        for n in full_names]}}
+
+
+def test_the_version_the_store_offers_is_read_from_its_packages(tmp_path):
+    ours = "ClipsStudio.ClipsStudio_{}_x64__315g1r74a6w58"
+    cases = [
+        _catalog(ours.format("2.0.0.0")),
+        _catalog(ours.format("2.0.0.0"), ours.format("2.0.0.0")),  # one per SKU, as the Store answers today
+        _catalog(ours.format("1.2.0.0"), ours.format("2.1.0.0"), ours.format("2.0.0.0")),  # the highest
+        _catalog(ours.format("2.9.0.0"), ours.format("2.10.0.0")),  # by number, not by letter
+        _catalog("SomeoneElse.Other_9.0.0.0_x64__abcdefghjkmnp", ours.format("2.0.0.0")),  # only this app's
+        _catalog("SomeoneElse.Other_9.0.0.0_x64__abcdefghjkmnp"),
+        _catalog(ours.format("2.0.0")),  # not a package version
+        _catalog(),
+        {"Product": None},
+        {"code": "NotFound"},
+        None,
+        "not json at all",
+        [],
+    ]
+    got = _run(tmp_path, cases, "return m.storeVersionOf(c)")
+    assert got == ["2.0.0", "2.0.0", "2.1.0", "2.10.0", "2.0.0", None, None, None, None, None, None, None, None]
+
+
+def test_newer_means_a_later_version_and_nothing_else(tmp_path):
+    cases = [
+        ("2.0.0", "1.1.4", True), ("2.0.0", "1.2.0", True), ("2.0.1", "2.0.0", True), ("2.10.0", "2.9.0", True),
+        ("2.0.0", "2.0.0", False), ("2.0", "2.0.0", False), ("2.0.0", "2.0", False),
+        ("1.2.0", "2.0.0", False),  # the Store behind this copy (a test build): no "update"
+        ("2.1.0-beta.1", "2.0.0", False), ("2.1.0", "2.1.0-beta.1", False), ("", "2.0.0", False),
+        ("latest", "2.0.0", False),
+    ]
+    got = _run(tmp_path, [list(c[:2]) for c in cases], "return m.isNewer(c[0], c[1])")
+    assert got == [c[2] for c in cases]
+
+
+def test_the_ids_are_the_ones_the_package_and_the_readme_use():
+    source = (MAIN / "storeVersion.ts").read_text(encoding="utf-8")
+    product = re.search(r"STORE_PRODUCT_ID = '([A-Z0-9]+)'", source).group(1)
+    identity = re.search(r"STORE_IDENTITY = '([\w.]+)'", source).group(1)
+    assert f"apps.microsoft.com/detail/{product}" in (ROOT / "README.md").read_text(encoding="utf-8")
+    builder = (ROOT / "ui" / "electron-builder.yml").read_text(encoding="utf-8")
+    assert re.search(rf"^\s*identityName: {re.escape(identity)}\s*$", builder, re.M)
+    # The Store's own page and catalog, by that id, and nowhere else.
+    assert "ms-windows-store://pdp/?ProductId=${STORE_PRODUCT_ID}" in source
+    assert "https://displaycatalog.mp.microsoft.com/v7.0/products/${STORE_PRODUCT_ID}?" in source
+
+
+def test_a_store_copy_asks_the_store_and_never_runs_the_installers_updater():
+    """Everything a Store copy does about updates is before the `return` that
+    ends its branch, and none of it touches electron-updater."""
+    source = (MAIN / "updater.ts").read_text(encoding="utf-8")
+    start = source.index("if (isMicrosoftStore()) {")
+    branch = source[start:source.index("\n    return\n  }\n", start)]
+    assert "autoUpdater" not in branch
+    assert "net.fetch(STORE_CATALOG" in branch and "storeVersionOf(" in branch and "isNewer(" in branch
+    for handler in ("update:check", "update:download", "update:install", "update:skip", "update:prefs"):
+        assert f"ipcMain.handle('{handler}'" in branch, handler
+    # Download and install stay refused there: the Store does both.
+    assert "ipcMain.handle('update:download', async () => ({ ok: false }))" in branch
+    assert "ipcMain.handle('update:install', () => ({ ok: false }))" in branch
+    # The button opens the Store's page, a fixed address the page can't choose.
+    assert "shell.openExternal(STORE_PAGE)" in source
+
+
+def test_the_screens_say_which_version_and_offer_the_store():
+    renderer = ROOT / "ui" / "src" / "renderer" / "src"
+    settings = (renderer / "pages" / "Settings.tsx").read_text(encoding="utf-8")
+    banner = (renderer / "components" / "UpdateBanner.tsx").read_text(encoding="utf-8")
+    assert "Version ${state.version} is in the Microsoft Store. This copy is ${state.current}." in settings
+    assert "You're on the latest version (${state.current})." in settings
+    assert "Couldn't check the Microsoft Store just now." in settings
+    assert "window.studio.update.openStore()" in settings and "window.studio.update.openStore()" in banner
+    # The bar shows only when the Store is ahead and that version wasn't skipped.
+    assert "if (!s.behind || s.skipped) return null" in banner
+    assert "openStore: (): Promise<{ ok: boolean }> => ipcRenderer.invoke('update:openStore')" in (
+        ROOT / "ui" / "src" / "preload" / "index.ts").read_text(encoding="utf-8")
@@ -0,0 +1,76 @@
+// Which version the Microsoft Store offers, read from its public catalog.
+//
+// A Store copy is updated by the Store, never by this app (distribution.ts).
+// But the Store updates on its own schedule, and that can be paused, switched
+// off or stuck behind a download of several gigabytes. A copy that only says
+// "the Store keeps this up to date" leaves somebody three versions behind with
+// no way to know. So the app asks what the Store has and says when it is newer.
+//
+// The Store's own catalog, not the Hugging Face feed the standalone build
+// reads: a release is on Hugging Face a day or more before certification
+// finishes, and "a new version is out" must never send people to a Store that
+// does not have it yet.
+//
+// No Electron in here, so it runs under Node in tests/test_ui_store_update.py.
+
+/** Clips Kitty in the Microsoft Store (the id in the README's Store link). */
+export const STORE_PRODUCT_ID = '9NB6XT7DSQZZ'
+
+/** The package's name (appx.identityName in electron-builder.yml). */
+export const STORE_IDENTITY = 'ClipsStudio.ClipsStudio'
+
+/** Clips Kitty's page in the Store app, where Update is pressed. */
+export const STORE_PAGE = `ms-windows-store://pdp/?ProductId=${STORE_PRODUCT_ID}`
+
+/** One plain request, carrying the product id and nothing about this PC. */
+export const STORE_CATALOG = `https://displaycatalog.mp.microsoft.com/v7.0/products/${STORE_PRODUCT_ID}?market=US&languages=en-US`
+
+function parts(version: string): number[] | null {
+  if (!/^\d+(\.\d+)*$/.test(version)) return null
+  return version.split('.').map(Number)
+}
+
+/** True when `a` is a later version than `b`. A part left out counts as 0,
+ *  so 2.0 and 2.0.0 are the same version. Anything that is not numbers and
+ *  dots (a pre-release name) is never newer: saying nothing beats saying
+ *  "update" wrongly. */
+export function isNewer(a: string, b: string): boolean {
+  const x = parts(a)
+  const y = parts(b)
+  if (!x || !y) return false
+  for (let i = 0; i < Math.max(x.length, y.length); i++) {
+    const d = (x[i] ?? 0) - (y[i] ?? 0)
+    if (d !== 0) return d > 0
+  }
+  return false
+}
+
+/** The app version the Store offers, as "2.0.0": the highest among the
+ *  catalog's packages of this app. A package is 2.0.0.0 (the fourth part is
+ *  the Store's own and always 0), and the app calls that 2.0.0. null when the
+ *  answer has no such package, whatever shape it came in. */
+export function storeVersionOf(catalog: unknown, identity: string = STORE_IDENTITY): string | null {
+  const names: string[] = []
+  const walk = (node: unknown, depth: number): void => {
+    if (depth > 12 || node === null || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item, depth + 1)
+      return
+    }
+    for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
+      if (key === 'PackageFullName' && typeof value === 'string') names.push(value)
+      else walk(value, depth + 1)
+    }
+  }
+  walk(catalog, 0)
+
+  let best: string | null = null
+  for (const name of names) {
+    // ClipsStudio.ClipsStudio_2.0.0.0_x64__315g1r74a6w58
+    const [who, version] = name.split('_')
+    if (who !== identity || !version || !/^\d+\.\d+\.\d+\.\d+$/.test(version)) continue
+    const app = version.split('.').slice(0, 3).join('.')
+    if (best === null || isNewer(app, best)) best = app
+  }
+  return best
+}
@@ -13,11 +13,12 @@
 // payload is too big for a release asset, so it lives on Hugging Face. See the
 // publish block in electron-builder.yml.
 
-import { app, ipcMain, type BrowserWindow } from 'electron'
+import { app, ipcMain, net, shell, type BrowserWindow } from 'electron'
 import { readFileSync, statSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { autoUpdater, type UpdateInfo } from 'electron-updater'
 import { isMicrosoftStore } from './distribution'
+import { STORE_CATALOG, STORE_PAGE, isNewer, storeVersionOf } from './storeVersion'
 
 /** Which releases this install is offered. Alpha sees everything, stable
  *  only sees finished releases. Read from the same file the renderer writes,
@@ -156,24 +157,64 @@ function stopPackageWatch(): void {
 export function setupUpdater(win: BrowserWindow): void {
   mainWindow = win
 
+  // Clips Kitty's page in the Store app. Only a Store copy shows the button.
+  ipcMain.handle('update:openStore', async () => {
+    await shell.openExternal(STORE_PAGE)
+    return { ok: true }
+  })
+
   // A Store copy is updated by the Store. electron-updater is not merely
   // unnecessary there, it is wrong: it would fetch the NSIS installer and try
   // to run it over a package Windows itself manages. So it is never wired up
-  // at all — no listeners, no startup check — and the handlers below answer
-  // honestly instead of pretending to check.
+  // at all, and nothing is ever downloaded or installed from here.
+  //
+  // What a Store copy does do is ask the Store's catalog which version it
+  // offers (storeVersion.ts) and say so when that is newer than this one: the
+  // Store updates when it chooses to, and "the Store keeps this up to date"
+  // told somebody three versions behind nothing at all.
   if (isMicrosoftStore()) {
-    const storeState = (): void => send('update:state', { state: 'store' })
-    ipcMain.handle('update:check', async () => {
-      storeState()
-      return { ok: false, reason: 'store' }
-    })
+    let last: Record<string, unknown> = { state: 'store', current: app.getVersion() }
+    const tell = (): void =>
+      send('update:state', { ...last, skipped: last.behind === true && loadPrefs().skipped === last.version })
+
+    const storeCheck = async (): Promise<{ ok: boolean; reason?: string }> => {
+      send('update:state', { state: 'checking' })
+      const current = app.getVersion()
+      let offered: string | null = null
+      try {
+        const r = await net.fetch(STORE_CATALOG, { signal: AbortSignal.timeout(15000) })
+        if (r.ok) offered = storeVersionOf(await r.json())
+      } catch {
+        // Offline, or the catalog answered differently: `offered` stays null
+        // and the screen says the check didn't work.
+      }
+      last = {
+        state: 'store',
+        current,
+        version: offered ?? undefined,
+        behind: offered !== null && isNewer(offered, current)
+      }
+      tell()
+      return { ok: offered !== null, reason: 'store' }
+    }
+
+    ipcMain.handle('update:check', storeCheck)
     ipcMain.handle('update:download', async () => ({ ok: false }))
     ipcMain.handle('update:install', () => ({ ok: false }))
-    ipcMain.handle('update:skip', () => ({ ok: false }))
+    // Hides the bar for that version; Settings still says it is there.
+    ipcMain.handle('update:skip', (_e, version: unknown) => {
+      if (typeof version !== 'string') return { ok: false }
+      savePrefs({ ...loadPrefs(), skipped: version })
+      tell()
+      return { ok: true }
+    })
     // Channel is still readable and writable so the screen renders, but it
     // decides nothing here.
     ipcMain.handle('update:prefs', () => loadPrefs())
-    storeState()
+    // One quiet check once the app is responsive, as the standalone copy does.
+    setTimeout(() => {
+      storeCheck().catch(() => undefined)
+    }, 8000)
     return
   }
 
 
@@ -61,6 +61,8 @@ contextBridge.exposeInMainWorld('studio', {
       ipcRenderer.invoke('update:skip', version),
     prefs: (patch?: { channel?: string }): Promise<{ channel: string; skipped?: string }> =>
       ipcRenderer.invoke('update:prefs', patch),
+    /** Clips Kitty's page in the Microsoft Store app (a Store copy's update button). */
+    openStore: (): Promise<{ ok: boolean }> => ipcRenderer.invoke('update:openStore'),
     /** Subscribe to update state. Returns an unsubscribe function. */
     onState: (fn: (s: Record<string, unknown>) => void): (() => void) => {
       const handler = (_e: unknown, s: Record<string, unknown>): void => fn(s)