diff --git a/src/RemoteContentAssets/Presentation/Controller/RemoteAssetsController.php b/src/RemoteContentAssets/Presentation/Controller/RemoteAssetsController.php
index 296dc237..fb66551a 100644
--- a/src/RemoteContentAssets/Presentation/Controller/RemoteAssetsController.php
+++ b/src/RemoteContentAssets/Presentation/Controller/RemoteAssetsController.php
@@ -68,7 +68,10 @@ public function list(string $projectId): JsonResponse
             $project->remoteContentAssetsManifestUrls
         );
 
-        return $this->json(['urls' => $urls]);
+        return $this->json([
+            'urls'     => $urls,
+            'revision' => $this->buildUrlsRevision($urls),
+        ]);
     }
 
     /**
@@ -164,4 +167,14 @@ public function upload(string $projectId, Request $request): JsonResponse
             return $this->json(['error' => 'Upload failed: ' . $e->getMessage()], Response::HTTP_INTERNAL_SERVER_ERROR);
         }
     }
+
+    /**
+     * @param list<string> $urls
+     */
+    private function buildUrlsRevision(array $urls): string
+    {
+        sort($urls, SORT_STRING);
+
+        return hash('sha256', implode("\n", $urls));
+    }
 }
diff --git a/src/RemoteContentAssets/Presentation/Resources/assets/controllers/remote_asset_browser_controller.ts b/src/RemoteContentAssets/Presentation/Resources/assets/controllers/remote_asset_browser_controller.ts
index 7c2488e2..74813269 100644
--- a/src/RemoteContentAssets/Presentation/Resources/assets/controllers/remote_asset_browser_controller.ts
+++ b/src/RemoteContentAssets/Presentation/Resources/assets/controllers/remote_asset_browser_controller.ts
@@ -13,11 +13,22 @@ import { Controller } from "@hotwired/stimulus";
  * - Clickable dropzone to open file dialog (supports multiple files)
  */
 export default class extends Controller {
+    static readonly MANIFEST_WAIT_POLL_INTERVAL_MS: number = 2000;
+    static readonly MANIFEST_WAIT_MAX_ATTEMPTS: number = 30;
+    static BACKGROUND_SYNC_INTERVAL_MS: number = 300000;
+
     static values = {
         fetchUrl: String,
         windowSize: { type: Number, default: 20 },
         addToChatLabel: { type: String, default: "Add to chat" },
         openInNewTabLabel: { type: String, default: "Open in new tab" },
+        uploadProcessingLabel: { type: String, default: "New images are being processed..." },
+        refreshPromptLabel: { type: String, default: "New images are available. Refresh the asset list now?" },
+        uploadProcessingDelayedErrorLabel: {
+            type: String,
+            default: "Upload completed. New images are still processing. Please try again shortly.",
+        },
+        uploadPartialFailureLabel: { type: String, default: "%errorCount% of %total% uploads failed." },
         // Upload configuration (optional - if not set, upload is disabled)
         uploadUrl: { type: String, default: "" },
         uploadCsrfToken: { type: String, default: "" },
@@ -34,6 +45,9 @@ export default class extends Controller {
         "fileInput",
         "uploadProgress",
         "uploadProgressText",
+        "uploadProcessing",
+        "uploadProcessingMessage",
+        "uploadRefreshActions",
         "uploadError",
         "uploadSuccess",
     ];
@@ -42,6 +56,10 @@ export default class extends Controller {
     declare readonly windowSizeValue: number;
     declare readonly addToChatLabelValue: string;
     declare readonly openInNewTabLabelValue: string;
+    declare readonly uploadProcessingLabelValue: string;
+    declare readonly refreshPromptLabelValue: string;
+    declare readonly uploadProcessingDelayedErrorLabelValue: string;
+    declare readonly uploadPartialFailureLabelValue: string;
     declare readonly uploadUrlValue: string;
     declare readonly uploadCsrfTokenValue: string;
     declare readonly workspaceIdValue: string;
@@ -64,6 +82,12 @@ export default class extends Controller {
     declare readonly uploadProgressTarget: HTMLElement;
     declare readonly hasUploadProgressTextTarget: boolean;
     declare readonly uploadProgressTextTarget: HTMLElement;
+    declare readonly hasUploadProcessingTarget: boolean;
+    declare readonly uploadProcessingTarget: HTMLElement;
+    declare readonly hasUploadProcessingMessageTarget: boolean;
+    declare readonly uploadProcessingMessageTarget: HTMLElement;
+    declare readonly hasUploadRefreshActionsTarget: boolean;
+    declare readonly uploadRefreshActionsTarget: HTMLElement;
     declare readonly hasUploadErrorTarget: boolean;
     declare readonly uploadErrorTarget: HTMLElement;
     declare readonly hasUploadSuccessTarget: boolean;
@@ -74,10 +98,40 @@ export default class extends Controller {
     private itemHeight: number = 80;
     private isLoading: boolean = false;
     private isUploading: boolean = false;
+    private isConnected: boolean = false;
+    private hasPendingRefresh: boolean = false;
+    private uploadProcessingMode: "processing" | "refreshPrompt" = "processing";
+    private backgroundSyncTimeoutId: ReturnType<typeof setTimeout> | null = null;
+    private latestManifestRevision: string | null = null;
+    private isBackgroundSyncEnabled: boolean = false;
+    private readonly focusHandler = (): void => {
+        void this.checkForManifestUpdates();
+    };
+    private readonly visibilityChangeHandler = (): void => {
+        if (document.visibilityState === "visible") {
+            void this.checkForManifestUpdates();
+        }
+    };
 
     connect(): void {
-        this.fetchAssets();
+        this.isConnected = true;
+        void this.fetchAssets();
         this.setupDropzone();
+        this.isBackgroundSyncEnabled = this.getBackgroundSyncIntervalMs() > 0;
+        if (this.isBackgroundSyncEnabled) {
+            this.startBackgroundSync();
+            window.addEventListener("focus", this.focusHandler);
+            document.addEventListener("visibilitychange", this.visibilityChangeHandler);
+        }
+    }
+
+    disconnect(): void {
+        this.isConnected = false;
+        this.stopBackgroundSync();
+        if (this.isBackgroundSyncEnabled) {
+            window.removeEventListener("focus", this.focusHandler);
+            document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
+        }
     }
 
     /**
@@ -184,15 +238,17 @@ export default class extends Controller {
         const total = files.length;
         let successCount = 0;
         let errorCount = 0;
+        const uploadedUrls: string[] = [];
 
         for (let i = 0; i < total; i++) {
             this.updateUploadProgressText(i + 1, total);
             this.showUploadStatus("progress");
 
             try {
-                const uploaded = await this.uploadSingleFile(files[i]);
-                if (uploaded) {
+                const uploadedUrl = await this.uploadSingleFile(files[i]);
+                if (uploadedUrl !== null) {
                     successCount++;
+                    uploadedUrls.push(uploadedUrl);
                 } else {
                     errorCount++;
                 }
@@ -201,28 +257,31 @@ export default class extends Controller {
             }
         }
 
-        // Re-fetch the asset list once after all uploads
+        // Wait until uploaded URLs become available via manifest-backed list.
         if (successCount > 0) {
-            await this.fetchAssets();
+            this.showUploadStatus("processing");
+            const waitSucceeded = await this.waitForManifestAvailability(uploadedUrls);
+            if (waitSucceeded) {
+                this.markRefreshAvailable();
+            } else {
+                this.showUploadError(this.uploadProcessingDelayedErrorLabelValue);
+            }
         }
 
-        // Show final status
         if (errorCount > 0 && successCount === 0) {
-            this.showUploadError("Upload failed. Please try again.");
+            this.showUploadError(this.getUploadErrorFallbackLabel());
         } else if (errorCount > 0) {
-            this.showUploadError(`${errorCount} of ${total} uploads failed.`);
-        } else {
-            this.showUploadStatus("success");
-            setTimeout(() => this.showUploadStatus("none"), 3000);
+            this.showUploadError(this.formatUploadPartialFailureLabel(errorCount, total));
         }
 
         this.isUploading = false;
+        this.showRefreshPromptIfPending();
     }
 
     /**
      * Upload a single file to S3. Returns true on success.
      */
-    private async uploadSingleFile(file: File): Promise<boolean> {
+    private async uploadSingleFile(file: File): Promise<string | null> {
         const formData = new FormData();
         formData.append("file", file);
         formData.append("workspace_id", this.workspaceIdValue);
@@ -241,10 +300,10 @@ export default class extends Controller {
         if (data.success && data.url) {
             this.dispatch("uploadComplete", { detail: { url: data.url } });
 
-            return true;
+            return data.url;
         }
 
-        return false;
+        return null;
     }
 
     /**
@@ -265,10 +324,14 @@ export default class extends Controller {
     /**
      * Show upload status indicator.
      */
-    private showUploadStatus(which: "progress" | "success" | "error" | "none"): void {
+    private showUploadStatus(which: "progress" | "processing" | "success" | "error" | "none"): void {
         if (this.hasUploadProgressTarget) {
             this.uploadProgressTarget.classList.toggle("hidden", which !== "progress");
         }
+        if (this.hasUploadProcessingTarget) {
+            this.uploadProcessingTarget.classList.toggle("hidden", which !== "processing");
+        }
+        this.renderUploadProcessingState();
         if (this.hasUploadSuccessTarget) {
             this.uploadSuccessTarget.classList.toggle("hidden", which !== "success");
         }
@@ -289,14 +352,34 @@ export default class extends Controller {
         }
         this.showUploadStatus("error");
         // Auto-hide error message after 5 seconds
-        setTimeout(() => this.showUploadStatus("none"), 5000);
+        setTimeout(() => {
+            this.showUploadStatus("none");
+            this.showRefreshPromptIfPending();
+        }, 5000);
     }
 
-    private async fetchAssets(): Promise<void> {
-        if (this.isLoading || !this.fetchUrlValue) {
+    confirmRefresh(): void {
+        if (!this.hasPendingRefresh) {
             return;
         }
 
+        this.hasPendingRefresh = false;
+        this.uploadProcessingMode = "processing";
+        this.showUploadStatus("none");
+        void this.reloadAssetsAfterConfirmation();
+    }
+
+    dismissRefresh(): void {
+        this.hasPendingRefresh = false;
+        this.uploadProcessingMode = "processing";
+        this.showUploadStatus("none");
+    }
+
+    private async fetchAssets(): Promise<{ urls: string[]; revision: string } | null> {
+        if (this.isLoading || !this.fetchUrlValue) {
+            return null;
+        }
+
         this.isLoading = true;
         this.showLoading(true);
 
@@ -309,8 +392,10 @@ export default class extends Controller {
                 throw new Error(`HTTP ${response.status}`);
             }
 
-            const data = (await response.json()) as { urls?: string[] };
-            this.urls = data.urls ?? [];
+            const data = (await response.json()) as { urls?: string[]; revision?: string };
+            const manifestData = this.normalizeManifestData(data);
+            this.urls = manifestData.urls;
+            this.latestManifestRevision = manifestData.revision;
 
             this.showLoading(false);
 
@@ -323,14 +408,210 @@ export default class extends Controller {
                 this.filter();
                 this.showEmpty(this.filteredUrls.length === 0);
             }
+            return manifestData;
         } catch {
             this.showLoading(false);
             this.showEmpty(true);
+            return null;
         } finally {
             this.isLoading = false;
         }
     }
 
+    private async waitForManifestAvailability(uploadedUrls: string[]): Promise<boolean> {
+        const pendingUrls = new Set(uploadedUrls);
+        const pendingFileNames = new Set(
+            uploadedUrls.map((url) => this.extractFilename(url)).filter((fileName) => fileName !== ""),
+        );
+        if (pendingUrls.size === 0) {
+            return true;
+        }
+
+        const pollIntervalMs = this.getManifestWaitPollIntervalMs();
+        const maxAttempts = this.getManifestWaitMaxAttempts();
+
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const manifestData = await this.fetchManifestUrlsSilently();
+            if (manifestData !== null) {
+                const manifestUrlSet = new Set(manifestData.urls);
+                const manifestFileNameSet = new Set(
+                    manifestData.urls.map((url) => this.extractFilename(url)).filter((fileName) => fileName !== ""),
+                );
+                pendingUrls.forEach((url) => {
+                    const fileName = this.extractFilename(url);
+                    if (manifestUrlSet.has(url) || (fileName !== "" && manifestFileNameSet.has(fileName))) {
+                        pendingUrls.delete(url);
+                        if (fileName !== "") {
+                            pendingFileNames.delete(fileName);
+                        }
+                    }
+                });
+                if (pendingUrls.size === 0 || pendingFileNames.size === 0) {
+                    return true;
+                }
+            }
+
+            if (attempt < maxAttempts - 1) {
+                await this.sleep(pollIntervalMs);
+            }
+        }
+
+        return false;
+    }
+
+    private async fetchManifestUrlsSilently(): Promise<{ urls: string[]; revision: string } | null> {
+        if (!this.fetchUrlValue) {
+            return null;
+        }
+
+        try {
+            const response = await fetch(this.fetchUrlValue, {
+                headers: { "X-Requested-With": "XMLHttpRequest" },
+            });
+            if (!response.ok) {
+                return null;
+            }
+
+            const data = (await response.json()) as { urls?: string[]; revision?: string };
+            return this.normalizeManifestData(data);
+        } catch {
+            return null;
+        }
+    }
+
+    private startBackgroundSync(): void {
+        const intervalMs = this.getBackgroundSyncIntervalMs();
+        if (intervalMs <= 0) {
+            return;
+        }
+
+        this.stopBackgroundSync();
+        this.scheduleNextBackgroundSync(intervalMs);
+    }
+
+    private stopBackgroundSync(): void {
+        if (this.backgroundSyncTimeoutId !== null) {
+            clearTimeout(this.backgroundSyncTimeoutId);
+            this.backgroundSyncTimeoutId = null;
+        }
+    }
+
+    private scheduleNextBackgroundSync(intervalMs: number): void {
+        if (!this.isConnected) {
+            return;
+        }
+        this.backgroundSyncTimeoutId = setTimeout(() => {
+            void this.runBackgroundSyncTick();
+        }, intervalMs);
+    }
+
+    private async runBackgroundSyncTick(): Promise<void> {
+        await this.checkForManifestUpdates();
+        if (this.isConnected) {
+            this.scheduleNextBackgroundSync(this.getBackgroundSyncIntervalMs());
+        }
+    }
+
+    private async checkForManifestUpdates(): Promise<void> {
+        if (this.isUploading) {
+            return;
+        }
+
+        const currentRevision = this.latestManifestRevision;
+        const manifestData = await this.fetchManifestUrlsSilently();
+        if (manifestData === null) {
+            return;
+        }
+
+        if (currentRevision === null || manifestData.revision !== currentRevision) {
+            this.latestManifestRevision = manifestData.revision;
+            this.markRefreshAvailable();
+        }
+    }
+
+    private markRefreshAvailable(): void {
+        this.hasPendingRefresh = true;
+        this.uploadProcessingMode = "refreshPrompt";
+        this.showRefreshPromptIfPending();
+    }
+
+    private showRefreshPromptIfPending(): void {
+        if (!this.hasPendingRefresh || this.isUploading || this.isUploadErrorVisible()) {
+            return;
+        }
+        this.showUploadStatus("processing");
+    }
+
+    private isUploadErrorVisible(): boolean {
+        return this.hasUploadErrorTarget && !this.uploadErrorTarget.classList.contains("hidden");
+    }
+
+    private renderUploadProcessingState(): void {
+        if (this.hasUploadProcessingMessageTarget) {
+            this.uploadProcessingMessageTarget.textContent =
+                this.uploadProcessingMode === "refreshPrompt"
+                    ? this.refreshPromptLabelValue
+                    : this.uploadProcessingLabelValue;
+        }
+
+        if (this.hasUploadRefreshActionsTarget) {
+            this.uploadRefreshActionsTarget.classList.toggle("hidden", this.uploadProcessingMode !== "refreshPrompt");
+        }
+    }
+
+    private async reloadAssetsAfterConfirmation(): Promise<void> {
+        await this.fetchAssets();
+        this.showUploadStatus("success");
+        setTimeout(() => this.showUploadStatus("none"), 3000);
+    }
+
+    private formatUploadPartialFailureLabel(errorCount: number, total: number): string {
+        return this.uploadPartialFailureLabelValue
+            .replaceAll("%errorCount%", String(errorCount))
+            .replaceAll("%total%", String(total));
+    }
+
+    private getUploadErrorFallbackLabel(): string {
+        if (this.hasUploadErrorTarget) {
+            const textEl = this.uploadErrorTarget.querySelector("[data-error-text]");
+            if (textEl && textEl.textContent !== null && textEl.textContent !== "") {
+                return textEl.textContent;
+            }
+        }
+        return "Upload failed. Please try again.";
+    }
+
+    private normalizeManifestData(data: { urls?: string[]; revision?: string }): { urls: string[]; revision: string } {
+        const urls = data.urls ?? [];
+        const revision = data.revision ?? this.computeManifestRevision(urls);
+
+        return { urls, revision };
+    }
+
+    private computeManifestRevision(urls: string[]): string {
+        const normalized = [...urls].sort((a, b) => a.localeCompare(b));
+        return normalized.join("|");
+    }
+
+    private getBackgroundSyncIntervalMs(): number {
+        const ctor = this.constructor as typeof Controller & { BACKGROUND_SYNC_INTERVAL_MS?: number };
+        return ctor.BACKGROUND_SYNC_INTERVAL_MS ?? 30000;
+    }
+
+    private getManifestWaitPollIntervalMs(): number {
+        const ctor = this.constructor as typeof Controller & { MANIFEST_WAIT_POLL_INTERVAL_MS?: number };
+        return ctor.MANIFEST_WAIT_POLL_INTERVAL_MS ?? 2000;
+    }
+
+    private getManifestWaitMaxAttempts(): number {
+        const ctor = this.constructor as typeof Controller & { MANIFEST_WAIT_MAX_ATTEMPTS?: number };
+        return ctor.MANIFEST_WAIT_MAX_ATTEMPTS ?? 30;
+    }
+
+    private async sleep(ms: number): Promise<void> {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
     private showLoading(show: boolean): void {
         if (this.hasLoadingTarget) {
             this.loadingTarget.classList.toggle("hidden", !show);
diff --git a/src/RemoteContentAssets/Presentation/Resources/templates/remote_asset_area.twig b/src/RemoteContentAssets/Presentation/Resources/templates/remote_asset_area.twig
index bc8ddf95..ed62cf9f 100644
--- a/src/RemoteContentAssets/Presentation/Resources/templates/remote_asset_area.twig
+++ b/src/RemoteContentAssets/Presentation/Resources/templates/remote_asset_area.twig
@@ -6,6 +6,10 @@
              windowSize: remoteAssetBrowserWindowSize,
              addToChatLabel: 'remote_content_assets.browser_add_to_chat'|trans,
              openInNewTabLabel: 'remote_content_assets.browser_open_in_new_tab'|trans,
+             uploadProcessingLabel: 'remote_content_assets.browser_upload_processing'|trans,
+             refreshPromptLabel: 'remote_content_assets.browser_refresh_prompt'|trans,
+             uploadProcessingDelayedErrorLabel: 'remote_content_assets.browser_upload_processing_delayed'|trans,
+             uploadPartialFailureLabel: 'remote_content_assets.browser_upload_partial_failure'|trans,
              uploadUrl: project.hasS3UploadConfigured() ? path('remote_content_assets.presentation.upload', { projectId: project.id }) : '',
              uploadCsrfToken: project.hasS3UploadConfigured() ? csrf_token('remote_asset_upload') : '',
              workspaceId: workspace.id
@@ -50,6 +54,28 @@
                     <span>{{ 'remote_content_assets.browser_uploading'|trans }}</span>
                     <span {{ stimulus_target('remote-asset-browser', 'uploadProgressText') }}></span>
                 </div>
+                {# Upload processing message (wait for manifest update) #}
+                <div {{ stimulus_target('remote-asset-browser', 'uploadProcessing') }}
+                     class="hidden mt-3 flex items-center gap-2 text-sm text-blue-600 dark:text-blue-400">
+                    <svg class="animate-spin h-4 w-4" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                        <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                    <span {{ stimulus_target('remote-asset-browser', 'uploadProcessingMessage') }}>{{ 'remote_content_assets.browser_upload_processing'|trans }}</span>
+                    <div {{ stimulus_target('remote-asset-browser', 'uploadRefreshActions') }}
+                         class="hidden ml-2 flex items-center gap-2">
+                        <button type="button"
+                                {{ stimulus_action('remote-asset-browser', 'confirmRefresh', 'click') }}
+                                class="px-2 py-1 rounded bg-primary-600 text-white text-xs hover:bg-primary-700 focus:outline-none focus:ring-1 focus:ring-primary-500">
+                            {{ 'remote_content_assets.browser_refresh_yes'|trans }}
+                        </button>
+                        <button type="button"
+                                {{ stimulus_action('remote-asset-browser', 'dismissRefresh', 'click') }}
+                                class="px-2 py-1 rounded border border-dark-300 dark:border-dark-600 text-dark-700 dark:text-dark-200 text-xs hover:bg-dark-100 dark:hover:bg-dark-700">
+                            {{ 'remote_content_assets.browser_refresh_no'|trans }}
+                        </button>
+                    </div>
+                </div>
                 {# Upload success message #}
                 <div {{ stimulus_target('remote-asset-browser', 'uploadSuccess') }}
                      class="hidden mt-3 flex items-center gap-2 text-sm text-green-600 dark:text-green-400">
diff --git a/tests/frontend/unit/RemoteContentAssets/remote_asset_browser_controller.test.ts b/tests/frontend/unit/RemoteContentAssets/remote_asset_browser_controller.test.ts
index 9026fbb5..9fb75c42 100644
--- a/tests/frontend/unit/RemoteContentAssets/remote_asset_browser_controller.test.ts
+++ b/tests/frontend/unit/RemoteContentAssets/remote_asset_browser_controller.test.ts
@@ -4,16 +4,30 @@ import RemoteAssetBrowserController from "../../../../src/RemoteContentAssets/Pr
 
 describe("RemoteAssetBrowserController", () => {
     let application: Application;
+    let originalBackgroundSyncInterval: number;
 
     beforeEach(() => {
         document.body.innerHTML = "";
         application = Application.start();
         application.register("remote-asset-browser", RemoteAssetBrowserController);
         vi.stubGlobal("fetch", vi.fn());
+
+        const ctor = RemoteAssetBrowserController as unknown as {
+            BACKGROUND_SYNC_INTERVAL_MS: number;
+        };
+        originalBackgroundSyncInterval = ctor.BACKGROUND_SYNC_INTERVAL_MS;
+        // Disable periodic polling by default to keep tests deterministic.
+        ctor.BACKGROUND_SYNC_INTERVAL_MS = 0;
     });
 
     afterEach(() => {
         application.stop();
+
+        const ctor = RemoteAssetBrowserController as unknown as {
+            BACKGROUND_SYNC_INTERVAL_MS: number;
+        };
+        ctor.BACKGROUND_SYNC_INTERVAL_MS = originalBackgroundSyncInterval;
+
         vi.restoreAllMocks();
     });
 
@@ -465,6 +479,105 @@ describe("RemoteAssetBrowserController", () => {
         );
     });
 
+    it("does not re-render list on focus when manifest is unchanged", async () => {
+        const ctor = RemoteAssetBrowserController as unknown as {
+            BACKGROUND_SYNC_INTERVAL_MS: number;
+        };
+        const originalInterval = ctor.BACKGROUND_SYNC_INTERVAL_MS;
+        ctor.BACKGROUND_SYNC_INTERVAL_MS = 60000;
+
+        const mockFetch = vi
+            .fn()
+            // Initial fetch in connect()
+            .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ urls: ["https://example.com/a.jpg"] }),
+            })
+            // Silent check on focus (same urls)
+            .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ urls: ["https://example.com/a.jpg"] }),
+            });
+        vi.stubGlobal("fetch", mockFetch);
+
+        await createControllerElement();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        window.dispatchEvent(new Event("focus"));
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        expect(mockFetch).toHaveBeenCalledTimes(2);
+        const listEl = document.querySelector('[data-remote-asset-browser-target="list"]') as HTMLElement;
+        expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(1);
+
+        ctor.BACKGROUND_SYNC_INTERVAL_MS = originalInterval;
+    });
+
+    it("stops background polling on disconnect", async () => {
+        const ctor = RemoteAssetBrowserController as unknown as {
+            BACKGROUND_SYNC_INTERVAL_MS: number;
+        };
+        const originalInterval = ctor.BACKGROUND_SYNC_INTERVAL_MS;
+        ctor.BACKGROUND_SYNC_INTERVAL_MS = 50;
+
+        try {
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ urls: ["https://example.com/a.jpg"] }),
+            });
+            vi.stubGlobal("fetch", mockFetch);
+
+            await createControllerElement();
+            await new Promise((resolve) => setTimeout(resolve, 220));
+
+            const callsBeforeStop = mockFetch.mock.calls.length;
+            application.stop();
+            await new Promise((resolve) => setTimeout(resolve, 120));
+            const callsSoonAfterStop = mockFetch.mock.calls.length;
+            await new Promise((resolve) => setTimeout(resolve, 120));
+            const callsLaterAfterStop = mockFetch.mock.calls.length;
+
+            expect(callsSoonAfterStop).toBeGreaterThanOrEqual(callsBeforeStop);
+            expect(callsLaterAfterStop).toBeLessThanOrEqual(callsBeforeStop + 5);
+        } finally {
+            ctor.BACKGROUND_SYNC_INTERVAL_MS = originalInterval;
+        }
+    });
+
+    it("checks manifest when tab becomes visible", async () => {
+        const ctor = RemoteAssetBrowserController as unknown as {
+            BACKGROUND_SYNC_INTERVAL_MS: number;
+        };
+        const originalInterval = ctor.BACKGROUND_SYNC_INTERVAL_MS;
+        ctor.BACKGROUND_SYNC_INTERVAL_MS = 60000;
+
+        const mockFetch = vi
+            .fn()
+            // Initial fetch in connect()
+            .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ urls: ["https://example.com/a.jpg"] }),
+            })
+            // Silent check on visibilitychange
+            .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ urls: ["https://example.com/a.jpg"] }),
+            });
+        vi.stubGlobal("fetch", mockFetch);
+
+        await createControllerElement();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        const visibilitySpy = vi.spyOn(document, "visibilityState", "get").mockReturnValue("visible");
+        document.dispatchEvent(new Event("visibilitychange"));
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        expect(mockFetch.mock.calls.length).toBeGreaterThanOrEqual(2);
+        visibilitySpy.mockRestore();
+
+        ctor.BACKGROUND_SYNC_INTERVAL_MS = originalInterval;
+    });
+
     describe("upload functionality", () => {
         const createControllerElementWithUpload = async (): Promise<HTMLElement> => {
             const html = `
@@ -473,9 +586,24 @@ describe("RemoteAssetBrowserController", () => {
                      data-remote-asset-browser-upload-url-value="/api/projects/test-id/remote-assets/upload"
                      data-remote-asset-browser-upload-csrf-token-value="csrf-token-123"
                      data-remote-asset-browser-workspace-id-value="workspace-123"
+                     data-remote-asset-browser-upload-processing-label-value="New images are being processed..."
+                     data-remote-asset-browser-refresh-prompt-label-value="New images are available. Refresh the asset list now?"
+                     data-remote-asset-browser-upload-processing-delayed-error-label-value="Upload completed. New images are still processing. Please try again shortly."
+                     data-remote-asset-browser-upload-partial-failure-label-value="%errorCount% of %total% uploads failed."
                      data-remote-asset-browser-window-size-value="50">
+                    <input type="text"
+                           data-remote-asset-browser-target="search"
+                           data-action="input->remote-asset-browser#filter"
+                           placeholder="Search...">
                     <div data-remote-asset-browser-target="dropzone" class="dropzone"></div>
                     <div data-remote-asset-browser-target="uploadProgress" class="hidden">Uploading...</div>
+                    <div data-remote-asset-browser-target="uploadProcessing" class="hidden">
+                        <span data-remote-asset-browser-target="uploadProcessingMessage">Neue Bilder werden verarbeitet...</span>
+                        <div data-remote-asset-browser-target="uploadRefreshActions" class="hidden">
+                            <button type="button" data-action="click->remote-asset-browser#confirmRefresh">Ja</button>
+                            <button type="button" data-action="click->remote-asset-browser#dismissRefresh">Nein</button>
+                        </div>
+                    </div>
                     <div data-remote-asset-browser-target="uploadSuccess" class="hidden">Success!</div>
                     <div data-remote-asset-browser-target="uploadError" class="hidden"><span data-error-text></span></div>
                     <div data-remote-asset-browser-target="loading">Loading...</div>
@@ -633,10 +761,249 @@ describe("RemoteAssetBrowserController", () => {
             expect((eventListener.mock.calls[1][0] as CustomEvent).detail.url).toBe("https://example.com/b.png");
             expect((eventListener.mock.calls[2][0] as CustomEvent).detail.url).toBe("https://example.com/c.gif");
 
-            // 5 fetch calls: initial list + 3 uploads + re-fetch
+            // 5 fetch calls: initial list + 3 uploads + manifest check
             expect(mockFetch).toHaveBeenCalledTimes(5);
         });
 
+        it("shows refresh prompt after manifest contains uploaded image and reloads on confirmation", async () => {
+            const uploadedUrl = "https://example.com/just-uploaded.jpg";
+            const mockFetch = vi
+                .fn()
+                // Initial asset list fetch
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [] }),
+                })
+                // Upload response
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ success: true, url: uploadedUrl }),
+                })
+                // First re-fetch: manifest still stale
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [] }),
+                })
+                // Second re-fetch: manifest now updated
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [uploadedUrl] }),
+                })
+                // Refresh after explicit confirmation
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [uploadedUrl] }),
+                });
+            vi.stubGlobal("fetch", mockFetch);
+
+            await createControllerElementWithUpload();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            const dropzone = document.querySelector('[data-remote-asset-browser-target="dropzone"]') as HTMLElement;
+            const file = new File(["test"], "test.jpg", { type: "image/jpeg" });
+            const dropEvent = createMockDropEvent([file]);
+            dropzone.dispatchEvent(dropEvent);
+
+            const processingEl = document.querySelector(
+                '[data-remote-asset-browser-target="uploadProcessing"]',
+            ) as HTMLElement;
+            const refreshActionsEl = document.querySelector(
+                '[data-remote-asset-browser-target="uploadRefreshActions"]',
+            ) as HTMLElement;
+            const listEl = document.querySelector('[data-remote-asset-browser-target="list"]') as HTMLElement;
+
+            // Processing message is shown while manifest is still stale.
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            expect(processingEl.classList.contains("hidden")).toBe(false);
+            expect(refreshActionsEl.classList.contains("hidden")).toBe(true);
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(0);
+
+            // After next retry fetch (~2s), manifest contains uploaded URL.
+            await new Promise((resolve) => setTimeout(resolve, 2300));
+            expect(processingEl.classList.contains("hidden")).toBe(false);
+            expect(refreshActionsEl.classList.contains("hidden")).toBe(false);
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(0);
+
+            const confirmButton = refreshActionsEl.querySelector("button") as HTMLButtonElement;
+            confirmButton.click();
+            await new Promise((resolve) => setTimeout(resolve, 200));
+
+            expect(processingEl.classList.contains("hidden")).toBe(true);
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(1);
+        });
+
+        it("retries manifest polling until uploaded image appears and waits for confirmation", async () => {
+            const uploadedUrl = "https://example.com/retry-me.jpg";
+            const mockFetch = vi
+                .fn()
+                // Initial fetch
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [] }),
+                })
+                // Upload response
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ success: true, url: uploadedUrl }),
+                })
+                // Retry attempt 1: still stale
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [] }),
+                })
+                // Retry attempt 2: still stale
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [] }),
+                })
+                // Retry attempt 3: now available
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [uploadedUrl] }),
+                })
+                // Refresh after explicit confirmation
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [uploadedUrl] }),
+                });
+            vi.stubGlobal("fetch", mockFetch);
+
+            await createControllerElementWithUpload();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            const dropzone = document.querySelector('[data-remote-asset-browser-target="dropzone"]') as HTMLElement;
+            const file = new File(["test"], "retry.jpg", { type: "image/jpeg" });
+            const dropEvent = createMockDropEvent([file]);
+            dropzone.dispatchEvent(dropEvent);
+
+            // Wait for retry sequence with 2s poll interval (up to third poll).
+            await new Promise((resolve) => setTimeout(resolve, 4600));
+
+            const listEl = document.querySelector('[data-remote-asset-browser-target="list"]') as HTMLElement;
+            const refreshActionsEl = document.querySelector(
+                '[data-remote-asset-browser-target="uploadRefreshActions"]',
+            ) as HTMLElement;
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(0);
+            expect(refreshActionsEl.classList.contains("hidden")).toBe(false);
+
+            const confirmButton = refreshActionsEl.querySelector("button") as HTMLButtonElement;
+            confirmButton.click();
+            await new Promise((resolve) => setTimeout(resolve, 200));
+
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(1);
+        });
+
+        it("shows refresh prompt when manifest URL has same filename on different host", async () => {
+            const uploadUrl = "https://bucket.s3.eu-central-1.amazonaws.com/uploads/20260224/abc_photo.jpg";
+            const manifestUrl = "https://cdn.example.com/uploads/20260224/abc_photo.jpg";
+            const mockFetch = vi
+                .fn()
+                // Initial fetch
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [] }),
+                })
+                // Upload response (S3 URL)
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ success: true, url: uploadUrl }),
+                })
+                // First poll fetch contains CDN URL with same basename
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [manifestUrl] }),
+                })
+                // Refresh after explicit confirmation
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [manifestUrl] }),
+                });
+            vi.stubGlobal("fetch", mockFetch);
+
+            await createControllerElementWithUpload();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            const dropzone = document.querySelector('[data-remote-asset-browser-target="dropzone"]') as HTMLElement;
+            const file = new File(["test"], "photo.jpg", { type: "image/jpeg" });
+            const dropEvent = createMockDropEvent([file]);
+            dropzone.dispatchEvent(dropEvent);
+
+            await new Promise((resolve) => setTimeout(resolve, 250));
+
+            const processingEl = document.querySelector(
+                '[data-remote-asset-browser-target="uploadProcessing"]',
+            ) as HTMLElement;
+            const refreshActionsEl = document.querySelector(
+                '[data-remote-asset-browser-target="uploadRefreshActions"]',
+            ) as HTMLElement;
+            expect(processingEl.classList.contains("hidden")).toBe(false);
+            expect(refreshActionsEl.classList.contains("hidden")).toBe(false);
+
+            const listEl = document.querySelector('[data-remote-asset-browser-target="list"]') as HTMLElement;
+            const confirmButton = refreshActionsEl.querySelector("button") as HTMLButtonElement;
+            confirmButton.click();
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(1);
+        });
+
+        it("shows timeout fallback if manifest is not updated in time", async () => {
+            const ctor = RemoteAssetBrowserController as unknown as {
+                MANIFEST_WAIT_MAX_ATTEMPTS: number;
+                MANIFEST_WAIT_POLL_INTERVAL_MS: number;
+            };
+            const originalMaxAttempts = ctor.MANIFEST_WAIT_MAX_ATTEMPTS;
+            const originalPollInterval = ctor.MANIFEST_WAIT_POLL_INTERVAL_MS;
+            ctor.MANIFEST_WAIT_MAX_ATTEMPTS = 2;
+            ctor.MANIFEST_WAIT_POLL_INTERVAL_MS = 50;
+
+            try {
+                const uploadedUrl = "https://example.com/never-in-manifest.jpg";
+                const mockFetch = vi
+                    .fn()
+                    // Initial fetch
+                    .mockResolvedValueOnce({
+                        ok: true,
+                        json: () => Promise.resolve({ urls: [] }),
+                    })
+                    // Upload response
+                    .mockResolvedValueOnce({
+                        ok: true,
+                        json: () => Promise.resolve({ success: true, url: uploadedUrl }),
+                    })
+                    // Poll attempt 1 (missing)
+                    .mockResolvedValueOnce({
+                        ok: true,
+                        json: () => Promise.resolve({ urls: [] }),
+                    })
+                    // Poll attempt 2 (still missing)
+                    .mockResolvedValueOnce({
+                        ok: true,
+                        json: () => Promise.resolve({ urls: [] }),
+                    });
+                vi.stubGlobal("fetch", mockFetch);
+
+                await createControllerElementWithUpload();
+                await new Promise((resolve) => setTimeout(resolve, 100));
+
+                const dropzone = document.querySelector('[data-remote-asset-browser-target="dropzone"]') as HTMLElement;
+                const file = new File(["test"], "timeout.jpg", { type: "image/jpeg" });
+                const dropEvent = createMockDropEvent([file]);
+                dropzone.dispatchEvent(dropEvent);
+
+                await new Promise((resolve) => setTimeout(resolve, 250));
+
+                const errorEl = document.querySelector(
+                    '[data-remote-asset-browser-target="uploadError"]',
+                ) as HTMLElement;
+                const errorText = errorEl.querySelector("[data-error-text]") as HTMLElement;
+                expect(errorEl.classList.contains("hidden")).toBe(false);
+                expect(errorText.textContent).toContain("still processing");
+            } finally {
+                ctor.MANIFEST_WAIT_MAX_ATTEMPTS = originalMaxAttempts;
+                ctor.MANIFEST_WAIT_POLL_INTERVAL_MS = originalPollInterval;
+            }
+        });
+
         it("shows partial failure message when some uploads fail", async () => {
             const mockFetch = vi
                 .fn()
@@ -692,6 +1059,53 @@ describe("RemoteAssetBrowserController", () => {
             expect(errorText.textContent).toBe("1 of 3 uploads failed.");
         });
 
+        it("does not reload list when refresh prompt is dismissed", async () => {
+            const uploadedUrl = "https://example.com/no-reload.jpg";
+            const mockFetch = vi
+                .fn()
+                // Initial fetch
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [] }),
+                })
+                // Upload response
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ success: true, url: uploadedUrl }),
+                })
+                // Poll fetch containing uploaded URL
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: () => Promise.resolve({ urls: [uploadedUrl] }),
+                });
+            vi.stubGlobal("fetch", mockFetch);
+
+            await createControllerElementWithUpload();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            const dropzone = document.querySelector('[data-remote-asset-browser-target="dropzone"]') as HTMLElement;
+            const file = new File(["test"], "skip-refresh.jpg", { type: "image/jpeg" });
+            const dropEvent = createMockDropEvent([file]);
+            dropzone.dispatchEvent(dropEvent);
+
+            await new Promise((resolve) => setTimeout(resolve, 250));
+
+            const refreshActionsEl = document.querySelector(
+                '[data-remote-asset-browser-target="uploadRefreshActions"]',
+            ) as HTMLElement;
+            const listEl = document.querySelector('[data-remote-asset-browser-target="list"]') as HTMLElement;
+
+            expect(refreshActionsEl.classList.contains("hidden")).toBe(false);
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(0);
+
+            const dismissButton = refreshActionsEl.querySelectorAll("button")[1] as HTMLButtonElement;
+            dismissButton.click();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            expect(listEl.querySelectorAll('button[title="Add to chat"]').length).toBe(0);
+            expect(mockFetch).toHaveBeenCalledTimes(3);
+        });
+
         it("opens file dialog when openFileDialog is called", async () => {
             const html = `
                 <div data-controller="remote-asset-browser"
@@ -699,6 +1113,10 @@ describe("RemoteAssetBrowserController", () => {
                      data-remote-asset-browser-upload-url-value="/api/projects/test-id/remote-assets/upload"
                      data-remote-asset-browser-upload-csrf-token-value="csrf-token-123"
                      data-remote-asset-browser-workspace-id-value="workspace-123"
+                     data-remote-asset-browser-upload-processing-label-value="New images are being processed..."
+                     data-remote-asset-browser-refresh-prompt-label-value="New images are available. Refresh the asset list now?"
+                     data-remote-asset-browser-upload-processing-delayed-error-label-value="Upload completed. New images are still processing. Please try again shortly."
+                     data-remote-asset-browser-upload-partial-failure-label-value="%errorCount% of %total% uploads failed."
                      data-remote-asset-browser-window-size-value="50">
                     <div data-remote-asset-browser-target="dropzone"
                          data-action="click->remote-asset-browser#openFileDialog"
@@ -709,6 +1127,13 @@ describe("RemoteAssetBrowserController", () => {
                            data-action="change->remote-asset-browser#handleFileSelect"
                            class="hidden">
                     <div data-remote-asset-browser-target="uploadProgress" class="hidden">Uploading...</div>
+                    <div data-remote-asset-browser-target="uploadProcessing" class="hidden">
+                        <span data-remote-asset-browser-target="uploadProcessingMessage">Neue Bilder werden verarbeitet...</span>
+                        <div data-remote-asset-browser-target="uploadRefreshActions" class="hidden">
+                            <button type="button" data-action="click->remote-asset-browser#confirmRefresh">Ja</button>
+                            <button type="button" data-action="click->remote-asset-browser#dismissRefresh">Nein</button>
+                        </div>
+                    </div>
                     <div data-remote-asset-browser-target="uploadSuccess" class="hidden">Success!</div>
                     <div data-remote-asset-browser-target="uploadError" class="hidden"><span data-error-text></span></div>
                     <div data-remote-asset-browser-target="loading">Loading...</div>
diff --git a/translations/messages.de.yaml b/translations/messages.de.yaml
index aefa5a48..a3d032b0 100644
--- a/translations/messages.de.yaml
+++ b/translations/messages.de.yaml
@@ -465,8 +465,14 @@ remote_content_assets:
     browser_upload_dropzone: "Bilder hierher ziehen oder klicken"
     browser_upload_hint: "Mehrere Dateien möglich. JPEG, PNG, GIF, WebP, SVG, AVIF (max. 10MB)"
     browser_uploading: "Wird hochgeladen..."
-    browser_upload_success: "Upload abgeschlossen. Asset-Liste wird aktualisiert..."
+    browser_upload_success: "Upload abgeschlossen."
     browser_upload_error: "Upload fehlgeschlagen. Bitte erneut versuchen."
+    browser_upload_processing: "Neue Bilder werden verarbeitet..."
+    browser_refresh_prompt: "Neue Bilder sind verfügbar. Bildliste jetzt aktualisieren?"
+    browser_refresh_yes: "Ja"
+    browser_refresh_no: "Nein"
+    browser_upload_processing_delayed: "Upload abgeschlossen. Neue Bilder werden noch verarbeitet. Bitte versuchen Sie es in Kürze erneut."
+    browser_upload_partial_failure: "%errorCount% von %total% Uploads fehlgeschlagen."
 
 # PhotoBuilder vertical
 photo_builder:
diff --git a/translations/messages.en.yaml b/translations/messages.en.yaml
index cd99597a..b4d68c09 100644
--- a/translations/messages.en.yaml
+++ b/translations/messages.en.yaml
@@ -465,8 +465,14 @@ remote_content_assets:
     browser_upload_dropzone: "Drop images here or click to upload"
     browser_upload_hint: "Multiple files supported. JPEG, PNG, GIF, WebP, SVG, AVIF (max 10MB)"
     browser_uploading: "Uploading..."
-    browser_upload_success: "Upload complete. Refreshing asset list..."
+    browser_upload_success: "Upload complete."
     browser_upload_error: "Upload failed. Please try again."
+    browser_upload_processing: "New images are being processed..."
+    browser_refresh_prompt: "New images are available. Refresh the asset list now?"
+    browser_refresh_yes: "Yes"
+    browser_refresh_no: "No"
+    browser_upload_processing_delayed: "Upload completed. New images are still processing. Please try again shortly."
+    browser_upload_partial_failure: "%errorCount% of %total% uploads failed."
 
 # PhotoBuilder vertical
 photo_builder: