diff --git a/src/app/service/service_worker/client.ts b/src/app/service/service_worker/client.ts
index b58a27912..d872a01f8 100644
--- a/src/app/service/service_worker/client.ts
+++ b/src/app/service/service_worker/client.ts
@@ -26,6 +26,7 @@ import { type ResourceBackup } from "@App/pkg/backup/struct";
 import { type ConfigBundle } from "@App/pkg/backup/config_bundle";
 import { type VSCodeConnectParam } from "../offscreen/vscode-connect";
 import { type ScriptInfo } from "@App/pkg/utils/scriptInstall";
+import { type SubscribeCheckUpdateResult } from "./subscribe";
 import type {
   AgentModelConfig,
   AgentTaskApiRequest,
@@ -483,7 +484,7 @@ export class SubscribeClient extends Client {
   }
 
   checkUpdate(url: string) {
-    return this.do("checkUpdate", { url });
+    return this.do<SubscribeCheckUpdateResult>("checkUpdate", { url });
   }
 
   enable(url: string, enable: boolean) {
diff --git a/src/app/service/service_worker/subscribe.test.ts b/src/app/service/service_worker/subscribe.test.ts
index c85301fc5..26e0d384d 100644
--- a/src/app/service/service_worker/subscribe.test.ts
+++ b/src/app/service/service_worker/subscribe.test.ts
@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { initTestEnv } from "@Tests/utils";
 import { SubscribeService } from "./subscribe";
 import type { ScriptService } from "./script";
@@ -6,9 +6,12 @@ import { ScriptDAO, SCRIPT_TYPE_NORMAL, SCRIPT_STATUS_ENABLE, SCRIPT_RUN_STATUS_
 import type { Script } from "@App/app/repo/scripts";
 import { SubscribeDAO, SubscribeStatusType } from "@App/app/repo/subscribe";
 import type { Subscribe } from "@App/app/repo/subscribe";
+import type { TInstallSubscribe } from "../queue";
 import { MessageQueue } from "@Packages/message/message_queue";
 import { MockMessage } from "@Packages/message/mock_message";
 import { Server } from "@Packages/message/server";
+import { SubscribeClient } from "./client";
+import { createMockOPFS } from "@App/app/repo/test-helpers";
 import EventEmitter from "eventemitter3";
 
 initTestEnv();
@@ -54,7 +57,7 @@ const buildService = () => {
     installByUrl: vi.fn(async () => makeScript()),
   } as unknown as ScriptService;
   const service = new SubscribeService(group, mq, scriptService);
-  return { service, scriptService };
+  return { service, scriptService, mq };
 };
 
 // 回收站按 deleteBy 提供「订阅」来源筛选；订阅链路删除脚本时若不标记来源，
@@ -85,3 +88,235 @@ describe("SubscribeService —— 删除脚本的来源标记", () => {
     expect(scriptService.deleteScript).toHaveBeenCalledWith("sub-script-1", "subscribe");
   });
 });
+
+// 订阅列表页只在挂载时拉取一次数据，列表要跟上后台变化，只能靠脚本同步完成后的广播
+describe("SubscribeService —— 订阅列表同步广播", () => {
+  beforeEach(async () => {
+    await chrome.storage.local.clear();
+  });
+
+  it("订阅脚本同步完成后应广播含最新脚本关联的订阅", async () => {
+    await new SubscribeDAO().save(makeSubscribe({ scripts: {} }));
+    const { service, mq } = buildService();
+    const published = new Promise<TInstallSubscribe>((resolve) => mq.subscribe("upsertSubscribe", resolve));
+
+    await service.upsertScript(SUB_URL);
+
+    const { subscribe } = await published;
+    expect(subscribe.url).toBe(SUB_URL);
+    expect(subscribe.scripts[SCRIPT_URL]).toEqual({ url: SCRIPT_URL, uuid: "sub-script-1" });
+  });
+
+  it("较旧的脚本同步完成较晚时保留较新的订阅", async () => {
+    await new SubscribeDAO().save(
+      makeSubscribe({
+        scripts: {},
+        metadata: { usersubscribe: [], scripturl: [SCRIPT_URL], version: ["0.3.4"] },
+      })
+    );
+    const { service, scriptService, mq } = buildService();
+    let finishScriptInstall!: (script: Script) => void;
+    const scriptInstallPending = new Promise<Script>((resolve) => {
+      finishScriptInstall = resolve;
+    });
+    vi.spyOn(scriptService, "installByUrl").mockImplementation(() => scriptInstallPending);
+    const save = vi.spyOn(service.subscribeDAO, "save");
+    const olderSync = service.upsertScript(SUB_URL);
+
+    await vi.waitFor(() => expect(scriptService.installByUrl).toHaveBeenCalledOnce());
+
+    const newerInstall = service.install({
+      subscribe: makeSubscribe({
+        scripts: {},
+        metadata: { usersubscribe: [], scripturl: [], version: ["0.3.5"] },
+      }),
+    });
+    const newerInstallComplete = newerInstall.then(() => undefined);
+    const savedWhileOlderSyncPending = save.mock.calls.length > 0;
+    if (savedWhileOlderSyncPending) await newerInstallComplete;
+
+    finishScriptInstall(makeScript());
+    await Promise.all([olderSync, newerInstall]);
+    const latestBroadcast = new Promise<TInstallSubscribe>((resolve) => mq.subscribe("upsertSubscribe", resolve));
+    await service.upsertScript(SUB_URL);
+
+    const saved = await new SubscribeDAO().get(SUB_URL);
+    expect(savedWhileOlderSyncPending).toBe(false);
+    expect(saved?.metadata.version).toEqual(["0.3.5"]);
+    expect(saved?.scripts).toEqual({});
+    await expect(latestBroadcast).resolves.toMatchObject({
+      subscribe: { metadata: { version: ["0.3.5"] }, scripts: {} },
+    });
+  });
+
+  it("脚本同步期间不启动同一订阅的更新检查", async () => {
+    await new SubscribeDAO().save(
+      makeSubscribe({
+        scripts: {},
+        metadata: { usersubscribe: [], scripturl: [SCRIPT_URL], version: ["0.3.4"] },
+      })
+    );
+    const { service, scriptService } = buildService();
+    let finishScriptInstall!: (script: Script) => void;
+    const scriptInstallPending = new Promise<Script>((resolve) => {
+      finishScriptInstall = resolve;
+    });
+    vi.spyOn(scriptService, "installByUrl").mockImplementation(() => scriptInstallPending);
+    const get = vi.spyOn(service.subscribeDAO, "get");
+    const syncing = service.upsertScript(SUB_URL);
+
+    await vi.waitFor(() => expect(scriptService.installByUrl).toHaveBeenCalledOnce());
+
+    const checkAvailable = vi.spyOn(service, "_checkUpdateAvailable").mockResolvedValue(false);
+    const checking = service.checkUpdate(SUB_URL, "user");
+    const checkStartedBeforeSyncFinished = get.mock.calls.length > 1;
+
+    finishScriptInstall(makeScript());
+    await Promise.all([syncing, checking]);
+
+    expect(checkStartedBeforeSyncFinished).toBe(false);
+    expect(checkAvailable).toHaveBeenCalledOnce();
+  });
+});
+
+const subscribeCode = (version: string, connect: string[] = []) =>
+  [
+    "// ==UserSubscribe==",
+    "// @name 测试订阅",
+    "// @namespace ns",
+    `// @version ${version}`,
+    ...connect.map((c) => `// @connect ${c}`),
+    "// ==/UserSubscribe==",
+    "",
+  ].join("\n");
+
+// options 页经 SubscribeClient 以 { url } 发送检查更新；SW 端若按字符串接收，
+// 会以 "[object Object]" 查订阅而查不到，手动检查永远显示「已是最新」且不发请求。
+describe("SubscribeService —— 手动检查更新", () => {
+  beforeEach(async () => {
+    await chrome.storage.local.clear();
+    // 需用户确认时更新代码暂存于 OPFS，再打开安装页
+    createMockOPFS();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const setup = async (remoteCode: string) => {
+    await new SubscribeDAO().save(makeSubscribe({ scripts: {}, metadata: { usersubscribe: [], version: ["0.3.3"] } }));
+    const fetchMock = vi
+      .spyOn(globalThis, "fetch")
+      .mockImplementation(async () => new Response(remoteCode, { status: 200 }));
+    const tabsCreate = vi.spyOn(chrome.tabs, "create");
+    // chrome.alarms 在 chrome-extension-mock 中没有实现，init() 会调用 clear
+    Object.assign(chrome, { alarms: { clear: vi.fn() } });
+    const mockMessage = new MockMessage(new EventEmitter<string, any>());
+    const server = new Server("serviceWorker", mockMessage);
+    const mq = new MessageQueue();
+    const service = new SubscribeService(server.group("subscribe"), mq, {} as ScriptService);
+    service.init();
+    return { client: new SubscribeClient(mockMessage), fetchMock, tabsCreate, mq, service };
+  };
+
+  it("远端版本更高且无需确认时应静默更新并返回 updated", async () => {
+    const { client, fetchMock, tabsCreate, mq } = await setup(subscribeCode("0.3.4"));
+    const synced = new Promise<TInstallSubscribe>((resolve) => mq.subscribe("upsertSubscribe", resolve));
+
+    const res = await client.checkUpdate(SUB_URL);
+
+    expect(fetchMock).toHaveBeenCalledWith(SUB_URL, expect.anything());
+    expect(res).toBe("updated");
+    expect((await synced).subscribe.metadata.version).toEqual(["0.3.4"]);
+    expect(tabsCreate).not.toHaveBeenCalled();
+  });
+
+  it("静默更新保存完成后才返回 updated", async () => {
+    const { client, service, mq } = await setup(subscribeCode("0.3.4"));
+    let finishSave!: (subscribe: Subscribe) => void;
+    const savePending = new Promise<Subscribe>((resolve) => {
+      finishSave = resolve;
+    });
+    const save = vi.spyOn(service.subscribeDAO, "save").mockReturnValue(savePending);
+    const installed = new Promise<TInstallSubscribe>((resolve) => mq.subscribe("installSubscribe", resolve));
+    let settled = false;
+    const result = client.checkUpdate(SUB_URL).then((value) => {
+      settled = true;
+      return value;
+    });
+
+    try {
+      await vi.waitFor(() => expect(save).toHaveBeenCalledOnce());
+      expect(settled).toBe(false);
+    } finally {
+      finishSave(makeSubscribe({ metadata: { usersubscribe: [], version: ["0.3.4"] } }));
+    }
+
+    await expect(result).resolves.toBe("updated");
+    await expect(installed).resolves.toMatchObject({ subscribe: { metadata: { version: ["0.3.4"] } } });
+  });
+
+  it("静默更新保存失败时返回 false", async () => {
+    const { client, service, tabsCreate } = await setup(subscribeCode("0.3.4"));
+    const failedInstall = Promise.reject(new Error("storage unavailable"));
+    void failedInstall.catch(() => {});
+    vi.spyOn(service.subscribeDAO, "save").mockReturnValue(failedInstall);
+
+    await expect(client.checkUpdate(SUB_URL)).resolves.toBe(false);
+    expect(tabsCreate).not.toHaveBeenCalled();
+  });
+
+  it("远端新增 @connect 域时应打开安装页并返回 confirm", async () => {
+    const { client, tabsCreate } = await setup(subscribeCode("0.3.4", ["new.example.com"]));
+
+    const res = await client.checkUpdate(SUB_URL);
+
+    expect(res).toBe("confirm");
+    expect(tabsCreate).toHaveBeenCalledWith({ url: expect.stringContaining("/src/install.html?uuid=") });
+  });
+
+  it("安装确认页创建完成后才返回 confirm", async () => {
+    const { client, tabsCreate } = await setup(subscribeCode("0.3.4", ["new.example.com"]));
+    let finishCreate!: (tab: chrome.tabs.Tab) => void;
+    const createPending = new Promise<chrome.tabs.Tab>((resolve) => {
+      finishCreate = resolve;
+    });
+    tabsCreate.mockImplementation(() => createPending);
+    let settled = false;
+    const result = client.checkUpdate(SUB_URL).then((value) => {
+      settled = true;
+      return value;
+    });
+
+    await vi.waitFor(() => expect(tabsCreate).toHaveBeenCalledOnce());
+    expect(settled).toBe(false);
+    finishCreate({} as chrome.tabs.Tab);
+
+    await expect(result).resolves.toBe("confirm");
+  });
+
+  it("安装确认页创建失败时不返回 confirm", async () => {
+    const { client, tabsCreate } = await setup(subscribeCode("0.3.4", ["new.example.com"]));
+    let failCreate!: (error: Error) => void;
+    const createPending = new Promise<chrome.tabs.Tab>((_, reject) => {
+      failCreate = reject;
+    });
+    void createPending.catch(() => {});
+    tabsCreate.mockImplementation(() => createPending);
+
+    const result = client.checkUpdate(SUB_URL);
+    await vi.waitFor(() => expect(tabsCreate).toHaveBeenCalledOnce());
+    failCreate(new Error("tab creation failed"));
+
+    await expect(result).resolves.toBe(false);
+  });
+
+  it("远端版本未升高时返回 false", async () => {
+    const { client, tabsCreate } = await setup(subscribeCode("0.3.3"));
+
+    const res = await client.checkUpdate(SUB_URL);
+
+    expect(res).toBe(false);
+    expect(tabsCreate).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/app/service/service_worker/subscribe.ts b/src/app/service/service_worker/subscribe.ts
index 12adf9ecf..5162eff3d 100644
--- a/src/app/service/service_worker/subscribe.ts
+++ b/src/app/service/service_worker/subscribe.ts
@@ -16,10 +16,15 @@ import i18n, { i18nName } from "@App/locales/locales";
 import { InfoNotification } from "./utils";
 import { TempStorageDAO, TempStorageItemType } from "@App/app/repo/tempStorage";
 
+// updated：已静默更新；confirm：@connect 新增了域，已打开安装页等待用户确认；false：无更新或检查失败
+export type SubscribeCheckUpdateResult = "updated" | "confirm" | false;
+
 export class SubscribeService {
   logger: Logger;
   subscribeDAO = new SubscribeDAO();
   scriptDAO = new ScriptDAO();
+  // Same-subscription sync writes full snapshots after async script work, so serialize all record mutations by URL.
+  private readonly subscribeOperations = new Map<string, Promise<void>>();
 
   constructor(
     private group: Group,
@@ -29,7 +34,25 @@ export class SubscribeService {
     this.logger = LoggerCore.logger().with({ service: "subscribe" });
   }
 
-  async install(param: { subscribe: Subscribe }) {
+  private withSubscribeOperation<T>(url: string, operation: () => Promise<T>): Promise<T> {
+    const previous = this.subscribeOperations.get(url) ?? Promise.resolve();
+    const result = previous.then(operation);
+    const current = result.then(
+      () => undefined,
+      () => undefined
+    );
+    this.subscribeOperations.set(url, current);
+    void current.then(() => {
+      if (this.subscribeOperations.get(url) === current) this.subscribeOperations.delete(url);
+    });
+    return result;
+  }
+
+  install(param: { subscribe: Subscribe }) {
+    return this.withSubscribeOperation(param.subscribe.url, () => this.installSubscribe(param));
+  }
+
+  private async installSubscribe(param: { subscribe: Subscribe }) {
     // 1）由安装页呼叫，进行 user.sub.js 的安装
     // 2）静默更新启动状态下，Subscribe 列表自动更新
     const logger = this.logger.with({
@@ -51,7 +74,11 @@ export class SubscribeService {
     }
   }
 
-  async delete(param: { url: string }) {
+  delete(param: { url: string }) {
+    return this.withSubscribeOperation(param.url, () => this.deleteSubscribe(param));
+  }
+
+  private async deleteSubscribe(param: { url: string }) {
     const url = param.url;
     const logger = this.logger.with({
       subscribeUrl: url,
@@ -88,7 +115,11 @@ export class SubscribeService {
 
   // 更新订阅的脚本（ installSubscribe ）
   // 已订阅的脚本则根据 Script脚本 本身的更新逻辑更新，与 Subscribe脚本 的更新无关
-  async upsertScript(url: string) {
+  upsertScript(url: string) {
+    return this.withSubscribeOperation(url, () => this.upsertSubscribeScripts(url));
+  }
+
+  private async upsertSubscribeScripts(url: string) {
     const subscribe = await this.subscribeDAO.get(url);
     if (!subscribe || !subscribe.metadata.usersubscribe) return; // 有效的 Subscribe 必定有 usersubscribe
     const logger = this.logger.with({
@@ -188,7 +219,11 @@ export class SubscribeService {
     await Promise.allSettled(promises);
 
     // 把 subscribe.scripts 的新资讯储存到 subscribeDAO
-    await this.subscribeDAO.update(subscribe.url, subscribe);
+    const saved = await this.subscribeDAO.update(subscribe.url, subscribe);
+    // 脚本关联到此才是最终结果，订阅列表页据此刷新；installSubscribe 早于脚本同步，不能用于刷新
+    if (saved) {
+      this.mq.publish<TInstallSubscribe>("upsertSubscribe", { subscribe: saved });
+    }
 
     InfoNotification(
       i18n.t("settings:notification.subscribe_update", { subscribeName: subscribe.name }),
@@ -247,7 +282,11 @@ export class SubscribeService {
    * @param source 系统自动检查: "system"; subscribeClient.checkUpdate(subscribe.url) 的时候: "user"
    * @returns
    */
-  async checkUpdate(url: string, source: InstallSource) {
+  checkUpdate(url: string, source: InstallSource): Promise<SubscribeCheckUpdateResult> {
+    return this.withSubscribeOperation(url, () => this.checkUpdateSubscribe(url, source));
+  }
+
+  private async checkUpdateSubscribe(url: string, source: InstallSource): Promise<SubscribeCheckUpdateResult> {
     const subscribe = await this.subscribeDAO.get(url);
     if (!subscribe) {
       return false;
@@ -266,7 +305,7 @@ export class SubscribeService {
       try {
         // 进行更新
         if (true === (await this.trySilenceUpdate(code, url))) {
-          // slience update
+          return "updated";
         } else {
           const si = await createTempCodeEntry(false, uuid, code, url, source, metadata, {});
           await new TempStorageDAO().save({
@@ -275,16 +314,17 @@ export class SubscribeService {
             savedAt: Date.now(),
             type: TempStorageItemType.tempCode,
           });
-          chrome.tabs.create({
+          await chrome.tabs.create({
             url: `/src/install.html?uuid=${uuid}`,
           });
         }
-        return true;
+        return "confirm";
       } catch (e) {
         logger.error("check update failed", { ...Logger.E(e), subscribe_url: url });
         return false;
       }
     }
+    return false;
   }
 
   // 订阅始终尝试静默更新，不受「非重要变更静默更新脚本」开关控制
@@ -293,17 +333,19 @@ export class SubscribeService {
     const logger = this.logger.with({
       url,
     });
+    let newSubscribe: Awaited<ReturnType<typeof prepareSubscribeByCode>>;
     try {
-      const newSubscribe = await prepareSubscribeByCode(code, url);
-      if (checkSilenceUpdate(newSubscribe.oldSubscribe!.metadata, newSubscribe.subscribe.metadata)) {
-        logger.info("silence update subscribe");
-        this.install({
-          subscribe: newSubscribe.subscribe,
-        });
-        return true;
-      }
+      newSubscribe = await prepareSubscribeByCode(code, url);
     } catch (e) {
       logger.error("prepare script failed", Logger.E(e));
+      return;
+    }
+    if (checkSilenceUpdate(newSubscribe.oldSubscribe!.metadata, newSubscribe.subscribe.metadata)) {
+      logger.info("silence update subscribe");
+      await this.installSubscribe({
+        subscribe: newSubscribe.subscribe,
+      });
+      return true;
     }
   }
 
@@ -321,7 +363,7 @@ export class SubscribeService {
     }
   }
 
-  requestCheckUpdate(url: string) {
+  requestCheckUpdate({ url }: { url: string }) {
     return this.checkUpdate(url, "user");
   }
 
@@ -330,7 +372,11 @@ export class SubscribeService {
     return this.subscribeDAO.find();
   }
 
-  async enable(param: { url: string; enable: boolean }) {
+  enable(param: { url: string; enable: boolean }) {
+    return this.withSubscribeOperation(param.url, () => this.enableSubscribe(param));
+  }
+
+  private async enableSubscribe(param: { url: string; enable: boolean }) {
     const logger = this.logger.with({
       url: param.url,
     });
diff --git a/src/pages/options/routes/SubscribeList/components.test.tsx b/src/pages/options/routes/SubscribeList/components.test.tsx
index 0cbf390a1..98931bad8 100644
--- a/src/pages/options/routes/SubscribeList/components.test.tsx
+++ b/src/pages/options/routes/SubscribeList/components.test.tsx
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeAll, afterEach } from "vitest";
-import { render, screen, cleanup, waitFor } from "@testing-library/react";
+import { act, render, screen, cleanup, waitFor, fireEvent } from "@testing-library/react";
 
 const { get } = vi.hoisted(() => ({ get: vi.fn() }));
 vi.mock("@App/pages/store/global", async () => {
@@ -13,7 +13,9 @@ vi.mock("@App/pages/store/features/subscribe", () => ({
 
 import { initTestLanguage } from "@Tests/initTestLanguage";
 import { TooltipProvider } from "@App/pages/components/ui/tooltip";
-import { PermissionFavicons } from "./components";
+import { t } from "@App/locales/locales";
+import { requestCheckSubscribeUpdate } from "@App/pages/store/features/subscribe";
+import { PermissionFavicons, SubscribeUpdateTimeCell } from "./components";
 
 beforeAll(() => {
   initTestLanguage("zh-CN");
@@ -49,3 +51,71 @@ describe("订阅 @connect 域名图标", () => {
     expect(container.querySelector("img")).toBeNull();
   });
 });
+
+describe("订阅更新时间格的检查更新状态", () => {
+  const URL = "https://example.com/list.user.sub.js";
+  const renderCell = (updatetime: number) => (
+    <TooltipProvider>
+      <SubscribeUpdateTimeCell url={URL} updatetime={updatetime} />
+    </TooltipProvider>
+  );
+  const clickCheck = () =>
+    act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: t("check_update") }));
+    });
+
+  it("已静默更新时不提示「存在新版本」", async () => {
+    vi.mocked(requestCheckSubscribeUpdate).mockResolvedValueOnce("updated");
+    render(renderCell(1000));
+
+    await clickCheck();
+
+    expect(requestCheckSubscribeUpdate).toHaveBeenCalledWith(URL);
+    expect(screen.queryByText(t("script:new_version_available"))).toBeNull();
+    expect(screen.queryByText(t("script:latest_version"))).toBeNull();
+  });
+
+  it("打开安装页待确认时提示「存在新版本」，订阅更新后恢复为更新时间", async () => {
+    vi.mocked(requestCheckSubscribeUpdate).mockResolvedValueOnce("confirm");
+    const { rerender } = render(renderCell(1000));
+
+    await clickCheck();
+    expect(screen.getByText(t("script:new_version_available"))).toBeInTheDocument();
+
+    rerender(renderCell(2000));
+
+    expect(screen.queryByText(t("script:new_version_available"))).toBeNull();
+  });
+
+  it("检查期间订阅更新时间变化后忽略过期的确认结果", async () => {
+    let resolveCheck!: (result: "confirm") => void;
+    const pendingCheck = new Promise<"confirm">((resolve) => {
+      resolveCheck = resolve;
+    });
+    vi.mocked(requestCheckSubscribeUpdate).mockReturnValueOnce(pendingCheck);
+    const { rerender } = render(renderCell(1000));
+
+    await clickCheck();
+    rerender(renderCell(2000));
+
+    await act(async () => {
+      resolveCheck("confirm");
+      await pendingCheck;
+    });
+
+    expect(screen.queryByText(t("script:new_version_available"))).toBeNull();
+  });
+
+  it("订阅更新时间变化后重置已是最新状态", async () => {
+    vi.mocked(requestCheckSubscribeUpdate).mockResolvedValueOnce(false);
+    const { rerender } = render(renderCell(1000));
+
+    await clickCheck();
+    expect(screen.getByText(t("script:latest_version"))).toBeInTheDocument();
+
+    rerender(renderCell(2000));
+
+    expect(screen.queryByText(t("script:latest_version"))).toBeNull();
+    expect(screen.getByRole("button", { name: t("check_update") })).toBeInTheDocument();
+  });
+});
diff --git a/src/pages/options/routes/SubscribeList/components.tsx b/src/pages/options/routes/SubscribeList/components.tsx
index a6f444825..0909717ee 100644
--- a/src/pages/options/routes/SubscribeList/components.tsx
+++ b/src/pages/options/routes/SubscribeList/components.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useState } from "react";
+import React, { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { SubscribeStatusType } from "@App/app/repo/subscribe";
 import { requestCheckSubscribeUpdate } from "@App/pages/store/features/subscribe";
 import { Switch } from "@App/pages/components/ui/switch";
@@ -104,42 +104,73 @@ export const SubscribeSourceTag = React.memo(({ url }: { url: string }) => {
 SubscribeSourceTag.displayName = "SubscribeSourceTag";
 
 // ========== UpdateTimeCell ==========
-// 「最后更新」就近放置检查更新入口：idle → checking → latest（2s 恢复）/ has-update
+// 「最后更新」就近放置检查更新入口：idle → checking → latest（2s 恢复）/ has-update / idle（已静默更新）
 type CheckUpdateState = "idle" | "checking" | "latest" | "has-update";
 
 export const SubscribeUpdateTimeCell = React.memo(({ url, updatetime }: { url: string; updatetime?: number }) => {
   const { t } = useTranslation();
-  const [state, setState] = useState<CheckUpdateState>("idle");
+  const [checkState, setCheckState] = useState({ status: "idle" as CheckUpdateState, generation: 0 });
+  const requestGeneration = useRef(0);
+
+  // 更新结果属于检查时的订阅版本，URL 或更新时间变化后不能再应用旧结果
+  const [prevIdentity, setPrevIdentity] = useState({ url, updatetime });
+  if (url !== prevIdentity.url || updatetime !== prevIdentity.updatetime) {
+    setPrevIdentity({ url, updatetime });
+    setCheckState((current) => ({
+      status: "idle",
+      generation: current.generation + 1,
+    }));
+  }
+
+  useLayoutEffect(() => {
+    requestGeneration.current = checkState.generation;
+    return () => {
+      if (requestGeneration.current === checkState.generation) requestGeneration.current++;
+    };
+  }, [checkState.generation]);
 
   const handleCheck = useCallback(() => {
-    if (state === "checking") return;
-    setState("checking");
+    if (checkState.status === "checking") return;
+    const generation = checkState.generation + 1;
+    requestGeneration.current = generation;
+    setCheckState({ status: "checking", generation });
     requestCheckSubscribeUpdate(url)
-      // res 为 true 时表示发现新版本并已打开更新页；false/undefined 表示已是最新
-      .then((res) => setState(res ? "has-update" : "latest"))
+      // updated：已静默更新，新的更新时间随广播到达；confirm：已打开安装页待确认
+      .then((res) => {
+        if (requestGeneration.current !== generation) return;
+        setCheckState((current) =>
+          current.generation === generation
+            ? { status: res === "updated" ? "idle" : res === "confirm" ? "has-update" : "latest", generation }
+            : current
+        );
+      })
       .catch((e) => {
-        setState("idle");
+        if (requestGeneration.current !== generation) return;
+        setCheckState((current) => (current.generation === generation ? { status: "idle", generation } : current));
         notify.error(`${t("script:update_check_failed")}: ${e}`);
       });
-  }, [state, url, t]);
+  }, [checkState, url, t]);
 
   // 「已是最新」短暂提示后恢复默认
   useEffect(() => {
-    if (state !== "latest") return;
-    const id = setTimeout(() => setState("idle"), 2000);
+    if (checkState.status !== "latest") return;
+    const generation = checkState.generation;
+    const id = setTimeout(() => {
+      setCheckState((current) => (current.generation === generation ? { status: "idle", generation } : current));
+    }, 2000);
     return () => clearTimeout(id);
-  }, [state]);
+  }, [checkState.status, checkState.generation]);
 
   const time = updatetime ? semTime(new Date(updatetime)) : "-";
 
   return (
     <div className="flex items-center justify-center gap-1">
-      {state === "latest" ? (
+      {checkState.status === "latest" ? (
         <span className="inline-flex items-center gap-1 text-xs text-success">
           <Check className="w-3 h-3" />
           {t("script:latest_version")}
         </span>
-      ) : state === "has-update" ? (
+      ) : checkState.status === "has-update" ? (
         /* 检查到新版本：直接取代时间展示「存在新版本」入口，点击可再次触发更新 */
         <Tooltip>
           <TooltipTrigger asChild>
@@ -166,7 +197,7 @@ export const SubscribeUpdateTimeCell = React.memo(({ url, updatetime }: { url: s
                 onClick={handleCheck}
                 className="text-muted-foreground opacity-60 transition-opacity hover:text-foreground hover:opacity-100"
               >
-                <RefreshCw className={cn("w-3 h-3", state === "checking" && "animate-spin")} />
+                <RefreshCw className={cn("w-3 h-3", checkState.status === "checking" && "animate-spin")} />
               </button>
             </TooltipTrigger>
             <TooltipContent>{t("check_update")}</TooltipContent>
diff --git a/src/pages/options/routes/SubscribeList/hooks.test.ts b/src/pages/options/routes/SubscribeList/hooks.test.ts
new file mode 100644
index 000000000..38b565b78
--- /dev/null
+++ b/src/pages/options/routes/SubscribeList/hooks.test.ts
@@ -0,0 +1,225 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import type { Subscribe } from "@App/app/repo/subscribe";
+import { SubscribeStatusType } from "@App/app/repo/subscribe";
+import type { TInstallSubscribe } from "@App/app/service/queue";
+
+const { messageHandlers, fetchSubscribeList } = vi.hoisted(() => ({
+  messageHandlers: new Map<string, (data: object) => void>(),
+  fetchSubscribeList: vi.fn(),
+}));
+
+vi.mock("@App/pages/store/global", async () => {
+  const { createGlobalStoreMock } = await import("@Tests/mocks/pageStores.ts");
+  return {
+    ...createGlobalStoreMock(),
+    subscribeMessage: vi.fn((topic: string, handler: (data: object) => void) => {
+      messageHandlers.set(topic, handler);
+      return () => messageHandlers.delete(topic);
+    }),
+  };
+});
+
+vi.mock("@App/pages/store/features/subscribe", () => ({ fetchSubscribeList }));
+
+import { useSubscribeDataManagement } from "./hooks";
+
+const mk = (url: string, overrides: Partial<Subscribe> = {}): Subscribe => ({
+  url,
+  name: url,
+  code: "",
+  author: "",
+  scripts: {},
+  metadata: { usersubscribe: [], version: ["0.1.0"] },
+  status: SubscribeStatusType.enable,
+  createtime: 1,
+  updatetime: 1,
+  checktime: 1,
+  ...overrides,
+});
+
+const A = "https://example.com/a.user.sub.js";
+const B = "https://example.com/b.user.sub.js";
+const C = "https://example.com/c.user.sub.js";
+
+const publish = (subscribe: Subscribe) =>
+  act(() => messageHandlers.get("upsertSubscribe")?.({ subscribe } satisfies TInstallSubscribe));
+
+beforeEach(() => {
+  messageHandlers.clear();
+  fetchSubscribeList.mockResolvedValue([mk(A)]);
+});
+
+// 列表只在挂载时拉取一次；后台静默更新或在安装页装好订阅后，列表要跟随广播刷新
+describe("订阅列表数据随后台广播同步", () => {
+  it("已有订阅更新后就地替换该行", async () => {
+    const { result } = renderHook(() => useSubscribeDataManagement());
+    await waitFor(() => expect(result.current.loadingList).toBe(false));
+
+    publish(
+      mk(A, {
+        metadata: { usersubscribe: [], version: ["0.2.0"] },
+        scripts: { "https://example.com/x.user.js": { url: "https://example.com/x.user.js", uuid: "x" } },
+        updatetime: 2,
+      })
+    );
+
+    expect(result.current.subscribeList).toHaveLength(1);
+    expect(result.current.subscribeList[0].metadata.version).toEqual(["0.2.0"]);
+    expect(Object.keys(result.current.subscribeList[0].scripts)).toEqual(["https://example.com/x.user.js"]);
+  });
+
+  it("新安装的订阅按创建时间追加", async () => {
+    const { result } = renderHook(() => useSubscribeDataManagement());
+    await waitFor(() => expect(result.current.loadingList).toBe(false));
+
+    publish(mk(B, { createtime: 2 }));
+
+    expect(result.current.subscribeList.map((s) => s.url)).toEqual([A, B]);
+  });
+
+  it("初始列表读取期间的后台广播不会被过期快照覆盖", async () => {
+    let resolveList!: (list: Subscribe[]) => void;
+    const pendingList = new Promise<Subscribe[]>((resolve) => {
+      resolveList = resolve;
+    });
+    fetchSubscribeList.mockReturnValueOnce(pendingList);
+    const { result } = renderHook(() => useSubscribeDataManagement());
+
+    publish(
+      mk(A, {
+        metadata: { usersubscribe: [], version: ["0.2.0"] },
+        scripts: { "https://example.com/x.user.js": { url: "https://example.com/x.user.js", uuid: "x" } },
+        updatetime: 2,
+        checktime: 2,
+        createtime: 99,
+      })
+    );
+    publish(mk(B, { createtime: 2 }));
+
+    await act(async () => {
+      resolveList([
+        Object.assign(
+          mk(A, {
+            metadata: { usersubscribe: [], version: ["0.1.0"] },
+            status: SubscribeStatusType.disable,
+            updatetime: 1,
+            checktime: 4,
+            createtime: 7,
+          }),
+          { actionLoading: true }
+        ),
+        mk(C, { createtime: 3 }),
+      ]);
+      await pendingList;
+    });
+
+    expect(result.current.subscribeList.map((subscribe) => subscribe.url)).toEqual([B, C, A]);
+    expect(result.current.subscribeList.find((subscribe) => subscribe.url === A)).toMatchObject({
+      metadata: { version: ["0.2.0"] },
+      status: SubscribeStatusType.disable,
+      checktime: 4,
+      createtime: 7,
+      actionLoading: true,
+    });
+    expect(result.current.loadingList).toBe(false);
+  });
+
+  it("初始读取期间按订阅更新时间保留最新广播", async () => {
+    let resolveList!: (list: Subscribe[]) => void;
+    const pendingList = new Promise<Subscribe[]>((resolve) => {
+      resolveList = resolve;
+    });
+    fetchSubscribeList.mockReturnValueOnce(pendingList);
+    const { result } = renderHook(() => useSubscribeDataManagement());
+
+    publish(
+      mk(A, {
+        metadata: { usersubscribe: [], version: ["0.3.0"] },
+        updatetime: 20,
+        createtime: 99,
+      })
+    );
+    publish(
+      mk(A, {
+        metadata: { usersubscribe: [], version: ["0.2.0"] },
+        updatetime: 10,
+        createtime: 99,
+      })
+    );
+
+    await act(async () => {
+      resolveList([
+        Object.assign(
+          mk(A, {
+            status: SubscribeStatusType.disable,
+            updatetime: 5,
+            checktime: 4,
+            createtime: 7,
+          }),
+          { actionLoading: true }
+        ),
+      ]);
+      await pendingList;
+    });
+
+    expect(result.current.subscribeList[0]).toMatchObject({
+      metadata: { version: ["0.3.0"] },
+      updatetime: 20,
+      status: SubscribeStatusType.disable,
+      checktime: 4,
+      createtime: 7,
+      actionLoading: true,
+    });
+  });
+
+  it("列表加载后忽略较旧广播且保留当前操作状态", async () => {
+    const { result } = renderHook(() => useSubscribeDataManagement());
+    await waitFor(() => expect(result.current.loadingList).toBe(false));
+    act(() => {
+      result.current.setSubscribeList((list) =>
+        list.map((subscribe) => ({
+          ...subscribe,
+          status: SubscribeStatusType.disable,
+          checktime: 4,
+          actionLoading: true,
+        }))
+      );
+    });
+
+    publish(
+      mk(A, {
+        metadata: { usersubscribe: [], version: ["0.3.0"] },
+        updatetime: 20,
+        createtime: 99,
+        checktime: 8,
+      })
+    );
+    publish(
+      mk(A, {
+        metadata: { usersubscribe: [], version: ["0.2.0"] },
+        updatetime: 10,
+        createtime: 99,
+        checktime: 8,
+      })
+    );
+
+    expect(result.current.subscribeList[0]).toMatchObject({
+      metadata: { version: ["0.3.0"] },
+      updatetime: 20,
+      status: SubscribeStatusType.disable,
+      checktime: 4,
+      createtime: 1,
+      actionLoading: true,
+    });
+  });
+
+  it("卸载后取消订阅广播", async () => {
+    const { result, unmount } = renderHook(() => useSubscribeDataManagement());
+    await waitFor(() => expect(result.current.loadingList).toBe(false));
+
+    unmount();
+
+    expect(messageHandlers.has("upsertSubscribe")).toBe(false);
+  });
+});
diff --git a/src/pages/options/routes/SubscribeList/hooks.ts b/src/pages/options/routes/SubscribeList/hooks.ts
index cb4707fa5..a876c68eb 100644
--- a/src/pages/options/routes/SubscribeList/hooks.ts
+++ b/src/pages/options/routes/SubscribeList/hooks.ts
@@ -1,9 +1,58 @@
 import { useEffect, useState } from "react";
 import { fetchSubscribeList, type SubscribeLoading } from "@App/pages/store/features/subscribe";
+import { subscribeMessage } from "@App/pages/store/global";
+import type { TInstallSubscribe } from "@App/app/service/queue";
+
+const sortByCreatetime = (list: SubscribeLoading[]) => [...list].sort((a, b) => a.createtime - b.createtime);
+
+const isOlderSubscribeUpdate = (current: TInstallSubscribe["subscribe"], incoming: TInstallSubscribe["subscribe"]) =>
+  current.updatetime !== undefined && (incoming.updatetime === undefined || incoming.updatetime < current.updatetime);
+
+const upsertSubscribe = (list: SubscribeLoading[], subscribe: TInstallSubscribe["subscribe"]) => {
+  const idx = list.findIndex((item) => item.url === subscribe.url);
+  if (idx === -1) return sortByCreatetime([...list, subscribe]);
+
+  const current = list[idx];
+  if (isOlderSubscribeUpdate(current, subscribe)) return list;
+
+  const newList = [...list];
+  newList[idx] = {
+    ...current,
+    ...subscribe,
+    createtime: current.createtime,
+    status: current.status,
+    checktime: current.checktime,
+  };
+  return newList;
+};
+
+const mergePendingBroadcasts = (list: SubscribeLoading[], broadcasts: Iterable<TInstallSubscribe["subscribe"]>) => {
+  const byUrl = new Map(list.map((subscribe) => [subscribe.url, subscribe] as const));
+  for (const subscribe of broadcasts) {
+    const current = byUrl.get(subscribe.url);
+    if (!current) {
+      byUrl.set(subscribe.url, subscribe);
+      continue;
+    }
+
+    // 快照中的操作状态可能比广播更新，广播只负责订阅内容和脚本关联。
+    if (isOlderSubscribeUpdate(current, subscribe)) continue;
+    byUrl.set(subscribe.url, {
+      ...current,
+      name: subscribe.name,
+      code: subscribe.code,
+      author: subscribe.author,
+      scripts: subscribe.scripts,
+      metadata: subscribe.metadata,
+      updatetime: subscribe.updatetime,
+    });
+  }
+  return sortByCreatetime([...byUrl.values()]);
+};
 
 /**
- * 管理订阅数据的核心逻辑：挂载时拉取一次列表。
- * 订阅的启用/删除在页面侧做乐观更新（与 v1.4 一致，订阅服务端未广播列表变更）。
+ * 管理订阅数据的核心逻辑：挂载时拉取一次列表，之后随后台 upsertSubscribe 广播同步新增/更新的订阅。
+ * 订阅的启用/删除在页面侧做乐观更新（与 v1.4 一致，服务端不广播这两类变更）。
  */
 export function useSubscribeDataManagement() {
   const [subscribeList, setSubscribeList] = useState<SubscribeLoading[]>([]);
@@ -11,15 +60,32 @@ export function useSubscribeDataManagement() {
 
   useEffect(() => {
     let mounted = true;
-    // loadingList 初始即为 true（见上方 useState），effect 仅挂载时执行一次，无需再同步置 true
-    void fetchSubscribeList().then((list) => {
-      if (!mounted) return;
-      // 按创建时间升序，保证「#」序号稳定
-      setSubscribeList([...list].sort((a, b) => a.createtime - b.createtime));
-      setLoadingList(false);
+    let initialFetchPending = true;
+    const pendingBroadcasts = new Map<string, TInstallSubscribe["subscribe"]>();
+    const unsubscribe = subscribeMessage<TInstallSubscribe>("upsertSubscribe", ({ subscribe }) => {
+      if (initialFetchPending) {
+        const pending = pendingBroadcasts.get(subscribe.url);
+        if (!pending || !isOlderSubscribeUpdate(pending, subscribe)) pendingBroadcasts.set(subscribe.url, subscribe);
+      }
+      setSubscribeList((list) => upsertSubscribe(list, subscribe));
     });
+
+    void fetchSubscribeList()
+      .then((list) => {
+        if (!mounted) return;
+        setSubscribeList(mergePendingBroadcasts(sortByCreatetime(list), pendingBroadcasts.values()));
+        setLoadingList(false);
+      })
+      .finally(() => {
+        initialFetchPending = false;
+        pendingBroadcasts.clear();
+      });
+
     return () => {
       mounted = false;
+      initialFetchPending = false;
+      pendingBroadcasts.clear();
+      unsubscribe();
     };
   }, []);