From 1f5f92b17faf93b8473cb5011d6aa9250da485a1 Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 12:28:58 -0600
Subject: [PATCH 01/11] fix(dotai): design and QA follow-ups from the Angular
 migration (#37538)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Seven items from the design and QA review of the new Angular dotAI portlet.

Empty states now go through `dot-empty-container` from `@dotcms/ui`, as every
other portlet does. The portlet's own `dot-ai-empty-state` is deleted and all
eight call sites converted, each with an icon.

`Velocity template` had no hint and no placeholder at all, and the `Fields`
hint was wrong. The two are not independent: `BulkEmbeddingsRunner` tries the
template first and only falls back to the field path when it renders nothing,
so a template silently overrides `Fields`, and an empty pair means dotCMS
guesses the fields rather than embedding the whole contentlet. Both hints now
say so, and the template carries an example.

`View provider config` and its JSON dialog are removed, along with the
`maskCredentials` helper that had no other caller.

`Rebuild DB` is a plain outlined button. A permanently-red control in the
toolbar read as a warning about the screen; the destructive step is the
confirm dialog it opens.

The Config Values host line was built server-side by concatenating the
hostname with " (falls back to system host)" — untranslatable, and it claimed
the fallback whether or not it had happened. `/completions/config` now returns
`configHost` and `configHostInherited` separately, and the label comes from a
message key.

Two defects:

- A rejected Lucene query was reported on the tab *after* the modal had closed
  over the query that caused it. The dialog now owns the submit, renders the
  failure and the "nothing matched" warning inline with the query still in the
  field, and closes only on success.

- A new index did not appear until a manual page reload. `markIndexBuilding`
  set the BUILDING flag and the refresh that followed erased it: `applyIndexes`
  rebuilt the status map from the server's list alone, and embedding is
  asynchronous so `indexCount` does not return the index yet. With no BUILDING
  status left the poll never started. Seeded builds now hold a placeholder row
  until the server catches up, with a TTL so an abandoned build stops the poll.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../lib/dot-ai/dot-ai-config.service.spec.ts  |   6 +-
 .../src/lib/dot-ai/dot-ai-config.service.ts   |   3 +
 .../dotcms-models/src/lib/dot-ai.model.ts     |   7 +-
 .../dot-ai-empty-state.component.html         |   7 -
 .../dot-ai-empty-state.component.ts           |  30 ----
 .../src/lib/models/dot-ai-portlet.models.ts   |  19 ++-
 .../features/with-ai-config.feature.spec.ts   |   2 +-
 .../store/features/with-ai-config.feature.ts  |   2 +
 .../features/with-ai-embeddings.feature.ts    |  10 +-
 .../features/with-ai-indexes.feature.spec.ts  |  76 ++++++++++
 .../store/features/with-ai-indexes.feature.ts |  61 ++++++--
 .../dot-ai-chat/dot-ai-chat.component.html    |   8 +-
 .../tabs/dot-ai-chat/dot-ai-chat.component.ts |  19 ++-
 .../dot-ai-config-values.component.html       |  49 ++-----
 .../dot-ai-config-values.component.spec.ts    |  55 +++-----
 .../dot-ai-config-values.component.ts         |  72 ++++++----
 .../dot-ai-embeddings.component.html          |  51 +++----
 .../dot-ai-embeddings.component.spec.ts       |  64 +++------
 .../dot-ai-embeddings.component.ts            |  91 +++++-------
 .../dot-ai-index-create.component.html        |  21 ++-
 .../dot-ai-index-create.component.spec.ts     | 130 ++++++++++++++++--
 .../dot-ai-index-create.component.ts          |  89 ++++++++----
 .../dot-ai-image/dot-ai-image.component.html  |  16 +--
 .../dot-ai-image/dot-ai-image.component.ts    |  13 +-
 .../dot-ai-search.component.html              |  20 +--
 .../dot-ai-search/dot-ai-search.component.ts  |  36 ++++-
 .../src/lib/utils/dot-ai-config.utils.spec.ts |  40 +-----
 .../src/lib/utils/dot-ai-config.utils.ts      |  29 ----
 .../src/lib/utils/dot-ai-index.utils.ts       |  28 ++++
 .../src/main/java/com/dotcms/ai/AiKeys.java   |   1 +
 .../dotcms/ai/rest/CompletionsResource.java   |   9 +-
 .../WEB-INF/messages/Language.properties      |   9 +-
 32 files changed, 643 insertions(+), 430 deletions(-)
 delete mode 100644 core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.html
 delete mode 100644 core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.ts

diff --git a/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.spec.ts b/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.spec.ts
index 390d7b2166cc..406022f5af6c 100644
--- a/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.spec.ts
+++ b/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.spec.ts
@@ -115,7 +115,7 @@ describe('DotAiConfigService', () => {
             spectator.service.getResolvedConfig().subscribe((r) => (result = r));
 
             flush({
-                configHost: 'demo.dotcms.com (falls back to system host)',
+                configHost: 'demo.dotcms.com',
                 settings: { temperature: '0.7' },
                 providerConfig: JSON.stringify({
                     chat: { provider: 'openrouter', apiKey: '*****', model: 'a,b,c' }
@@ -134,12 +134,12 @@ describe('DotAiConfigService', () => {
             spectator.service.getResolvedConfig().subscribe((r) => (result = r));
 
             flush({
-                configHost: 'demo.dotcms.com (falls back to system host)',
+                configHost: 'demo.dotcms.com',
                 settings: {},
                 providerConfig: '{}'
             });
 
-            expect(result.configHost).toBe('demo.dotcms.com (falls back to system host)');
+            expect(result.configHost).toBe('demo.dotcms.com');
         });
 
         it('should report isConfigured false when providerConfig is omitted', () => {
diff --git a/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.ts b/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.ts
index 148e1a855f8f..16a288d3f196 100644
--- a/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.ts
+++ b/core-web/libs/data-access/src/lib/dot-ai/dot-ai-config.service.ts
@@ -20,6 +20,8 @@ interface ResponseEntityView<T> {
 
 interface RawCompletionsConfig {
     configHost: string;
+    /** Absent on an older backend, where the hostname carried the fallback note inline. */
+    configHostInherited?: boolean;
     settings?: Record<string, string>;
     /** Omitted entirely by the backend when blank — that absence is the "not configured" signal. */
     providerConfig?: string;
@@ -130,6 +132,7 @@ export class DotAiConfigService {
     #toResolvedConfig(raw: RawCompletionsConfig): DotAiResolvedConfig {
         const base = {
             configHost: raw?.configHost ?? '',
+            configHostInherited: raw?.configHostInherited ?? false,
             settings: raw?.settings ?? {}
         };
 
diff --git a/core-web/libs/dotcms-models/src/lib/dot-ai.model.ts b/core-web/libs/dotcms-models/src/lib/dot-ai.model.ts
index d31f83741577..edb276f5d7cf 100644
--- a/core-web/libs/dotcms-models/src/lib/dot-ai.model.ts
+++ b/core-web/libs/dotcms-models/src/lib/dot-ai.model.ts
@@ -270,8 +270,13 @@ export interface DotAiEmbeddingsBuildResult {
 
 /** `providerConfig` parsed exactly once, by DotAiConfigService. */
 export interface DotAiResolvedConfig {
-    /** A display string from the server, e.g. "demo.dotcms.com (falls back to system host)". */
+    /** The site the configuration is read for, e.g. "demo.dotcms.com". */
     configHost: string;
+    /**
+     * The site has no dotAI configuration of its own, so what is shown came from the System
+     * Host. The server reports this separately from the hostname so the client can label it.
+     */
+    configHostInherited: boolean;
     settings: Record<string, string>;
     providerConfig: Record<string, unknown> | null;
     /** `chat.model` is a CSV fallback list whose first entry is the default. */
diff --git a/core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.html b/core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.html
deleted file mode 100644
index 1f9d38950ee1..000000000000
--- a/core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.html
+++ /dev/null
@@ -1,7 +0,0 @@
-<div class="p-8 text-center">
-    <h2 class="text-2xl font-medium">{{ title() }}</h2>
-
-    @if (subtitle()) {
-        <p class="mt-1 text-muted-color">{{ subtitle() }}</p>
-    }
-</div>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.ts b/core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.ts
deleted file mode 100644
index 297db5036048..000000000000
--- a/core-web/libs/portlets/dot-ai/src/lib/components/dot-ai-empty-state/dot-ai-empty-state.component.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { Component, input } from '@angular/core';
-
-/**
- * The portlet's empty / no-results / not-permitted state: a title with an optional line under
- * it, centred in whatever space it is given.
- *
- * Seven of these were written out by hand across the five tabs, each carrying its own
- * typography and spacing literals, so a change to the portlet's empty states meant editing
- * every tab and hoping none had drifted.
- *
- * Takes resolved strings rather than message keys, as `dot-site` does — the caller pipes its
- * own `dm`, which keeps the keys visible at the point of use.
- *
- * Not `dot-empty-container` from `@dotcms/ui`: that renders a smaller `text-lg` title, a
- * styled subtitle and an icon slot, so adopting it would restyle every empty state in the
- * portlet rather than just de-duplicate them.
- */
-@Component({
-    selector: 'dot-ai-empty-state',
-    templateUrl: './dot-ai-empty-state.component.html',
-    // data-testid stays on the call site rather than an input: written there it lands on
-    // this host element in the parent's own template, so it is present whether or not a test
-    // renders this component for real.
-    host: { class: 'block' }
-})
-export class DotAiEmptyStateComponent {
-    readonly title = input.required<string>();
-
-    readonly subtitle = input<string>('');
-}
diff --git a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
index 7477057927e8..d5f0d71eb776 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
@@ -112,6 +112,8 @@ export interface DotAiPortletState {
      */
     configLoadFailed: boolean;
     configHost: string;
+    /** The site has no dotAI configuration of its own; these settings came from System Host. */
+    configHostInherited: boolean;
     settings: Record<string, string>;
     chatModels: string[];
     redactionFailed: boolean;
@@ -121,7 +123,16 @@ export interface DotAiPortletState {
     indexes: DotAiIndex[];
     indexStatuses: Record<string, DotAiIndexStatus>;
     indexFragmentSnapshot: Record<string, number>;
-    indexBuildSeeds: string[];
+    /**
+     * Builds that have been requested but may not be in `indexes` yet — name to the epoch ms
+     * the build was requested. Embedding is asynchronous, so a freshly built index has no rows
+     * in `dot_embeddings` and does not come back from `indexCount` for a second or two; this is
+     * what lets the row show as Building in the meantime instead of not showing at all.
+     *
+     * The timestamp is the stop condition: a build that never materialises would otherwise poll
+     * for the lifetime of the page. See `BUILD_SEED_TTL_MS`.
+     */
+    indexBuildSeeds: Record<string, number>;
     indexesForbidden: boolean;
 
     // shared retrieval settings
@@ -149,6 +160,8 @@ export interface DotAiPortletState {
     // embeddings screen (client-side filters — the whole dataset arrives in one response)
     indexFilter: string;
     indexBuildNotice: DotAiIndexBuildNotice | null;
+    /** A build request is outstanding. Read by the create dialog, which stays open until it settles. */
+    indexBuildInFlight: boolean;
 
     // image
     image: DotAiGeneratedImage | null;
@@ -192,6 +205,7 @@ export const DOT_AI_INITIAL_STATE: DotAiPortletState = {
     configLoaded: false,
     configLoadFailed: false,
     configHost: '',
+    configHostInherited: false,
     settings: {},
     chatModels: [],
     redactionFailed: false,
@@ -200,7 +214,7 @@ export const DOT_AI_INITIAL_STATE: DotAiPortletState = {
     indexes: [],
     indexStatuses: {},
     indexFragmentSnapshot: {},
-    indexBuildSeeds: [],
+    indexBuildSeeds: {},
     indexesForbidden: false,
 
     settingsIndexName: 'default',
@@ -223,6 +237,7 @@ export const DOT_AI_INITIAL_STATE: DotAiPortletState = {
 
     indexFilter: '',
     indexBuildNotice: null,
+    indexBuildInFlight: false,
 
     image: null,
     imageGenerating: false,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.spec.ts
index 6793ec3acf4e..6aba244c3957 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.spec.ts
@@ -13,7 +13,7 @@ import { withAiConfig } from './with-ai-config.feature';
 import { DOT_AI_INITIAL_STATE, DotAiPortletState } from '../../models/dot-ai-portlet.models';
 
 const resolved = (overrides: Partial<DotAiResolvedConfig> = {}): DotAiResolvedConfig => ({
-    configHost: 'demo.dotcms.com (falls back to system host)',
+    configHost: 'demo.dotcms.com',
     settings: { embeddingsSearchThreshold: '0.4' },
     providerConfig: { chat: { model: 'a,b' } },
     chatModels: ['a', 'b'],
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.ts
index 4150d5c679d8..649322c7639e 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-config.feature.ts
@@ -55,6 +55,7 @@ export function withAiConfig() {
             /** The resolved config reassembled from state, for the Config Values screen. */
             resolvedConfig: computed<DotAiResolvedConfig>(() => ({
                 configHost: store.configHost(),
+                configHostInherited: store.configHostInherited(),
                 settings: store.settings(),
                 providerConfig: store.providerConfig(),
                 chatModels: store.chatModels(),
@@ -97,6 +98,7 @@ export function withAiConfig() {
                                         configLoadFailed: false,
                                         isConfigured: config.isConfigured,
                                         configHost: config.configHost,
+                                        configHostInherited: config.configHostInherited,
                                         settings: config.settings,
                                         chatModels: config.chatModels,
                                         redactionFailed: config.redactionFailed,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
index 2ce7eeba91cb..6818a29b5c02 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
@@ -94,7 +94,12 @@ export function withAiEmbeddings() {
 
                 buildIndex: rxMethod<DotAiEmbeddingsBuildForm>(
                     pipe(
-                        tap(() => patchState(store, { indexBuildNotice: null })),
+                        tap(() =>
+                            patchState(store, {
+                                indexBuildNotice: null,
+                                indexBuildInFlight: true
+                            })
+                        ),
                         // exhaustMap: a double submit must not build twice.
                         exhaustMap((form) =>
                             embeddingsService.buildIndex(form).pipe(
@@ -104,6 +109,7 @@ export function withAiEmbeddings() {
                                     // saying nothing here reads as "the build did nothing".
                                     if (!result.totalToEmbed) {
                                         patchState(store, {
+                                            indexBuildInFlight: false,
                                             indexBuildNotice: {
                                                 kind: 'empty',
                                                 indexName: result.indexName
@@ -114,6 +120,7 @@ export function withAiEmbeddings() {
                                     }
 
                                     patchState(store, {
+                                        indexBuildInFlight: false,
                                         indexBuildNotice: {
                                             kind: 'built',
                                             indexName: result.indexName,
@@ -134,6 +141,7 @@ export function withAiEmbeddings() {
                                 // (FR-014).
                                 catchError((error: HttpErrorResponse) => {
                                     patchState(store, {
+                                        indexBuildInFlight: false,
                                         indexBuildNotice: {
                                             kind: 'failed',
                                             indexName: form.indexName,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
index e4b73b52f109..ab35307946a3 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
@@ -125,6 +125,82 @@ describe('withAiIndexes', () => {
         });
     });
 
+    describe('an index the server has not caught up with', () => {
+        // Embedding is asynchronous, so a freshly built index has nothing in dot_embeddings and
+        // indexCount does not return it. Every assertion here is about the window in between,
+        // which is what used to leave the user reloading the page to see their new index.
+        it('should put the new index in the table straight away', () => {
+            stubIndexes([index({ name: 'existing' })]);
+            store.loadIndexes();
+
+            store.markIndexBuilding('blogs');
+
+            expect(store.indexes().map((row) => row.name)).toContain('blogs');
+            expect(store.indexStatuses()['blogs']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
+        });
+
+        it('should keep it on a poll that still does not list it', () => {
+            // The regression: applyIndexes rebuilt the status map from the server's list alone,
+            // so this very refresh erased the BUILDING flag it was meant to act on.
+            stubIndexes([index({ name: 'existing' })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+
+            store.loadIndexes();
+
+            expect(store.indexes().map((row) => row.name)).toContain('blogs');
+            expect(store.indexStatuses()['blogs']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
+        });
+
+        it('should not settle it to READY off a placeholder that never moves', () => {
+            // The placeholder stands at zero fragments. Snapshotting that would make the next
+            // poll read "unchanged" and call the build finished before it started.
+            stubIndexes([index({ name: 'existing' })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+
+            store.loadIndexes();
+            store.loadIndexes();
+
+            expect(store.indexStatuses()['blogs']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
+        });
+
+        it('should hand over to the real row once the server lists it', () => {
+            stubIndexes([index({ name: 'existing' })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+
+            stubIndexes([index({ name: 'existing' }), index({ name: 'blogs', fragments: 4 })]);
+            store.loadIndexes();
+
+            const blogs = store.indexes().find((row) => row.name === 'blogs');
+
+            expect(store.indexes().filter((row) => row.name === 'blogs')).toHaveLength(1);
+            expect(blogs?.fragments).toBe(4);
+            expect(store.indexStatuses()['blogs']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
+        });
+
+        it('should stop waiting on a build that never materialises', () => {
+            // Without an expiry the seed would keep the badge up and the poll running for the
+            // life of the page.
+            vi.useFakeTimers();
+
+            try {
+                stubIndexes([index({ name: 'existing' })]);
+                store.loadIndexes();
+                store.markIndexBuilding('blogs');
+
+                vi.advanceTimersByTime(3 * 60 * 1000);
+                store.loadIndexes();
+
+                expect(store.indexes().map((row) => row.name)).not.toContain('blogs');
+                expect(store.indexStatuses()['blogs']).toBeUndefined();
+            } finally {
+                vi.useRealTimers();
+            }
+        });
+    });
+
     describe('index seeding (FR-018)', () => {
         it('should keep a restored index that is still offered', () => {
             // The old "seed once" flag was never persisted, so every visit arrived unseeded and
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
index e7972a1c0f8d..034fafe8194c 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
@@ -18,11 +18,25 @@ import { DotAiEmbeddingsService, DotHttpErrorManagerService } from '@dotcms/data
 import { DOT_AI_INDEX_STATUS, DotAiIndex } from '@dotcms/dotcms-models';
 
 import { DotAiPortletState } from '../../models/dot-ai-portlet.models';
-import { deriveIndexStatuses, toIndexOptions } from '../../utils/dot-ai-index.utils';
+import {
+    deriveIndexStatuses,
+    toIndexOptions,
+    withPendingIndexes
+} from '../../utils/dot-ai-index.utils';
 
 /** Matches the legacy portlet's cadence; fast enough to feel live, slow enough to be cheap. */
 const INDEX_POLL_MS = 5000;
 
+/**
+ * How long a requested build may stay unaccounted for before the portlet stops waiting on it.
+ *
+ * A seed keeps its index BUILDING and keeps the poll running. Embedding normally writes its
+ * first rows within a second or two, so anything still missing after two minutes is a build
+ * that failed somewhere the client cannot see — and without a stop condition the poll would run
+ * for the life of the page.
+ */
+const BUILD_SEED_TTL_MS = 2 * 60 * 1000;
+
 /**
  * The embeddings index list — one owner, two readers.
  *
@@ -46,20 +60,39 @@ export function withAiIndexes() {
             const httpErrorManager = inject(DotHttpErrorManagerService);
 
             const applyIndexes = (indexes: DotAiIndex[]) => {
-                const offered = toIndexOptions(indexes).map((option) => option.value);
+                const now = Date.now();
 
-                const seeds = new Set(store.indexBuildSeeds());
-                const statuses = deriveIndexStatuses(indexes, store.indexFragmentSnapshot(), seeds);
+                // Drop seeds that have outlived their welcome before anything derives from them,
+                // so an abandoned build stops both the BUILDING badge and the poll.
+                const liveSeeds = Object.fromEntries(
+                    Object.entries(store.indexBuildSeeds()).filter(
+                        ([, startedAt]) => now - startedAt < BUILD_SEED_TTL_MS
+                    )
+                );
+
+                const seeds = new Set(Object.keys(liveSeeds));
+
+                // The server's list plus a placeholder for each seeded build it has not caught
+                // up with, so a new index is in the table from the moment it is requested.
+                const merged = withPendingIndexes(indexes, seeds);
+                const offered = toIndexOptions(merged).map((option) => option.value);
+
+                const statuses = deriveIndexStatuses(merged, store.indexFragmentSnapshot(), seeds);
 
                 // An index that has settled is no longer a candidate for the next poll.
-                const stillBuilding = store
-                    .indexBuildSeeds()
-                    .filter((name) => statuses[name] === DOT_AI_INDEX_STATUS.BUILDING);
+                const stillBuilding = Object.fromEntries(
+                    Object.entries(liveSeeds).filter(
+                        ([name]) => statuses[name] === DOT_AI_INDEX_STATUS.BUILDING
+                    )
+                );
 
                 patchState(store, {
-                    indexes,
+                    indexes: merged,
                     indexStatuses: statuses,
                     indexBuildSeeds: stillBuilding,
+                    // Snapshotted from the server's own response, never from `merged`: a
+                    // placeholder recorded at zero fragments would look like a settled index on
+                    // the next poll and flip itself to READY before the build had begun.
                     indexFragmentSnapshot: indexes.reduce<Record<string, number>>(
                         (snapshot, index) => {
                             snapshot[index.name] = index.fragments;
@@ -113,8 +146,18 @@ export function withAiIndexes() {
                  * from a delta that has not appeared yet.
                  */
                 markIndexBuilding(indexName: string): void {
+                    const listed = store.indexes().some((index) => index.name === indexName);
+
                     patchState(store, {
-                        indexBuildSeeds: [...new Set([...store.indexBuildSeeds(), indexName])],
+                        indexBuildSeeds: { ...store.indexBuildSeeds(), [indexName]: Date.now() },
+                        // Stand the row up now rather than waiting for the next poll — the build
+                        // has been accepted, so the index exists whether or not `indexCount`
+                        // knows about it yet.
+                        ...(listed
+                            ? {}
+                            : {
+                                  indexes: withPendingIndexes(store.indexes(), new Set([indexName]))
+                              }),
                         indexStatuses: {
                             ...store.indexStatuses(),
                             [indexName]: DOT_AI_INDEX_STATUS.BUILDING
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html
index fa10cb31c879..09377f5254fe 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html
@@ -48,11 +48,9 @@
                         }
                     </div>
                 } @else {
-                    <!-- The subtitle deliberately does not promise sources: only the
-                         non-streaming mode returns them, and this tab streams. -->
-                    <dot-ai-empty-state
-                        [title]="'dotai.chat.empty.title' | dm"
-                        [subtitle]="'dotai.chat.empty.sub' | dm"
+                    <dot-empty-container
+                        [configuration]="emptyConfig"
+                        [hideContactUsLink]="true"
                         data-testid="dotai-chat-empty" />
                 }
             </div>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts
index eac98cbc63ed..c493eb3834a6 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts
@@ -5,10 +5,10 @@ import { Component, computed, DestroyRef, inject, signal, viewChild } from '@ang
 import { ButtonModule } from 'primeng/button';
 
 import { DotAgentThinkingComponent, DotAiPromptInputComponent } from '@dotcms/ai-ui';
+import { DotMessageService } from '@dotcms/data-access';
 import { DOT_AI_ANSWER_STATE } from '@dotcms/dotcms-models';
-import { DotMessagePipe } from '@dotcms/ui';
+import { DotEmptyContainerComponent, DotMessagePipe, PrincipalConfiguration } from '@dotcms/ui';
 
-import { DotAiEmptyStateComponent } from '../../components/dot-ai-empty-state/dot-ai-empty-state.component';
 import { DotAiWorkspaceComponent } from '../../components/dot-ai-workspace/dot-ai-workspace.component';
 import { DotAiStore } from '../../store/dot-ai.store';
 
@@ -28,7 +28,7 @@ import { DotAiStore } from '../../store/dot-ai.store';
 @Component({
     selector: 'dot-ai-chat',
     imports: [
-        DotAiEmptyStateComponent,
+        DotEmptyContainerComponent,
         ButtonModule,
         MarkdownModule,
         DotAgentThinkingComponent,
@@ -42,6 +42,19 @@ import { DotAiStore } from '../../store/dot-ai.store';
 export default class DotAiChatComponent {
     protected readonly store = inject(DotAiStore);
 
+    readonly #messageService = inject(DotMessageService);
+
+    /**
+     * The subtitle deliberately does not promise sources: only the non-streaming mode returns
+     * them, and this tab streams.
+     */
+    protected readonly emptyConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.chat.empty.title'),
+        subtitle: this.#messageService.get('dotai.chat.empty.sub'),
+        icon: 'forum',
+        iconStyle: 'material-symbols-rounded'
+    };
+
     constructor() {
         // FR-015: leaving Chat mid-answer must cancel it. The store's own onDestroy cannot do
         // this — DotAiStore is provided on the shell, above the five tab routes, so switching
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
index bc1e7cab7691..a0de49c1c898 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
@@ -9,33 +9,20 @@
             (search)="$filter.set($event)"
             data-testid="dotai-config-filter" />
 
-        <!-- flex-1 takes the slack, which is what keeps the filter left and the action right;
-             truncate because a long host string would otherwise do the squeezing itself. -->
+        <!-- flex-1 takes the slack, which is what keeps the filter left; truncate because a
+             long host string would otherwise do the squeezing itself. -->
         <span class="flex-1 truncate text-sm text-muted-color" data-testid="dotai-config-host">
-            {{ store.resolvedConfig()?.configHost }}
+            {{ $hostLabel() }}
         </span>
-
-        <!-- redactionFailed leaves providerConfig null while isConfigured stays true, so
-             without that second clause the button opens a dialog containing `{}` — which reads
-             as "the provider has no configuration" rather than "we would not show it". -->
-        <!-- shrink-0 + whitespace-nowrap: PrimeNG sets no white-space on the button or its
-             label, so a squeezed button broke "View provider config" across two lines. -->
-        <p-button
-            class="shrink-0 whitespace-nowrap"
-            variant="text"
-            [label]="'dotai.config.view-provider' | dm"
-            [disabled]="!store.isConfigured() || store.redactionFailed()"
-            (onClick)="$providerDialogOpen.set(true)"
-            data-testid="dotai-config-view-provider" />
     </div>
 
     <div class="min-h-0 flex-1 overflow-hidden">
         @if (store.redactionFailed()) {
             <!-- The server could not safely redact the config, so it sent a sentinel rather
                  than JSON. Say so instead of rendering the sentinel as a value (FR-046). -->
-            <dot-ai-empty-state
-                [title]="'dotai.config.redaction-failed.title' | dm"
-                [subtitle]="'dotai.config.redaction-failed.sub' | dm"
+            <dot-empty-container
+                [configuration]="redactionFailedConfig"
+                [hideContactUsLink]="true"
                 data-testid="dotai-config-redaction-failed" />
         } @else {
             <p-table
@@ -80,9 +67,10 @@
                 <ng-template pTemplate="emptymessage">
                     <tr>
                         <td colspan="3">
-                            <div class="p-8 text-center" data-testid="dotai-config-empty">
-                                <p class="text-muted-color">{{ 'dotai.config.empty' | dm }}</p>
-                            </div>
+                            <dot-empty-container
+                                [configuration]="noMatchesConfig"
+                                [hideContactUsLink]="true"
+                                data-testid="dotai-config-empty" />
                         </td>
                     </tr>
                 </ng-template>
@@ -90,20 +78,3 @@
         }
     </div>
 </section>
-
-<p-dialog
-    [visible]="$providerDialogOpen()"
-    (visibleChange)="$providerDialogOpen.set($event)"
-    [header]="'dotai.config.provider.header' | dm"
-    [modal]="true"
-    [draggable]="false"
-    [closable]="true"
-    [closeAriaLabel]="'close' | dm"
-    [closeOnEscape]="true"
-    [style]="{ width: '700px' }">
-    <pre
-        class="max-h-[60vh] overflow-auto rounded-md bg-surface-100 p-3 font-mono text-sm"
-        data-testid="dotai-config-provider-json"
-        >{{ $providerJson() }}</pre
-    >
-</p-dialog>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts
index f91d146c7ca3..8d3f5e0c9ebc 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts
@@ -14,7 +14,8 @@ import DotAiConfigValuesComponent from './dot-ai-config-values.component';
 import { DotAiStore } from '../../store/dot-ai.store';
 
 const resolved = (overrides: Partial<DotAiResolvedConfig> = {}): DotAiResolvedConfig => ({
-    configHost: 'demo.dotcms.com (falls back to system host)',
+    configHost: 'demo.dotcms.com',
+    configHostInherited: false,
     settings: { temperature: '0.7', debugLogging: 'false' },
     providerConfig: { chat: { apiKey: '*****', temperature: '0.7' } },
     chatModels: [],
@@ -50,9 +51,21 @@ describe('DotAiConfigValuesComponent', () => {
         expect(spectator.queryAll(byTestId('dotai-config-row')).length).toBeGreaterThan(0);
     });
 
-    it('should render configHost verbatim, since the server sends a display string', () => {
-        expect(spectator.query(byTestId('dotai-config-host'))).toContainText(
-            'falls back to system host'
+    it('should label the host from a message key rather than a server-built sentence', () => {
+        const messageService = spectator.inject(DotMessageService, true);
+
+        expect(messageService.get).toHaveBeenCalledWith('dotai.config.host', 'demo.dotcms.com');
+    });
+
+    it('should say when the configuration was inherited from System Host', () => {
+        // Two different facts: which site is on screen, and whose settings those are. The old
+        // server-built string claimed the fallback unconditionally.
+        storeMock.resolvedConfig.mockReturnValue(resolved({ configHostInherited: true }));
+        spectator = createComponent();
+
+        expect(spectator.inject(DotMessageService, true).get).toHaveBeenCalledWith(
+            'dotai.config.host.inherited',
+            'demo.dotcms.com'
         );
     });
 
@@ -71,27 +84,9 @@ describe('DotAiConfigValuesComponent', () => {
         expect(spectator.query(byTestId('dotai-config-table'))).toBeFalsy();
     });
 
-    describe('the provider JSON view', () => {
-        const viewProviderButton = (): HTMLButtonElement | null =>
-            spectator.query(byTestId('dotai-config-view-provider'))?.querySelector('button') ??
-            null;
-
-        it('should mask credentials rather than printing the server mask (FR-042)', () => {
-            spectator.click(viewProviderButton() as HTMLButtonElement);
-            const json = spectator.query(byTestId('dotai-config-provider-json'))?.textContent ?? '';
-
-            expect(json).toContain('••••••••');
-            expect(json).not.toContain('*****');
-        });
-
-        it('should not be offered when redaction failed', () => {
-            // providerConfig is null there while isConfigured stays true, so the dialog would
-            // open on `{}` — which reads as "no provider configuration" rather than "withheld".
-            storeMock.redactionFailed.mockReturnValue(true);
-            spectator = createComponent();
-
-            expect(viewProviderButton()?.hasAttribute('disabled')).toBe(true);
-        });
+    it('should not offer a provider config view at all', () => {
+        // Removed on review: the raw JSON dump was not something the screen needed to carry.
+        expect(spectator.query(byTestId('dotai-config-view-provider'))).toBeFalsy();
     });
 
     describe('the filter bar', () => {
@@ -116,15 +111,5 @@ describe('DotAiConfigValuesComponent', () => {
             // action right without either being positioned.
             expect(host.className).toContain('flex-1');
         });
-
-        it('should not let the view-provider label wrap', () => {
-            // PrimeNG sets no white-space on the button or its label, so a squeezed button
-            // broke "View provider config" across two lines — measured at 1100px, not just
-            // at narrow widths.
-            const button = spectator.query(byTestId('dotai-config-view-provider')) as HTMLElement;
-
-            expect(button.className).toContain('whitespace-nowrap');
-            expect(button.className).toContain('shrink-0');
-        });
     });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
index f32332c7735d..12af81d07786 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
@@ -1,23 +1,22 @@
 import { Component, computed, inject, signal } from '@angular/core';
 
-import { ButtonModule } from 'primeng/button';
-import { DialogModule } from 'primeng/dialog';
 import { TableModule } from 'primeng/table';
 import { TagModule } from 'primeng/tag';
 
-import { DotCopyButtonComponent, DotMessagePipe, DotSearchInputComponent } from '@dotcms/ui';
+import { DotMessageService } from '@dotcms/data-access';
+import {
+    DotCopyButtonComponent,
+    DotEmptyContainerComponent,
+    DotMessagePipe,
+    DotSearchInputComponent,
+    PrincipalConfiguration
+} from '@dotcms/ui';
 
-import { DotAiEmptyStateComponent } from '../../components/dot-ai-empty-state/dot-ai-empty-state.component';
 import { DotAiStore } from '../../store/dot-ai.store';
-import {
-    DOT_AI_CONFIG_SOURCE,
-    maskCredentials,
-    toConfigRows
-} from '../../utils/dot-ai-config.utils';
+import { DOT_AI_CONFIG_SOURCE, toConfigRows } from '../../utils/dot-ai-config.utils';
 
 /**
- * Config Values: every resolved dotAI setting, where it came from, and the raw provider
- * configuration behind it.
+ * Config Values: every resolved dotAI setting and where it came from.
  *
  * A diagnostic screen, so it stays reachable and useful even when nothing else works —
  * which is exactly when it is needed (FR-048).
@@ -25,11 +24,9 @@ import {
 @Component({
     selector: 'dot-ai-config-values',
     imports: [
-        DotAiEmptyStateComponent,
+        DotEmptyContainerComponent,
         TableModule,
         TagModule,
-        ButtonModule,
-        DialogModule,
         DotSearchInputComponent,
         DotCopyButtonComponent,
         DotMessagePipe
@@ -40,9 +37,44 @@ import {
 export default class DotAiConfigValuesComponent {
     protected readonly store = inject(DotAiStore);
 
+    readonly #messageService = inject(DotMessageService);
+
     protected readonly sources = DOT_AI_CONFIG_SOURCE;
     protected readonly $filter = signal('');
-    protected readonly $providerDialogOpen = signal(false);
+
+    protected readonly redactionFailedConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.config.redaction-failed.title'),
+        subtitle: this.#messageService.get('dotai.config.redaction-failed.sub'),
+        icon: 'visibility_off',
+        iconStyle: 'material-symbols-rounded'
+    };
+
+    protected readonly noMatchesConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.config.empty'),
+        icon: 'filter_alt_off',
+        iconStyle: 'material-symbols-rounded'
+    };
+
+    /**
+     * Which site's configuration is on screen, and whether it is actually that site's.
+     *
+     * The server resolves dotAI settings per site and falls back to the System Host's when the
+     * site has none of its own, so these are two different facts and the label has to say which
+     * one applies. They arrive as separate fields precisely so this can be a message key rather
+     * than an English sentence assembled on the server.
+     */
+    protected readonly $hostLabel = computed(() => {
+        const config = this.store.resolvedConfig();
+
+        if (!config?.configHost) {
+            return '';
+        }
+
+        return this.#messageService.get(
+            config.configHostInherited ? 'dotai.config.host.inherited' : 'dotai.config.host',
+            config.configHost
+        );
+    });
 
     protected readonly $rows = computed(() => toConfigRows(this.store.resolvedConfig()));
 
@@ -60,16 +92,6 @@ export default class DotAiConfigValuesComponent {
         );
     });
 
-    /**
-     * A flat two-column table cannot represent nested JSON, so it gets its own view.
-     *
-     * Masked on the way out: the server sends credential fields as `*****`, and printing that
-     * verbatim shows a mask that reads like a real value (FR-042).
-     */
-    protected readonly $providerJson = computed(() =>
-        JSON.stringify(maskCredentials(this.store.resolvedConfig()?.providerConfig ?? {}), null, 2)
-    );
-
     protected severityFor(source: string): 'info' | 'secondary' {
         return source === DOT_AI_CONFIG_SOURCE.APP_CONFIG ? 'info' : 'secondary';
     }
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
index 8cc95732017a..a3cbbaafd08b 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
@@ -10,7 +10,7 @@
         <ng-template pTemplate="end">
             <div class="flex items-center gap-2">
                 <p-button
-                    severity="danger"
+                    severity="secondary"
                     [outlined]="true"
                     [label]="'dotai.embeddings.rebuild' | dm"
                     (onClick)="confirmRebuild()"
@@ -24,40 +24,29 @@
         </ng-template>
     </p-toolbar>
 
+    <!-- Only a successful build reaches the tab. The two outcomes that need the query fixed —
+         nothing matched, and a query the server rejected — stay inside the dialog, next to the
+         field that produced them. -->
     @if (store.indexBuildNotice(); as notice) {
-        <!-- Build outcomes land here rather than in a modal: the dialog has already closed by
-             the time the answer arrives, and the shared error handler would render a malformed
-             query as "Unknown Error" with the index name lost. -->
-        <p-message
-            class="block shrink-0 px-4 pb-2"
-            [severity]="noticeSeverity(notice.kind)"
-            [closable]="true"
-            (onClose)="store.dismissBuildNotice()"
-            data-testid="dotai-embeddings-build-notice">
-            @switch (notice.kind) {
-                @case ('built') {
-                    {{ 'dotai.embeddings.build.ok' | dm: [notice.detail ?? '', notice.indexName] }}
-                }
-                @case ('empty') {
-                    {{ 'dotai.embeddings.build.empty' | dm: [notice.indexName] }}
-                }
-                @default {
-                    {{
-                        'dotai.embeddings.build.failed'
-                            | dm: [notice.indexName, notice.detail ?? '']
-                    }}
-                }
-            }
-        </p-message>
+        @if (notice.kind === 'built') {
+            <p-message
+                class="block shrink-0 px-4 pb-2"
+                severity="success"
+                [closable]="true"
+                (onClose)="store.dismissBuildNotice()"
+                data-testid="dotai-embeddings-build-notice">
+                {{ 'dotai.embeddings.build.ok' | dm: [notice.detail ?? '', notice.indexName] }}
+            </p-message>
+        }
     }
 
     <div class="min-h-0 flex-1 overflow-hidden">
         @if (store.indexesForbidden()) {
             <!-- indexCount requires CMS_ADMINISTRATOR_ROLE while portlet access does not, so
                  this is a normal state for a non-admin, not an error (FR-049, FR-050). -->
-            <dot-ai-empty-state
-                [title]="'dotai.index.admin-required' | dm"
-                [subtitle]="'dotai.index.admin-required.sub' | dm"
+            <dot-empty-container
+                [configuration]="forbiddenConfig"
+                [hideContactUsLink]="true"
                 data-testid="dotai-embeddings-forbidden" />
         } @else {
             <p-table
@@ -157,9 +146,9 @@
                 <ng-template pTemplate="emptymessage">
                     <tr>
                         <td colspan="6">
-                            <dot-ai-empty-state
-                                [title]="'dotai.embeddings.empty.title' | dm"
-                                [subtitle]="'dotai.embeddings.empty.sub' | dm"
+                            <dot-empty-container
+                                [configuration]="emptyConfig"
+                                [hideContactUsLink]="true"
                                 data-testid="dotai-embeddings-empty" />
                         </td>
                     </tr>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
index 51b6cb2e66ae..a869200ef125 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
@@ -148,53 +148,17 @@ describe('DotAiEmbeddingsComponent', () => {
             );
         });
 
-        it('should build without forwarding the dialog-only mode field', () => {
-            // The server answers 400 "Unrecognized field 'mode'" rather than ignoring it, so
-            // passing the dialog result through verbatim broke every index build.
+        it('should clear a previous outcome so the dialog opens clean', () => {
+            // The dialog reads the same notice signal; a stale one would greet the next build
+            // with the last one's error.
             clickButton('dotai-embeddings-new-index');
 
-            onClose.next({ mode: 'add', indexName: 'blogs', query: '+contentType:Blog' });
-
-            expect(storeMock.buildIndex).toHaveBeenCalledWith({
-                indexName: 'blogs',
-                query: '+contentType:Blog'
-            });
-            expect(storeMock.buildIndex.mock.calls[0][0]).not.toHaveProperty('mode');
-            expect(storeMock.deleteFromIndex).not.toHaveBeenCalled();
+            expect(storeMock.dismissBuildNotice).toHaveBeenCalled();
         });
 
-        it('should still forward the optional build fields', () => {
-            clickButton('dotai-embeddings-new-index');
-
-            onClose.next({
-                mode: 'add',
-                indexName: 'blogs',
-                query: '+contentType:Blog',
-                fields: 'title,body',
-                velocityTemplate: '$!{title}'
-            });
-
-            expect(storeMock.buildIndex).toHaveBeenCalledWith({
-                indexName: 'blogs',
-                query: '+contentType:Blog',
-                fields: 'title,body',
-                velocityTemplate: '$!{title}'
-            });
-        });
-
-        it('should delete from the index on a delete-mode result (FR-030)', () => {
-            clickButton('dotai-embeddings-new-index');
-
-            onClose.next({ mode: 'delete', indexName: 'blogs', query: '+contentType:Blog' });
-
-            expect(storeMock.deleteFromIndex).toHaveBeenCalledWith({
-                indexName: 'blogs',
-                query: '+contentType:Blog'
-            });
-            expect(storeMock.buildIndex).not.toHaveBeenCalled();
-        });
-
-        it('should do nothing when the dialog is dismissed', () => {
+        it('should leave the build to the dialog rather than submitting on close', () => {
+            // The dialog owns the submit now: a rejected Lucene query has to be correctable in
+            // the form that produced it, not reported here after the modal took the query away.
             clickButton('dotai-embeddings-new-index');
 
             onClose.next(undefined);
@@ -278,11 +242,15 @@ describe('DotAiEmbeddingsComponent', () => {
             expect(classes).not.toContain('p-button-outlined');
         });
 
-        it('should keep Rebuild DB red, since that one drops every embedding', () => {
-            expect(
-                spectator.query(byTestId('dotai-embeddings-rebuild'))?.querySelector('button')
-                    ?.className
-            ).toContain('p-button-danger');
+        it('should keep Rebuild DB a plain outlined button, not a red one', () => {
+            // A permanently-red control in the toolbar read as a warning about the screen.
+            // The destructive step is the confirm dialog it opens.
+            const rebuild = spectator
+                .query(byTestId('dotai-embeddings-rebuild'))
+                ?.querySelector('button');
+
+            expect(rebuild?.className).toContain('p-button-outlined');
+            expect(rebuild?.className).not.toContain('p-button-danger');
         });
     });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index a29538f5f1c7..e1e2c5751950 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -9,19 +9,17 @@ import { TableModule } from 'primeng/table';
 import { TagModule } from 'primeng/tag';
 import { ToolbarModule } from 'primeng/toolbar';
 
-import { take } from 'rxjs/operators';
-
 import { DotMessageService } from '@dotcms/data-access';
 import { DOT_AI_INDEX_STATUS, DotAiIndex } from '@dotcms/dotcms-models';
-import { DotMessagePipe, DotSearchInputComponent } from '@dotcms/ui';
-
 import {
-    DotAiIndexCreateComponent,
-    DotAiIndexCreateResult
-} from './dot-ai-index-create/dot-ai-index-create.component';
+    DotEmptyContainerComponent,
+    DotMessagePipe,
+    DotSearchInputComponent,
+    PrincipalConfiguration
+} from '@dotcms/ui';
+
+import { DotAiIndexCreateComponent } from './dot-ai-index-create/dot-ai-index-create.component';
 
-import { DotAiEmptyStateComponent } from '../../components/dot-ai-empty-state/dot-ai-empty-state.component';
-import { DotAiIndexBuildNotice } from '../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../store/dot-ai.store';
 
 /**
@@ -52,7 +50,7 @@ const CONFIRM_BUTTONS = {
 @Component({
     selector: 'dot-ai-embeddings',
     imports: [
-        DotAiEmptyStateComponent,
+        DotEmptyContainerComponent,
         ToolbarModule,
         MessageModule,
         TableModule,
@@ -75,56 +73,43 @@ export default class DotAiEmbeddingsComponent {
 
     protected readonly statuses = DOT_AI_INDEX_STATUS;
 
+    protected readonly emptyConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.embeddings.empty.title'),
+        subtitle: this.#messageService.get('dotai.embeddings.empty.sub'),
+        icon: 'database',
+        iconStyle: 'material-symbols-rounded'
+    };
+
+    protected readonly forbiddenConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.index.admin-required'),
+        subtitle: this.#messageService.get('dotai.index.admin-required.sub'),
+        icon: 'lock',
+        iconStyle: 'material-symbols-rounded'
+    };
+
     /** Fixed layout plus full height keeps the empty state from collapsing the table. */
     protected readonly tablePt = {
         table: { class: 'table-fixed' },
         wrapper: { class: 'h-full' }
     };
 
-    /** p-message severities for the three build outcomes. */
-    protected noticeSeverity(kind: DotAiIndexBuildNotice['kind']): 'success' | 'warn' | 'error' {
-        if (kind === 'built') {
-            return 'success';
-        }
-
-        return kind === 'empty' ? 'warn' : 'error';
-    }
-
+    /**
+     * Opens the build dialog and leaves it to it.
+     *
+     * No `onClose` handling any more: the dialog submits to the store itself so that a rejected
+     * Lucene query can be corrected in the form that produced it, rather than being reported
+     * onto this tab after the modal has closed over the query.
+     */
     protected openCreateDialog(): void {
-        this.#dialogService
-            .open(DotAiIndexCreateComponent, {
-                header: this.#messageService.get('dotai.index.create.header'),
-                width: '700px',
-                closable: true,
-                closeOnEscape: true,
-                draggable: false,
-                data: { indexes: this.store.indexes().map((index) => index.name) }
-            })
-            // `DialogService.onClose` is `Observable<any>`, so the annotation here is what
-            // makes the "mode must not travel any further" invariant below a compiler rule
-            // rather than a convention.
-            .onClose.pipe(take(1))
-            .subscribe((result: DotAiIndexCreateResult | undefined) => {
-                if (!result) {
-                    return;
-                }
-
-                // `mode` picks the branch and must not travel any further: it is a dialog
-                // concept, and EmbeddingsForm rejects the whole request with
-                // "Unrecognized field 'mode'" rather than ignoring it.
-                const { mode, ...form } = result;
-
-                if (mode === 'delete') {
-                    this.store.deleteFromIndex({
-                        indexName: form.indexName,
-                        query: form.query
-                    });
-
-                    return;
-                }
-
-                this.store.buildIndex(form);
-            });
+        this.store.dismissBuildNotice();
+
+        this.#dialogService.open(DotAiIndexCreateComponent, {
+            header: this.#messageService.get('dotai.index.create.header'),
+            width: '700px',
+            closable: true,
+            closeOnEscape: true,
+            draggable: false
+        });
     }
 
     protected confirmDeleteIndex(index: DotAiIndex): void {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
index dd3ebd96f05b..2889cf4634e5 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
@@ -76,14 +76,32 @@
             <textarea
                 pTextarea
                 id="dotai-index-template"
-                rows="2"
+                rows="3"
                 [ngModel]="$velocityTemplate()"
                 [ngModelOptions]="{ standalone: true }"
                 (ngModelChange)="$velocityTemplate.set($event)"
+                [placeholder]="'dotai.index.create.template.placeholder' | dm"
                 data-testid="dotai-index-create-template"></textarea>
+            <small class="p-field-hint">{{ 'dotai.index.create.template.hint' | dm }}</small>
         </div>
     }
 
+    <!-- The build outcome belongs here, not on the tab behind: a rejected Lucene query is a
+         correction to the field two rows up, and the dialog is still holding it. Only the
+         outcomes the user has to act on reach this — a success closes the dialog instead. -->
+    @if ($notice(); as notice) {
+        <p-message
+            class="mt-4 block"
+            [severity]="notice.kind === 'empty' ? 'warn' : 'error'"
+            data-testid="dotai-index-create-notice">
+            @if (notice.kind === 'empty') {
+                {{ 'dotai.embeddings.build.empty' | dm: [notice.indexName] }}
+            } @else {
+                {{ 'dotai.embeddings.build.failed' | dm: [notice.indexName, notice.detail ?? ''] }}
+            }
+        </p-message>
+    }
+
     <div class="mt-4 flex justify-end gap-2">
         <p-button
             severity="secondary"
@@ -95,6 +113,7 @@
             type="submit"
             [severity]="$mode() === 'delete' ? 'danger' : 'primary'"
             [disabled]="!$canSubmit()"
+            [loading]="store.indexBuildInFlight()"
             [label]="$submitLabel() | dm"
             data-testid="dotai-index-create-submit" />
     </div>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
index 91df1c0b18fe..f04a1fa9598f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
@@ -5,28 +5,58 @@ import {
     Spectator
 } from '@openng/spectator/vitest';
 
-import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { signal } from '@angular/core';
+
+import { DynamicDialogRef } from 'primeng/dynamicdialog';
 
 import { DotMessageService } from '@dotcms/data-access';
+import { DotAiIndex } from '@dotcms/dotcms-models';
 
 import { DotAiIndexCreateComponent } from './dot-ai-index-create.component';
 
+import { DotAiIndexBuildNotice } from '../../../models/dot-ai-portlet.models';
+import { DotAiStore } from '../../../store/dot-ai.store';
+
 describe('DotAiIndexCreateComponent', () => {
     let spectator: Spectator<DotAiIndexCreateComponent>;
     let dialogRef: DynamicDialogRef;
+    let store: {
+        indexes: ReturnType<typeof signal<DotAiIndex[]>>;
+        indexBuildNotice: ReturnType<typeof signal<DotAiIndexBuildNotice | null>>;
+        indexBuildInFlight: ReturnType<typeof signal<boolean>>;
+        buildIndex: ReturnType<typeof vi.fn>;
+        deleteFromIndex: ReturnType<typeof vi.fn>;
+        dismissBuildNotice: ReturnType<typeof vi.fn>;
+    };
 
     const createComponent = createComponentFactory({
         component: DotAiIndexCreateComponent,
-        providers: [
-            mockProvider(DynamicDialogRef),
-            mockProvider(DotMessageService),
-            { provide: DynamicDialogConfig, useValue: { data: { indexes: ['default'] } } }
-        ],
+        providers: [mockProvider(DynamicDialogRef), mockProvider(DotMessageService)],
         shallow: true
     });
 
     beforeEach(() => {
-        spectator = createComponent();
+        store = {
+            indexes: signal<DotAiIndex[]>([
+                {
+                    name: 'default',
+                    fragments: 1,
+                    contents: 1,
+                    tokenTotal: 1,
+                    tokensPerChunk: 1,
+                    contentTypes: []
+                }
+            ]),
+            indexBuildNotice: signal<DotAiIndexBuildNotice | null>(null),
+            indexBuildInFlight: signal(false),
+            buildIndex: vi.fn(),
+            deleteFromIndex: vi.fn(),
+            dismissBuildNotice: vi.fn()
+        };
+
+        spectator = createComponent({
+            providers: [{ provide: DotAiStore, useValue: store }]
+        });
         dialogRef = spectator.inject(DynamicDialogRef);
     });
 
@@ -39,6 +69,12 @@ describe('DotAiIndexCreateComponent', () => {
             spectator.query(byTestId(testId))?.querySelector('button') as HTMLButtonElement
         );
 
+    const fillValidForm = () => {
+        fill('dotai-index-create-name', 'blogs');
+        fill('dotai-index-create-query', '+contentType:Blog');
+        spectator.detectChanges();
+    };
+
     it('should keep submit disabled until both name and query are given', () => {
         const submit = () =>
             spectator.query(byTestId('dotai-index-create-submit'))?.querySelector('button');
@@ -54,20 +90,20 @@ describe('DotAiIndexCreateComponent', () => {
         expect(submit()?.disabled).toBe(false);
     });
 
-    it('should close with an add-mode payload including the optional shaping fields', () => {
-        fill('dotai-index-create-name', 'blogs');
-        fill('dotai-index-create-query', '+contentType:Blog');
+    it('should build through the store rather than resolving the dialog', () => {
+        fillValidForm();
         fill('dotai-index-create-fields', 'title,body');
         spectator.detectChanges();
 
         clickButton('dotai-index-create-submit');
 
-        expect(dialogRef.close).toHaveBeenCalledWith({
-            mode: 'add',
+        expect(store.buildIndex).toHaveBeenCalledWith({
             indexName: 'blogs',
             query: '+contentType:Blog',
             fields: 'title,body'
         });
+        // The whole point: the query has to survive long enough to be corrected.
+        expect(dialogRef.close).not.toHaveBeenCalled();
     });
 
     it('should trim whitespace off the name and query', () => {
@@ -77,14 +113,72 @@ describe('DotAiIndexCreateComponent', () => {
 
         clickButton('dotai-index-create-submit');
 
-        expect(dialogRef.close).toHaveBeenCalledWith(
+        expect(store.buildIndex).toHaveBeenCalledWith(
             expect.objectContaining({ indexName: 'blogs', query: '+contentType:Blog' })
         );
     });
 
+    it('should show a rejected query inline and keep what was typed', () => {
+        fillValidForm();
+        clickButton('dotai-index-create-submit');
+
+        store.indexBuildNotice.set({
+            kind: 'failed',
+            indexName: 'blogs',
+            detail: 'Cannot parse query'
+        });
+        spectator.detectChanges();
+
+        expect(spectator.query(byTestId('dotai-index-create-notice'))).toBeTruthy();
+        expect(dialogRef.close).not.toHaveBeenCalled();
+        expect(
+            (spectator.query(byTestId('dotai-index-create-query')) as HTMLTextAreaElement).value
+        ).toBe('+contentType:Blog');
+    });
+
+    it('should keep a query that matched nothing in the dialog too', () => {
+        fillValidForm();
+        clickButton('dotai-index-create-submit');
+
+        store.indexBuildNotice.set({ kind: 'empty', indexName: 'blogs' });
+        spectator.detectChanges();
+
+        expect(spectator.query(byTestId('dotai-index-create-notice'))).toBeTruthy();
+        expect(dialogRef.close).not.toHaveBeenCalled();
+    });
+
+    it('should close itself once the build succeeds', () => {
+        fillValidForm();
+        clickButton('dotai-index-create-submit');
+
+        store.indexBuildNotice.set({ kind: 'built', indexName: 'blogs', detail: '12' });
+        spectator.detectChanges();
+
+        expect(dialogRef.close).toHaveBeenCalled();
+    });
+
+    it('should block a second submit while a build is outstanding', () => {
+        fillValidForm();
+        store.indexBuildInFlight.set(true);
+        spectator.detectChanges();
+
+        expect(
+            spectator.query(byTestId('dotai-index-create-submit'))?.querySelector('button')
+                ?.disabled
+        ).toBe(true);
+    });
+
+    it('should reject a name an existing index already uses', () => {
+        fill('dotai-index-create-name', 'default');
+        spectator.detectChanges();
+
+        expect(spectator.query(byTestId('dotai-index-create-name-error'))).toBeTruthy();
+    });
+
     it('should close with nothing on cancel, so the caller does no work', () => {
         clickButton('dotai-index-create-cancel');
 
+        expect(store.dismissBuildNotice).toHaveBeenCalled();
         expect(dialogRef.close).toHaveBeenCalledWith();
     });
 
@@ -104,4 +198,14 @@ describe('DotAiIndexCreateComponent', () => {
             'p-label-input-required'
         );
     });
+
+    it('should guide the Velocity template with a placeholder and a hint', () => {
+        // It had neither, and it silently overrides Fields — the one thing nobody could guess.
+        const template = spectator.query(
+            byTestId('dotai-index-create-template')
+        ) as HTMLTextAreaElement;
+
+        expect(template.getAttribute('placeholder')).toBeTruthy();
+        expect(spectator.query('label[for="dotai-index-template"]')).toBeTruthy();
+    });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
index 52d431af2c9d..642d3e896fc6 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
@@ -1,14 +1,17 @@
-import { Component, computed, inject, signal } from '@angular/core';
+import { Component, computed, effect, inject, signal, untracked } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { ButtonModule } from 'primeng/button';
-import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DynamicDialogRef } from 'primeng/dynamicdialog';
 import { InputTextModule } from 'primeng/inputtext';
+import { MessageModule } from 'primeng/message';
 import { SelectButtonModule } from 'primeng/selectbutton';
 import { TextareaModule } from 'primeng/textarea';
 
 import { DotMessagePipe } from '@dotcms/ui';
 
+import { DotAiStore } from '../../../store/dot-ai.store';
+
 export type DotAiIndexCreateMode = 'add' | 'delete';
 
 /**
@@ -18,20 +21,19 @@ export type DotAiIndexCreateMode = 'add' | 'delete';
  */
 const INDEX_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 
-export interface DotAiIndexCreateResult {
-    mode: DotAiIndexCreateMode;
-    indexName: string;
-    query: string;
-    fields?: string;
-    velocityTemplate?: string;
-}
-
 /**
  * One dialog, two modes.
  *
  * Add mode embeds the content the query matches; delete mode removes it from the index. The
  * submit label flips with the toggle so the destructive mode never hides behind a neutral
  * word (FR-030) — the legacy screen did the same remap.
+ *
+ * Unusually for this codebase, the dialog calls the store itself rather than closing with a
+ * form value for the list component to submit. It has to: a build is the one action here whose
+ * *failure* is a correction to the form — a malformed Lucene query — and resolving the dialog
+ * first threw that message onto the tab behind a modal that had already taken the query with
+ * it. Owning the submit is what lets the query survive its own error. The store is still data
+ * only; nothing here is dispatched from it.
  */
 @Component({
     selector: 'dot-ai-index-create',
@@ -41,15 +43,15 @@ export interface DotAiIndexCreateResult {
         InputTextModule,
         TextareaModule,
         SelectButtonModule,
+        MessageModule,
         DotMessagePipe
     ],
     templateUrl: './dot-ai-index-create.component.html'
 })
 export class DotAiIndexCreateComponent {
     readonly #dialogRef = inject(DynamicDialogRef);
-    readonly #config = inject(DynamicDialogConfig<{ indexes: string[] }>);
 
-    protected readonly existingIndexes = this.#config.data?.indexes ?? [];
+    protected readonly store = inject(DotAiStore);
 
     protected readonly $mode = signal<DotAiIndexCreateMode>('add');
     protected readonly $indexName = signal('');
@@ -68,6 +70,29 @@ export class DotAiIndexCreateComponent {
             : 'dotai.index.create.submit.add'
     );
 
+    /**
+     * The build outcome, while it is this dialog's to show.
+     *
+     * `built` is absent by construction — the effect below closes on it — so what is left is
+     * exactly the two outcomes the user has to act on: a query that matched nothing, and a
+     * query the server rejected.
+     */
+    protected readonly $notice = computed(() => {
+        const notice = this.store.indexBuildNotice();
+
+        return notice?.kind === 'built' ? null : notice;
+    });
+
+    constructor() {
+        // A finished build is the only thing that dismisses this dialog. The success message is
+        // left standing on the tab behind, next to the row it just created.
+        effect(() => {
+            if (this.store.indexBuildNotice()?.kind === 'built') {
+                untracked(() => this.#dialogRef.close());
+            }
+        });
+    }
+
     /** Empty until the field has been touched, so the form does not scold you on open. */
     protected readonly $nameError = computed<string | null>(() => {
         const name = this.$indexName().trim();
@@ -81,7 +106,7 @@ export class DotAiIndexCreateComponent {
         }
 
         // Only for a build: deleting names an index that must already exist.
-        if (this.$mode() === 'add' && this.existingIndexes.includes(name)) {
+        if (this.$mode() === 'add' && this.store.indexes().some((index) => index.name === name)) {
             return 'dotai.index.create.name.exists';
         }
 
@@ -89,7 +114,11 @@ export class DotAiIndexCreateComponent {
     });
 
     protected readonly $canSubmit = computed(
-        () => !!this.$indexName().trim() && !!this.$query().trim() && !this.$nameError()
+        () =>
+            !!this.$indexName().trim() &&
+            !!this.$query().trim() &&
+            !this.$nameError() &&
+            !this.store.indexBuildInFlight()
     );
 
     protected submit(): void {
@@ -97,27 +126,31 @@ export class DotAiIndexCreateComponent {
             return;
         }
 
-        const result: DotAiIndexCreateResult = {
-            mode: this.$mode(),
-            indexName: this.$indexName().trim(),
-            query: this.$query().trim()
-        };
+        const indexName = this.$indexName().trim();
+        const query = this.$query().trim();
 
-        // Only meaningful when embedding; a delete is driven purely by the query.
-        if (this.$mode() === 'add') {
-            if (this.$fields().trim()) {
-                result.fields = this.$fields().trim();
-            }
+        // A delete has no outcome to report back into the form — it either works or goes
+        // through the shared error handler — so it keeps the original resolve-and-close shape.
+        if (this.$mode() === 'delete') {
+            this.store.deleteFromIndex({ indexName, query });
+            this.#dialogRef.close();
 
-            if (this.$velocityTemplate().trim()) {
-                result.velocityTemplate = this.$velocityTemplate().trim();
-            }
+            return;
         }
 
-        this.#dialogRef.close(result);
+        this.store.buildIndex({
+            indexName,
+            query,
+            // Both only shape what gets embedded, so they are omitted rather than sent blank.
+            ...(this.$fields().trim() ? { fields: this.$fields().trim() } : {}),
+            ...(this.$velocityTemplate().trim()
+                ? { velocityTemplate: this.$velocityTemplate().trim() }
+                : {})
+        });
     }
 
     protected cancel(): void {
+        this.store.dismissBuildNotice();
         this.#dialogRef.close();
     }
 }
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html
index 4de215802e21..2a8f23694c2f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html
@@ -122,17 +122,11 @@
                     </div>
                 </div>
             } @else {
-                <div
-                    class="flex min-h-0 flex-1 items-center justify-center rounded-lg bg-surface-100 p-8 text-center"
-                    data-testid="dotai-image-empty">
-                    <div>
-                        <span
-                            class="material-symbols-outlined text-4xl! text-muted-color"
-                            aria-hidden="true">
-                            image
-                        </span>
-                        <p class="mt-2 text-muted-color">{{ 'dotai.image.empty.sub' | dm }}</p>
-                    </div>
+                <div class="flex min-h-0 flex-1 rounded-lg bg-surface-100 p-8">
+                    <dot-empty-container
+                        [configuration]="emptyConfig"
+                        [hideContactUsLink]="true"
+                        data-testid="dotai-image-empty" />
                 </div>
             }
         </div>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts
index b2931526a9fd..a3e63e599661 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts
@@ -9,8 +9,9 @@ import { SkeletonModule } from 'primeng/skeleton';
 import { TooltipModule } from 'primeng/tooltip';
 
 import { DotAiPromptInputComponent } from '@dotcms/ai-ui';
+import { DotMessageService } from '@dotcms/data-access';
 import { DotAIImageOrientation } from '@dotcms/dotcms-models';
-import { DotMessagePipe } from '@dotcms/ui';
+import { DotEmptyContainerComponent, DotMessagePipe, PrincipalConfiguration } from '@dotcms/ui';
 
 import { DotAiStore } from '../../store/dot-ai.store';
 
@@ -24,6 +25,7 @@ import { DotAiStore } from '../../store/dot-ai.store';
 @Component({
     selector: 'dot-ai-image',
     imports: [
+        DotEmptyContainerComponent,
         FormsModule,
         ButtonModule,
         SelectModule,
@@ -40,6 +42,15 @@ import { DotAiStore } from '../../store/dot-ai.store';
 export default class DotAiImageComponent {
     protected readonly store = inject(DotAiStore);
 
+    readonly #messageService = inject(DotMessageService);
+
+    protected readonly emptyConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.image.empty.title'),
+        subtitle: this.#messageService.get('dotai.image.empty.sub'),
+        icon: 'image',
+        iconStyle: 'material-symbols-rounded'
+    };
+
     protected readonly $prompt = signal('');
 
     /**
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html
index 969091574dab..7a8097bd7715 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html
@@ -52,20 +52,20 @@
                             <p-skeleton height="5rem" />
                         }
                     </div>
-                } @else if (store.searchMissingIndex(); as missing) {
-                    <dot-ai-empty-state
-                        [title]="'dotai.search.index-missing' | dm"
-                        [subtitle]="missing"
+                } @else if (store.searchMissingIndex()) {
+                    <dot-empty-container
+                        [configuration]="$missingIndexConfig()"
+                        [hideContactUsLink]="true"
                         data-testid="dotai-search-missing-index" />
                 } @else if (!store.hasSearched()) {
-                    <dot-ai-empty-state
-                        [title]="'dotai.search.first-run.title' | dm"
-                        [subtitle]="'dotai.search.first-run.sub' | dm"
+                    <dot-empty-container
+                        [configuration]="firstRunConfig"
+                        [hideContactUsLink]="true"
                         data-testid="dotai-search-empty-first-run" />
                 } @else if (!store.searchResults().length) {
-                    <dot-ai-empty-state
-                        [title]="'dotai.search.no-results.title' | dm"
-                        [subtitle]="'dotai.search.no-results.sub' | dm"
+                    <dot-empty-container
+                        [configuration]="noResultsConfig"
+                        [hideContactUsLink]="true"
                         data-testid="dotai-search-no-results" />
                 } @else {
                     <ul class="flex flex-col gap-3" data-testid="dotai-search-results">
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts
index fd682c8c50cc..8d1f1ce3ab77 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts
@@ -7,9 +7,14 @@ import { InputTextModule } from 'primeng/inputtext';
 import { ProgressBarModule } from 'primeng/progressbar';
 import { SkeletonModule } from 'primeng/skeleton';
 
-import { DotMessagePipe, DotRelativeDatePipe } from '@dotcms/ui';
+import { DotMessageService } from '@dotcms/data-access';
+import {
+    DotEmptyContainerComponent,
+    DotMessagePipe,
+    DotRelativeDatePipe,
+    PrincipalConfiguration
+} from '@dotcms/ui';
 
-import { DotAiEmptyStateComponent } from '../../components/dot-ai-empty-state/dot-ai-empty-state.component';
 import { DotAiWorkspaceComponent } from '../../components/dot-ai-workspace/dot-ai-workspace.component';
 import { DotAiStore } from '../../store/dot-ai.store';
 import { toClosenessPercent } from '../../utils/dot-ai-distance.utils';
@@ -25,7 +30,7 @@ import { toClosenessPercent } from '../../utils/dot-ai-distance.utils';
 @Component({
     selector: 'dot-ai-search',
     imports: [
-        DotAiEmptyStateComponent,
+        DotEmptyContainerComponent,
         ButtonModule,
         InputGroupModule,
         InputGroupAddonModule,
@@ -42,6 +47,31 @@ import { toClosenessPercent } from '../../utils/dot-ai-distance.utils';
 export default class DotAiSearchComponent {
     protected readonly store = inject(DotAiStore);
 
+    readonly #messageService = inject(DotMessageService);
+
+    /** Resolved strings rather than keys: `dot-empty-container` renders `configuration` as-is. */
+    protected readonly firstRunConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.search.first-run.title'),
+        subtitle: this.#messageService.get('dotai.search.first-run.sub'),
+        icon: 'search',
+        iconStyle: 'material-symbols-rounded'
+    };
+
+    protected readonly noResultsConfig: PrincipalConfiguration = {
+        title: this.#messageService.get('dotai.search.no-results.title'),
+        subtitle: this.#messageService.get('dotai.search.no-results.sub'),
+        icon: 'search_off',
+        iconStyle: 'material-symbols-rounded'
+    };
+
+    /** The only one that has to be computed — the subtitle is the index name from the server. */
+    protected readonly $missingIndexConfig = computed<PrincipalConfiguration>(() => ({
+        title: this.#messageService.get('dotai.search.index-missing'),
+        subtitle: this.store.searchMissingIndex() ?? '',
+        icon: 'database_off',
+        iconStyle: 'material-symbols-rounded'
+    }));
+
     /**
      * Typed rather than `$any($event.target).value`, and a handler rather than `ngModel`:
      * `disabled` is an *input on NgModel*, which applies it a microtask after the binding, so
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.spec.ts
index be8da6018680..85d3432c6ac8 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.spec.ts
@@ -1,14 +1,10 @@
 import { DotAiResolvedConfig } from '@dotcms/dotcms-models';
 
-import {
-    DOT_AI_CONFIG_SOURCE,
-    maskCredentials,
-    SECRET_MASK,
-    toConfigRows
-} from './dot-ai-config.utils';
+import { DOT_AI_CONFIG_SOURCE, SECRET_MASK, toConfigRows } from './dot-ai-config.utils';
 
 const config = (overrides: Partial<DotAiResolvedConfig> = {}): DotAiResolvedConfig => ({
-    configHost: 'demo.dotcms.com (falls back to system host)',
+    configHost: 'demo.dotcms.com',
+    configHostInherited: false,
     settings: { temperature: '0.7', imageSize: '1024x1024' },
     providerConfig: { chat: { provider: 'openrouter', apiKey: '*****', temperature: '0.7' } },
     chatModels: [],
@@ -63,34 +59,4 @@ describe('toConfigRows', () => {
 
         expect(keys).toEqual([...keys].sort((a, b) => a.localeCompare(b)));
     });
-
-    describe('maskCredentials (FR-042)', () => {
-        it('should replace the server mask with the client one', () => {
-            const masked = maskCredentials({ chat: { apiKey: '*****', model: 'gpt-4' } });
-
-            expect(masked).toEqual({ chat: { apiKey: SECRET_MASK, model: 'gpt-4' } });
-        });
-
-        it('should reach a credential at any depth, unlike the table rows', () => {
-            const masked = maskCredentials({
-                image: { aws: { secretAccessKey: '*****', region: 'us-east-1' } }
-            });
-
-            expect(masked).toEqual({
-                image: { aws: { secretAccessKey: SECRET_MASK, region: 'us-east-1' } }
-            });
-        });
-
-        it('should walk arrays without flattening them', () => {
-            expect(maskCredentials([{ apiKey: 'x' }, 'plain'])).toEqual([
-                { apiKey: SECRET_MASK },
-                'plain'
-            ]);
-        });
-
-        it('should pass a primitive through untouched', () => {
-            expect(maskCredentials(null)).toBeNull();
-            expect(maskCredentials('gpt-4')).toBe('gpt-4');
-        });
-    });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.ts
index d59d7d9b1a1b..33eef60fb052 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-config.utils.ts
@@ -20,35 +20,6 @@ export interface DotAiConfigValueRow {
     source: DotAiConfigSource;
 }
 
-/**
- * A copy of the provider config with every credential field replaced by the client's own mask.
- *
- * The server has already rewritten these to `*****`, so nothing secret reaches the browser —
- * but FR-042 rules out rendering the server's mask as much as the value itself, since `*****`
- * reads like a real five-character setting. The raw JSON view is the only place the config is
- * shown unflattened, so it is the only place that needs this; the table gets the same
- * treatment structurally, through `toSecretRows`.
- *
- * Recurses, unlike `toSecretRows`, which only walks the one section level the table has rows
- * for. The JSON view shows whatever depth the provider sent.
- */
-export function maskCredentials(value: unknown): unknown {
-    if (Array.isArray(value)) {
-        return value.map(maskCredentials);
-    }
-
-    if (!value || typeof value !== 'object') {
-        return value;
-    }
-
-    return Object.fromEntries(
-        Object.entries(value as Record<string, unknown>).map(([key, nested]) => [
-            key,
-            AI_CREDENTIAL_FIELDS.includes(key) ? SECRET_MASK : maskCredentials(nested)
-        ])
-    );
-}
-
 /**
  * Flattens the resolved config into table rows, deriving each value's origin the same way the
  * backend resolves it: an explicitly-set value wins, otherwise the built-in default.
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
index 3d0f0d96d169..cce3abb0e426 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
@@ -19,6 +19,30 @@ export function toIndexOptions(indexes: DotAiIndex[]): { label: string; value: s
     }));
 }
 
+/**
+ * A build that has been requested but has not reached `indexCount` yet.
+ *
+ * Embedding is asynchronous — `EmbeddingsRunner` writes one row per contentlet as it finishes —
+ * so for the first second or two after a build the index genuinely exists but has nothing in
+ * `dot_embeddings`, and `indexCount` does not return it. Standing in for it with a zeroed row
+ * is what puts it in the table immediately, rather than leaving the user to reload the page.
+ */
+export function toPendingIndex(name: string): DotAiIndex {
+    return { name, fragments: 0, contents: 0, tokenTotal: 0, tokensPerChunk: 0, contentTypes: [] };
+}
+
+/**
+ * The server's list plus a placeholder row for every seeded build it has not caught up with.
+ *
+ * Ordered with the pending ones last so an in-flight build does not reshuffle the table.
+ */
+export function withPendingIndexes(indexes: DotAiIndex[], buildSeeds: Set<string>): DotAiIndex[] {
+    const listed = new Set(indexes.map((index) => index.name));
+    const pending = [...buildSeeds].filter((name) => !listed.has(name));
+
+    return pending.length ? [...indexes, ...pending.map(toPendingIndex)] : indexes;
+}
+
 /**
  * Build status per index, derived rather than read: `dot_embeddings` has no status column.
  *
@@ -26,6 +50,10 @@ export function toIndexOptions(indexes: DotAiIndex[]): { label: string; value: s
  * the indexes a build was just requested for, which is what lets the very first poll report
  * BUILDING instead of guessing from a delta that has not appeared yet.
  *
+ * A seeded index the server has not listed yet has no `previousFragments` entry — the snapshot
+ * is taken from the server's own response, never from the placeholder rows — so it stays
+ * BUILDING rather than settling to READY off a fragment count of zero that never moves.
+ *
  * Deliberately per index. The legacy portlet derived one portlet-wide flag, so starting a
  * build on one index made every row claim to be building.
  */
diff --git a/dotCMS/src/main/java/com/dotcms/ai/AiKeys.java b/dotCMS/src/main/java/com/dotcms/ai/AiKeys.java
index 979553504400..2037f45e744a 100644
--- a/dotCMS/src/main/java/com/dotcms/ai/AiKeys.java
+++ b/dotCMS/src/main/java/com/dotcms/ai/AiKeys.java
@@ -40,6 +40,7 @@ public class AiKeys {
     public static final String SITE = "site";
     public static final String CREATED = "created";
     public static final String CONFIG_HOST = "configHost";
+    public static final String CONFIG_HOST_INHERITED = "configHostInherited";
     public static final String MODDATE = "moddate";
     public static final String DISTANCE = "distance";
     public static final String EXTRACTED_TEXT = "extractedText";
diff --git a/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java b/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
index f36da6942d0e..f53366dffefe 100644
--- a/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
+++ b/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
@@ -193,7 +193,14 @@ public final Response getConfig(@Context final HttpServletRequest request,
         final AppConfig appConfig = ConfigService.INSTANCE.config(host);
 
         final Map<String, Object> map = new HashMap<>();
-        map.put(AiKeys.CONFIG_HOST, host.getHostname() + " (falls back to system host)");
+        // The site the configuration is being read for, and whether it actually came from that
+        // site. ConfigService falls back to the System Host's secrets when the site has none of
+        // its own, so the two hostnames differing is what "inherited" means here. Reported as
+        // separate fields rather than one concatenated English string so the client can label
+        // and translate it.
+        final String requestedHost = host.getHostname();
+        map.put(AiKeys.CONFIG_HOST, requestedHost);
+        map.put(AiKeys.CONFIG_HOST_INHERITED, !requestedHost.equalsIgnoreCase(appConfig.getHost()));
 
         final String providerConfig = appConfig.getProviderConfig();
         if (StringUtils.isNotBlank(providerConfig)) {
diff --git a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
index b816dfa8ee1c..41ab7e6cdf0f 100644
--- a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
+++ b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
@@ -8742,8 +8742,10 @@ dotai.index.create.query.placeholder=+contentType:Blog
 dotai.index.create.query.hint=Lucene query selecting the content to work on.
 dotai.index.create.fields=Fields
 dotai.index.create.fields.placeholder=title,body
-dotai.index.create.fields.hint=Comma separated. Leave empty to embed the whole contentlet.
+dotai.index.create.fields.hint=Comma separated field variables. Ignored when a Velocity template is set. Leave both empty and dotCMS picks the fields itself.
 dotai.index.create.template=Velocity template
+dotai.index.create.template.placeholder=$contentlet.title $contentlet.body.toHtml()
+dotai.index.create.template.hint=Renders the exact text to embed, once per matching content. Use $contentlet.fieldVariable for field values, or $contentletToString for what dotCMS would pick on its own. HTML is stripped to plain text. Takes precedence over Fields.
 dotai.index.create.cancel=Cancel
 dotai.index.create.submit.add=Build index
 dotai.index.create.submit.delete=Delete from index
@@ -8755,10 +8757,11 @@ dotai.image.save=Save to Assets
 dotai.image.download=Download
 dotai.image.actions.aria=Generated image actions
 dotai.image.published=Saved to your assets.
+dotai.image.empty.title=Generate an image
 dotai.image.empty.sub=Describe what you want. Generating does not save anything until you choose to.
 dotai.config.filter.placeholder=Filter settings
-dotai.config.view-provider=View provider config
-dotai.config.provider.header=Provider configuration
+dotai.config.host=Showing settings for {0}
+dotai.config.host.inherited=Showing settings for {0}, inherited from System Host
 dotai.config.column.key=Key
 dotai.config.column.value=Value
 dotai.config.column.source=Source

From 6022950191bb51844a10feec0337c3ff66cdb809 Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 12:53:30 -0600
Subject: [PATCH 02/11] fix(dotai): centre the empty states in their pane
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`dot-empty-container` centres itself with `h-full`, and a percentage height
needs a parent that has one. Every dotAI call site nested it somewhere with an
auto height, so each state measured only as tall as its own text and pinned
itself to the top of an otherwise blank pane.

Search and Chat: the empty states move out of the `container mx-auto` column
and become direct children of the scroll box, which is a flex child with a
real height. The results and the loading skeletons keep the column.

Embeddings and Config Values: the empty states move out of the table's
`emptymessage` and replace the table entirely, as the forbidden state already
did. A `<td>` is sized by its own content, so nothing done to the host could
centre it there — and this also drops a header row with nothing under it.

The Embeddings empty state now picks its copy: "No indexes yet" only when
there are none, and "No indexes match this filter." when a filter is what
emptied the table. Telling someone to create their first index when they have
six and mistyped the filter is the wrong instruction.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../dot-ai-chat/dot-ai-chat.component.html    | 20 ++++----
 .../dot-ai-config-values.component.html       | 18 +++-----
 .../dot-ai-embeddings.component.html          | 19 ++++----
 .../dot-ai-embeddings.component.ts            | 27 ++++++++---
 .../dot-ai-search.component.html              | 46 +++++++++++--------
 .../dot-ai-search.component.spec.ts           | 21 ++++++++-
 .../WEB-INF/messages/Language.properties      |  1 +
 7 files changed, 93 insertions(+), 59 deletions(-)

diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html
index 09377f5254fe..1849e72476fb 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.html
@@ -1,8 +1,10 @@
 <dot-ai-workspace stateKey="dotai-chat-splitter">
     <section class="flex h-full min-w-0 flex-col overflow-hidden">
+        <!-- Same as Search: the empty state is a direct child so its `h-full` has a parent
+             height to resolve against and it centres in the pane. -->
         <div #answer class="min-h-0 flex-1 overflow-y-auto p-4" data-testid="dotai-chat-answer">
-            <div class="container mx-auto">
-                @if (store.chatAnswer(); as current) {
+            @if (store.chatAnswer(); as current) {
+                <div class="container mx-auto">
                     <!-- One 70ch column for the whole answer, so the thinking indicator
                          starts exactly where the text will appear and nothing shifts
                          sideways when one replaces the other. The stopped note and the
@@ -47,13 +49,13 @@
                             </p>
                         }
                     </div>
-                } @else {
-                    <dot-empty-container
-                        [configuration]="emptyConfig"
-                        [hideContactUsLink]="true"
-                        data-testid="dotai-chat-empty" />
-                }
-            </div>
+                </div>
+            } @else {
+                <dot-empty-container
+                    [configuration]="emptyConfig"
+                    [hideContactUsLink]="true"
+                    data-testid="dotai-chat-empty" />
+            }
         </div>
         <!-- Composer last in the DOM as well as visually, so focus order matches what you
              read: answer, then the box you type in. No border here — dot-ai-prompt-input
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
index a0de49c1c898..7046403111d8 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
@@ -24,6 +24,13 @@
                 [configuration]="redactionFailedConfig"
                 [hideContactUsLink]="true"
                 data-testid="dotai-config-redaction-failed" />
+        } @else if (!$filteredRows().length) {
+            <!-- Same reason as the Embeddings table: a `<td>` is sized by its content, so an
+                 empty state nested in one cannot centre in the pane. -->
+            <dot-empty-container
+                [configuration]="noMatchesConfig"
+                [hideContactUsLink]="true"
+                data-testid="dotai-config-empty" />
         } @else {
             <p-table
                 [value]="$filteredRows()"
@@ -63,17 +70,6 @@
                         </td>
                     </tr>
                 </ng-template>
-
-                <ng-template pTemplate="emptymessage">
-                    <tr>
-                        <td colspan="3">
-                            <dot-empty-container
-                                [configuration]="noMatchesConfig"
-                                [hideContactUsLink]="true"
-                                data-testid="dotai-config-empty" />
-                        </td>
-                    </tr>
-                </ng-template>
             </p-table>
         }
     </div>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
index a3cbbaafd08b..fa2320319cba 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
@@ -48,6 +48,14 @@
                 [configuration]="forbiddenConfig"
                 [hideContactUsLink]="true"
                 data-testid="dotai-embeddings-forbidden" />
+        } @else if (!store.filteredIndexes().length) {
+            <!-- Instead of the table, not inside it: a `<td>` is sized by its own content, so
+                 an empty state nested there cannot centre in the pane however the host is
+                 styled. Replacing the table also drops a header row with nothing under it. -->
+            <dot-empty-container
+                [configuration]="$emptyConfig()"
+                [hideContactUsLink]="true"
+                data-testid="dotai-embeddings-empty" />
         } @else {
             <p-table
                 [value]="store.filteredIndexes()"
@@ -142,17 +150,6 @@
                         </td>
                     </tr>
                 </ng-template>
-
-                <ng-template pTemplate="emptymessage">
-                    <tr>
-                        <td colspan="6">
-                            <dot-empty-container
-                                [configuration]="emptyConfig"
-                                [hideContactUsLink]="true"
-                                data-testid="dotai-embeddings-empty" />
-                        </td>
-                    </tr>
-                </ng-template>
             </p-table>
         }
     </div>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index e1e2c5751950..34e3e7481207 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -1,4 +1,4 @@
-import { Component, inject } from '@angular/core';
+import { Component, computed, inject } from '@angular/core';
 
 import { ConfirmationService } from 'primeng/api';
 import { ButtonModule } from 'primeng/button';
@@ -73,12 +73,25 @@ export default class DotAiEmbeddingsComponent {
 
     protected readonly statuses = DOT_AI_INDEX_STATUS;
 
-    protected readonly emptyConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.embeddings.empty.title'),
-        subtitle: this.#messageService.get('dotai.embeddings.empty.sub'),
-        icon: 'database',
-        iconStyle: 'material-symbols-rounded'
-    };
+    /**
+     * Two different empty states behind one slot: an instance with no indexes at all, and a
+     * filter that matched none of the ones there are. Telling someone to create their first
+     * index when they have six and mistyped the filter is the wrong instruction.
+     */
+    protected readonly $emptyConfig = computed<PrincipalConfiguration>(() =>
+        this.store.indexFilter().trim()
+            ? {
+                  title: this.#messageService.get('dotai.embeddings.no-matches'),
+                  icon: 'filter_alt_off',
+                  iconStyle: 'material-symbols-rounded'
+              }
+            : {
+                  title: this.#messageService.get('dotai.embeddings.empty.title'),
+                  subtitle: this.#messageService.get('dotai.embeddings.empty.sub'),
+                  icon: 'database',
+                  iconStyle: 'material-symbols-rounded'
+              }
+    );
 
     protected readonly forbiddenConfig: PrincipalConfiguration = {
         title: this.#messageService.get('dotai.index.admin-required'),
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html
index 7a8097bd7715..cc0845df4c11 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.html
@@ -44,30 +44,36 @@
             </div>
         </div>
 
+        <!-- The empty states sit directly in this box rather than inside the `container`
+             column below: `dot-empty-container` centres itself with `h-full`, and a percentage
+             height needs a parent that has one. `container mx-auto` is auto-height, so nested
+             there the state pinned itself to the top of an otherwise blank pane. -->
         <div class="min-h-0 flex-1 overflow-y-auto p-4" data-testid="dotai-search-scroll">
-            <div class="container mx-auto">
-                @if (store.isSearching()) {
+            @if (store.isSearching()) {
+                <div class="container mx-auto">
                     <div class="flex flex-col gap-3" data-testid="dotai-search-loading">
                         @for (row of [1, 2, 3]; track row) {
                             <p-skeleton height="5rem" />
                         }
                     </div>
-                } @else if (store.searchMissingIndex()) {
-                    <dot-empty-container
-                        [configuration]="$missingIndexConfig()"
-                        [hideContactUsLink]="true"
-                        data-testid="dotai-search-missing-index" />
-                } @else if (!store.hasSearched()) {
-                    <dot-empty-container
-                        [configuration]="firstRunConfig"
-                        [hideContactUsLink]="true"
-                        data-testid="dotai-search-empty-first-run" />
-                } @else if (!store.searchResults().length) {
-                    <dot-empty-container
-                        [configuration]="noResultsConfig"
-                        [hideContactUsLink]="true"
-                        data-testid="dotai-search-no-results" />
-                } @else {
+                </div>
+            } @else if (store.searchMissingIndex()) {
+                <dot-empty-container
+                    [configuration]="$missingIndexConfig()"
+                    [hideContactUsLink]="true"
+                    data-testid="dotai-search-missing-index" />
+            } @else if (!store.hasSearched()) {
+                <dot-empty-container
+                    [configuration]="firstRunConfig"
+                    [hideContactUsLink]="true"
+                    data-testid="dotai-search-empty-first-run" />
+            } @else if (!store.searchResults().length) {
+                <dot-empty-container
+                    [configuration]="noResultsConfig"
+                    [hideContactUsLink]="true"
+                    data-testid="dotai-search-no-results" />
+            } @else {
+                <div class="container mx-auto">
                     <ul class="flex flex-col gap-3" data-testid="dotai-search-results">
                         @for (result of store.searchResults(); track result.inode) {
                             <li>
@@ -129,8 +135,8 @@
                             </li>
                         }
                     </ul>
-                }
-            </div>
+                </div>
+            }
         </div>
     </section>
 </dot-ai-workspace>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.spec.ts
index bbe1f082e042..bb76581d61bf 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.spec.ts
@@ -263,7 +263,12 @@ describe('DotAiSearchComponent', () => {
         it('should share one set of edges between the field and the results', () => {
             // Chat and Image both centre their content in a `container mx-auto` column;
             // without it Search spanned the full pane and its field did not line up with
-            // the results underneath.
+            // the results underneath. Asserted with results on screen, since the empty states
+            // deliberately sit outside that column — see the next test.
+            storeMock.hasSearched.mockReturnValue(true);
+            storeMock.searchResults.mockReturnValue([result()]);
+            spectator = createComponent();
+
             const field = spectator.query(byTestId('dotai-search-input'))?.closest('.container');
             const results = spectator
                 .query(byTestId('dotai-search-scroll'))
@@ -273,6 +278,20 @@ describe('DotAiSearchComponent', () => {
             expect(results?.className).toContain('mx-auto');
         });
 
+        it('should keep the empty states out of that column so they can centre', () => {
+            // dot-empty-container centres itself with `h-full`, and a percentage height needs
+            // a parent that has one. `container mx-auto` is auto-height, so nested there the
+            // state pinned itself to the top of an otherwise blank pane.
+            spectator = createComponent();
+
+            const scroll = spectator.query(byTestId('dotai-search-scroll'));
+            const empty = spectator.query(byTestId('dotai-search-empty-first-run'));
+
+            expect(empty).toBeTruthy();
+            expect(empty?.closest('.container')).toBeNull();
+            expect(empty?.parentElement).toBe(scroll);
+        });
+
         it('should keep the meta line in the same column as the field', () => {
             storeMock.searchResponse.mockReturnValue(response({ count: 1 }));
             spectator = createComponent();
diff --git a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
index 41ab7e6cdf0f..5b134c34a229 100644
--- a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
+++ b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
@@ -8725,6 +8725,7 @@ dotai.embeddings.column.status=Status
 dotai.embeddings.status.ready=Ready
 dotai.embeddings.status.building=Building
 dotai.embeddings.no-types=No content types
+dotai.embeddings.no-matches=No indexes match this filter.
 dotai.embeddings.empty.title=No indexes yet
 dotai.embeddings.empty.sub=Create an index from a content query to start searching and chatting over your content.
 dotai.index.admin-required.sub=Ask an administrator to grant the role, or to build the indexes for you.

From d841f964334bf52d872dde1e90f6d45bf037a21e Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 12:57:04 -0600
Subject: [PATCH 03/11] fix(dotai): centre the Image empty state horizontally
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`justify-center` belongs on the wrapper, not just inside the host. The host is
a flex *item* in that panel, so it was sized to its own content — a 30rem
column — and sat against the left edge; its own `justify-center` only centred
the text within that column. The other four tabs give the host a full-width
block, which is why this one was the only one still off.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../src/lib/tabs/dot-ai-image/dot-ai-image.component.html   | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html
index 2a8f23694c2f..0f86ed25685c 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.html
@@ -122,7 +122,11 @@
                     </div>
                 </div>
             } @else {
-                <div class="flex min-h-0 flex-1 rounded-lg bg-surface-100 p-8">
+                <!-- `justify-center` on the wrapper, not just inside the host: the host is a
+                     flex *item* here, so it is sized to its own content (a 30rem column) and
+                     sat against the left edge of the panel. Its own `justify-center` only
+                     centres text within that column. -->
+                <div class="flex min-h-0 flex-1 justify-center rounded-lg bg-surface-100 p-8">
                     <dot-empty-container
                         [configuration]="emptyConfig"
                         [hideContactUsLink]="true"

From 7cf525ffd495319081e8f237913a49cd9ec12485 Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 13:16:20 -0600
Subject: [PATCH 04/11] refactor(dotai): fold out duplicated and derivable
 state
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cleanup pass over the feedback fixes; no behaviour change.

`indexStatuses` is a projection, not state. `applyIndexes` keeps a seed only
while its index still derives as BUILDING, so "seeded" and "building" are the
same fact by the time anything reads it — holding both only created somewhere
for the two to drift, and `markIndexBuilding` had to write each separately.
It is now a computed over `indexes` and `indexBuildSeeds`, which also makes
the poll guard say what it means: is any build outstanding.

The build-seed TTL now covers only the window before the index is listed at
all. Measured from the start of the build, as it was, a build of a few
thousand contentlets would have its seed dropped at two minutes, flip to Ready
mid-flight and stop the poll — the exact failure the feature exists to
prevent. Once the index is listed the fragment delta owns its lifecycle and no
clock is involved.

`indexBuildInFlight` leaves the state model: it disabled one button in one
dialog and nothing outside read it, so it is a local signal there instead.
The dialog now clears an unrendered outcome in `DestroyRef.onDestroy` rather
than in `cancel()` — PrimeNG's header X and Escape call `DynamicDialogRef.close`
directly and never reached that handler, leaving a failure set with nothing
showing it.

Also: `markIndexBuilding` no longer re-implements the guard already inside
`withPendingIndexes`; `applyIndexes` stops building and discarding a label per
index for one membership test; the tab's build notice loses a nested `@if`;
and the ten near-identical `PrincipalConfiguration` literals collapse onto one
`toEmptyStateConfig` helper.

Documents the dialog-owns-its-submit exception in libs/portlets/CLAUDE.md,
which still said `close(formValue)` was the only pattern.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 core-web/libs/portlets/CLAUDE.md              |  2 +
 .../src/lib/models/dot-ai-portlet.models.ts   |  6 --
 .../features/with-ai-embeddings.feature.ts    | 10 +--
 .../features/with-ai-indexes.feature.spec.ts  | 25 ++++++
 .../store/features/with-ai-indexes.feature.ts | 81 ++++++++++++-------
 .../tabs/dot-ai-chat/dot-ai-chat.component.ts | 14 ++--
 .../dot-ai-config-values.component.ts         | 26 +++---
 .../dot-ai-embeddings.component.html          | 23 +++---
 .../dot-ai-embeddings.component.ts            | 45 +++++++----
 .../dot-ai-index-create.component.html        |  2 +-
 .../dot-ai-index-create.component.spec.ts     | 36 ++++++++-
 .../dot-ai-index-create.component.ts          | 54 +++++++++----
 .../dot-ai-image/dot-ai-image.component.ts    | 14 ++--
 .../dot-ai-search/dot-ai-search.component.ts  | 33 ++++----
 .../src/lib/utils/dot-ai-empty-state.utils.ts | 24 ++++++
 .../src/lib/utils/dot-ai-index.utils.ts       |  2 +-
 16 files changed, 255 insertions(+), 142 deletions(-)
 create mode 100644 core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-empty-state.utils.ts

diff --git a/core-web/libs/portlets/CLAUDE.md b/core-web/libs/portlets/CLAUDE.md
index bccb282b8ccf..2a79de91edc5 100644
--- a/core-web/libs/portlets/CLAUDE.md
+++ b/core-web/libs/portlets/CLAUDE.md
@@ -65,6 +65,8 @@ this.dialogService.open(MyFormComponent, { width: '700px', ... });
 
 **Modal dialogs (default)**: List component opens `DialogService.open(CreateComponent, ...)`. The dialog closes with the form value; the list component passes it to the store. This is the pattern used in `dot-tags` and should be the default for new portlets.
 
+**Dialogs whose submit can fail into the form (exception)**: when a submit can be rejected in a way that is *a correction to a field the dialog is still holding* — a Lucene or GraphQL query the server parses, say — `close(formValue)` loses the input at the moment the user needs it, and the error surfaces on the screen behind a modal that has already gone. Such a dialog keeps ownership of the submit: it calls the store itself, renders the failure inline, and closes only on success. Keep the request state local to the dialog rather than adding an in-flight flag to portlet state, and clear any unrendered outcome in the dialog's `DestroyRef.onDestroy` — PrimeNG's header X and the Escape key call `DynamicDialogRef.close` directly and never reach your own cancel handler. See `dot-ai`'s `dot-ai-index-create`. `close(formValue)` stays the default for every dialog whose submit cannot fail into the form.
+
 **Routed CRUD (rare)**: Separate route for create/edit pages. Use only when the form is too complex for a dialog (many tabs, nested data). See `dot-experiments` for this pattern.
 
 ## When the CRUD Pattern Is Not Enough
diff --git a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
index d5f0d71eb776..33e0d52961df 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
@@ -9,7 +9,6 @@ import {
     DotAIImageOrientation,
     DOT_AI_VECTOR_OPERATOR,
     DotAiIndex,
-    DotAiIndexStatus,
     DotAiSearchResponse,
     DotAiVectorOperator
 } from '@dotcms/dotcms-models';
@@ -121,7 +120,6 @@ export interface DotAiPortletState {
 
     // indexes
     indexes: DotAiIndex[];
-    indexStatuses: Record<string, DotAiIndexStatus>;
     indexFragmentSnapshot: Record<string, number>;
     /**
      * Builds that have been requested but may not be in `indexes` yet — name to the epoch ms
@@ -160,8 +158,6 @@ export interface DotAiPortletState {
     // embeddings screen (client-side filters — the whole dataset arrives in one response)
     indexFilter: string;
     indexBuildNotice: DotAiIndexBuildNotice | null;
-    /** A build request is outstanding. Read by the create dialog, which stays open until it settles. */
-    indexBuildInFlight: boolean;
 
     // image
     image: DotAiGeneratedImage | null;
@@ -212,7 +208,6 @@ export const DOT_AI_INITIAL_STATE: DotAiPortletState = {
     providerConfig: null,
 
     indexes: [],
-    indexStatuses: {},
     indexFragmentSnapshot: {},
     indexBuildSeeds: {},
     indexesForbidden: false,
@@ -237,7 +232,6 @@ export const DOT_AI_INITIAL_STATE: DotAiPortletState = {
 
     indexFilter: '',
     indexBuildNotice: null,
-    indexBuildInFlight: false,
 
     image: null,
     imageGenerating: false,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
index 6818a29b5c02..2ce7eeba91cb 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
@@ -94,12 +94,7 @@ export function withAiEmbeddings() {
 
                 buildIndex: rxMethod<DotAiEmbeddingsBuildForm>(
                     pipe(
-                        tap(() =>
-                            patchState(store, {
-                                indexBuildNotice: null,
-                                indexBuildInFlight: true
-                            })
-                        ),
+                        tap(() => patchState(store, { indexBuildNotice: null })),
                         // exhaustMap: a double submit must not build twice.
                         exhaustMap((form) =>
                             embeddingsService.buildIndex(form).pipe(
@@ -109,7 +104,6 @@ export function withAiEmbeddings() {
                                     // saying nothing here reads as "the build did nothing".
                                     if (!result.totalToEmbed) {
                                         patchState(store, {
-                                            indexBuildInFlight: false,
                                             indexBuildNotice: {
                                                 kind: 'empty',
                                                 indexName: result.indexName
@@ -120,7 +114,6 @@ export function withAiEmbeddings() {
                                     }
 
                                     patchState(store, {
-                                        indexBuildInFlight: false,
                                         indexBuildNotice: {
                                             kind: 'built',
                                             indexName: result.indexName,
@@ -141,7 +134,6 @@ export function withAiEmbeddings() {
                                 // (FR-014).
                                 catchError((error: HttpErrorResponse) => {
                                     patchState(store, {
-                                        indexBuildInFlight: false,
                                         indexBuildNotice: {
                                             kind: 'failed',
                                             indexName: form.indexName,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
index ab35307946a3..c9f73aea5a0f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
@@ -180,6 +180,31 @@ describe('withAiIndexes', () => {
             expect(store.indexStatuses()['blogs']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
         });
 
+        it('should not cut off a long build the server is still reporting progress on', () => {
+            // The TTL covers only the window before the index is listed at all. Measured from
+            // the start of the build instead, a large one would flip to Ready mid-flight and
+            // stop the poll — the exact failure this feature exists to prevent.
+            vi.useFakeTimers();
+
+            try {
+                stubIndexes([index({ name: 'existing' })]);
+                store.loadIndexes();
+                store.markIndexBuilding('blogs');
+
+                stubIndexes([index({ name: 'existing' }), index({ name: 'blogs', fragments: 4 })]);
+                store.loadIndexes();
+
+                vi.advanceTimersByTime(5 * 60 * 1000);
+
+                stubIndexes([index({ name: 'existing' }), index({ name: 'blogs', fragments: 90 })]);
+                store.loadIndexes();
+
+                expect(store.indexStatuses()['blogs']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
+            } finally {
+                vi.useRealTimers();
+            }
+        });
+
         it('should stop waiting on a build that never materialises', () => {
             // Without an expiry the seed would keep the badge up and the poll running for the
             // life of the page.
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
index 034fafe8194c..8ff7e5202893 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
@@ -15,12 +15,13 @@ import { computed, inject } from '@angular/core';
 import { catchError, switchMap, tap } from 'rxjs/operators';
 
 import { DotAiEmbeddingsService, DotHttpErrorManagerService } from '@dotcms/data-access';
-import { DOT_AI_INDEX_STATUS, DotAiIndex } from '@dotcms/dotcms-models';
+import { DOT_AI_INDEX_STATUS, DotAiIndex, DotAiIndexStatus } from '@dotcms/dotcms-models';
 
 import { DotAiPortletState } from '../../models/dot-ai-portlet.models';
 import {
     deriveIndexStatuses,
     toIndexOptions,
+    toRetrievalIndexes,
     withPendingIndexes
 } from '../../utils/dot-ai-index.utils';
 
@@ -28,14 +29,18 @@ import {
 const INDEX_POLL_MS = 5000;
 
 /**
- * How long a requested build may stay unaccounted for before the portlet stops waiting on it.
+ * How long a requested build may stay missing from `indexCount` before the portlet gives up on
+ * it.
  *
- * A seed keeps its index BUILDING and keeps the poll running. Embedding normally writes its
- * first rows within a second or two, so anything still missing after two minutes is a build
- * that failed somewhere the client cannot see — and without a stop condition the poll would run
- * for the life of the page.
+ * Deliberately scoped to the window *before* the index is listed at all. Once it appears, the
+ * fragment-count delta owns its lifecycle and no clock is involved — a timer measured from the
+ * start of the build would cut a large one off mid-flight, flipping a still-growing index to
+ * Ready and stopping the poll, which is the exact failure this feature exists to prevent.
+ *
+ * Embedding normally writes its first rows within a second or two, so a build still unlisted
+ * after two minutes failed somewhere the client cannot see.
  */
-const BUILD_SEED_TTL_MS = 2 * 60 * 1000;
+const PENDING_SEED_TTL_MS = 2 * 60 * 1000;
 
 /**
  * The embeddings index list — one owner, two readers.
@@ -53,7 +58,29 @@ export function withAiIndexes() {
         type<{ state: DotAiPortletState }>(),
         withComputed((store) => ({
             /** Retrieval targets only — the cache pseudo-index is excluded. */
-            indexOptions: computed(() => toIndexOptions(store.indexes()))
+            indexOptions: computed(() => toIndexOptions(store.indexes())),
+
+            /**
+             * Build status per index, projected rather than stored.
+             *
+             * `applyIndexes` keeps a seed only while its index still derives as BUILDING, so
+             * "seeded" and "building" are the same fact by the time anything reads this —
+             * holding it as a third state field only created somewhere for the two to drift.
+             */
+            indexStatuses: computed<Record<string, DotAiIndexStatus>>(() => {
+                const seeds = store.indexBuildSeeds();
+
+                return Object.fromEntries(
+                    store
+                        .indexes()
+                        .map((index) => [
+                            index.name,
+                            index.name in seeds
+                                ? DOT_AI_INDEX_STATUS.BUILDING
+                                : DOT_AI_INDEX_STATUS.READY
+                        ])
+                );
+            })
         })),
         withMethods((store) => {
             const embeddingsService = inject(DotAiEmbeddingsService);
@@ -61,12 +88,15 @@ export function withAiIndexes() {
 
             const applyIndexes = (indexes: DotAiIndex[]) => {
                 const now = Date.now();
+                const listed = new Set(indexes.map((index) => index.name));
 
-                // Drop seeds that have outlived their welcome before anything derives from them,
-                // so an abandoned build stops both the BUILDING badge and the poll.
+                // A seed survives while the server still has not listed its index and the wait
+                // is within the grace period, or once it is listed — from then on
+                // `deriveIndexStatuses` decides, off the fragment delta.
                 const liveSeeds = Object.fromEntries(
                     Object.entries(store.indexBuildSeeds()).filter(
-                        ([, startedAt]) => now - startedAt < BUILD_SEED_TTL_MS
+                        ([name, requestedAt]) =>
+                            listed.has(name) || now - requestedAt < PENDING_SEED_TTL_MS
                     )
                 );
 
@@ -75,8 +105,6 @@ export function withAiIndexes() {
                 // The server's list plus a placeholder for each seeded build it has not caught
                 // up with, so a new index is in the table from the moment it is requested.
                 const merged = withPendingIndexes(indexes, seeds);
-                const offered = toIndexOptions(merged).map((option) => option.value);
-
                 const statuses = deriveIndexStatuses(merged, store.indexFragmentSnapshot(), seeds);
 
                 // An index that has settled is no longer a candidate for the next poll.
@@ -86,9 +114,13 @@ export function withAiIndexes() {
                     )
                 );
 
+                // Retrieval targets, for the picker's fallback below. Read off `merged` rather
+                // than through `toIndexOptions`, which would build and discard a label per
+                // index for what is one membership test.
+                const offered = toRetrievalIndexes(merged).map((index) => index.name);
+
                 patchState(store, {
                     indexes: merged,
-                    indexStatuses: statuses,
                     indexBuildSeeds: stillBuilding,
                     // Snapshotted from the server's own response, never from `merged`: a
                     // placeholder recorded at zero fragments would look like a settled index on
@@ -146,22 +178,13 @@ export function withAiIndexes() {
                  * from a delta that has not appeared yet.
                  */
                 markIndexBuilding(indexName: string): void {
-                    const listed = store.indexes().some((index) => index.name === indexName);
-
                     patchState(store, {
                         indexBuildSeeds: { ...store.indexBuildSeeds(), [indexName]: Date.now() },
                         // Stand the row up now rather than waiting for the next poll — the build
                         // has been accepted, so the index exists whether or not `indexCount`
-                        // knows about it yet.
-                        ...(listed
-                            ? {}
-                            : {
-                                  indexes: withPendingIndexes(store.indexes(), new Set([indexName]))
-                              }),
-                        indexStatuses: {
-                            ...store.indexStatuses(),
-                            [indexName]: DOT_AI_INDEX_STATUS.BUILDING
-                        }
+                        // knows about it yet. `withPendingIndexes` is a no-op, same array
+                        // reference included, when the list already has it.
+                        indexes: withPendingIndexes(store.indexes(), new Set([indexName]))
                     });
                 }
             };
@@ -193,11 +216,7 @@ export function withAiIndexes() {
         })),
         withHooks({
             onInit(store) {
-                store.pollIndexes(
-                    computed(() =>
-                        Object.values(store.indexStatuses()).includes(DOT_AI_INDEX_STATUS.BUILDING)
-                    )
-                );
+                store.pollIndexes(computed(() => Object.keys(store.indexBuildSeeds()).length > 0));
             }
         })
     );
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts
index c493eb3834a6..e43be3b89be7 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-chat/dot-ai-chat.component.ts
@@ -7,10 +7,11 @@ import { ButtonModule } from 'primeng/button';
 import { DotAgentThinkingComponent, DotAiPromptInputComponent } from '@dotcms/ai-ui';
 import { DotMessageService } from '@dotcms/data-access';
 import { DOT_AI_ANSWER_STATE } from '@dotcms/dotcms-models';
-import { DotEmptyContainerComponent, DotMessagePipe, PrincipalConfiguration } from '@dotcms/ui';
+import { DotEmptyContainerComponent, DotMessagePipe } from '@dotcms/ui';
 
 import { DotAiWorkspaceComponent } from '../../components/dot-ai-workspace/dot-ai-workspace.component';
 import { DotAiStore } from '../../store/dot-ai.store';
+import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
 
 /**
  * Chat tab: ask a question of the indexed content and watch the answer stream in.
@@ -48,12 +49,11 @@ export default class DotAiChatComponent {
      * The subtitle deliberately does not promise sources: only the non-streaming mode returns
      * them, and this tab streams.
      */
-    protected readonly emptyConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.chat.empty.title'),
-        subtitle: this.#messageService.get('dotai.chat.empty.sub'),
-        icon: 'forum',
-        iconStyle: 'material-symbols-rounded'
-    };
+    protected readonly emptyConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.chat.empty.title',
+        subtitle: 'dotai.chat.empty.sub',
+        icon: 'forum'
+    });
 
     constructor() {
         // FR-015: leaving Chat mid-answer must cancel it. The store's own onDestroy cannot do
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
index 12af81d07786..2954b106f2aa 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
@@ -8,12 +8,12 @@ import {
     DotCopyButtonComponent,
     DotEmptyContainerComponent,
     DotMessagePipe,
-    DotSearchInputComponent,
-    PrincipalConfiguration
+    DotSearchInputComponent
 } from '@dotcms/ui';
 
 import { DotAiStore } from '../../store/dot-ai.store';
 import { DOT_AI_CONFIG_SOURCE, toConfigRows } from '../../utils/dot-ai-config.utils';
+import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
 
 /**
  * Config Values: every resolved dotAI setting and where it came from.
@@ -42,18 +42,16 @@ export default class DotAiConfigValuesComponent {
     protected readonly sources = DOT_AI_CONFIG_SOURCE;
     protected readonly $filter = signal('');
 
-    protected readonly redactionFailedConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.config.redaction-failed.title'),
-        subtitle: this.#messageService.get('dotai.config.redaction-failed.sub'),
-        icon: 'visibility_off',
-        iconStyle: 'material-symbols-rounded'
-    };
-
-    protected readonly noMatchesConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.config.empty'),
-        icon: 'filter_alt_off',
-        iconStyle: 'material-symbols-rounded'
-    };
+    protected readonly redactionFailedConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.config.redaction-failed.title',
+        subtitle: 'dotai.config.redaction-failed.sub',
+        icon: 'visibility_off'
+    });
+
+    protected readonly noMatchesConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.config.empty',
+        icon: 'filter_alt_off'
+    });
 
     /**
      * Which site's configuration is on screen, and whether it is actually that site's.
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
index fa2320319cba..8d2977b6041a 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
@@ -24,20 +24,15 @@
         </ng-template>
     </p-toolbar>
 
-    <!-- Only a successful build reaches the tab. The two outcomes that need the query fixed —
-         nothing matched, and a query the server rejected — stay inside the dialog, next to the
-         field that produced them. -->
-    @if (store.indexBuildNotice(); as notice) {
-        @if (notice.kind === 'built') {
-            <p-message
-                class="block shrink-0 px-4 pb-2"
-                severity="success"
-                [closable]="true"
-                (onClose)="store.dismissBuildNotice()"
-                data-testid="dotai-embeddings-build-notice">
-                {{ 'dotai.embeddings.build.ok' | dm: [notice.detail ?? '', notice.indexName] }}
-            </p-message>
-        }
+    @if ($builtNotice(); as notice) {
+        <p-message
+            class="block shrink-0 px-4 pb-2"
+            severity="success"
+            [closable]="true"
+            (onClose)="store.dismissBuildNotice()"
+            data-testid="dotai-embeddings-build-notice">
+            {{ 'dotai.embeddings.build.ok' | dm: [notice.detail ?? '', notice.indexName] }}
+        </p-message>
     }
 
     <div class="min-h-0 flex-1 overflow-hidden">
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index 34e3e7481207..288396609c92 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -21,6 +21,7 @@ import {
 import { DotAiIndexCreateComponent } from './dot-ai-index-create/dot-ai-index-create.component';
 
 import { DotAiStore } from '../../store/dot-ai.store';
+import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
 
 /**
  * Button treatment shared by both confirmations: a primary accept and an outlined cancel.
@@ -73,6 +74,19 @@ export default class DotAiEmbeddingsComponent {
 
     protected readonly statuses = DOT_AI_INDEX_STATUS;
 
+    /**
+     * The build outcome this tab owns.
+     *
+     * Only a success reaches here. The two outcomes that need the query fixed — nothing
+     * matched, and a query the server rejected — stay inside the create dialog, next to the
+     * field that produced them.
+     */
+    protected readonly $builtNotice = computed(() => {
+        const notice = this.store.indexBuildNotice();
+
+        return notice?.kind === 'built' ? notice : null;
+    });
+
     /**
      * Two different empty states behind one slot: an instance with no indexes at all, and a
      * filter that matched none of the ones there are. Telling someone to create their first
@@ -80,25 +94,22 @@ export default class DotAiEmbeddingsComponent {
      */
     protected readonly $emptyConfig = computed<PrincipalConfiguration>(() =>
         this.store.indexFilter().trim()
-            ? {
-                  title: this.#messageService.get('dotai.embeddings.no-matches'),
-                  icon: 'filter_alt_off',
-                  iconStyle: 'material-symbols-rounded'
-              }
-            : {
-                  title: this.#messageService.get('dotai.embeddings.empty.title'),
-                  subtitle: this.#messageService.get('dotai.embeddings.empty.sub'),
-                  icon: 'database',
-                  iconStyle: 'material-symbols-rounded'
-              }
+            ? toEmptyStateConfig(this.#messageService, {
+                  title: 'dotai.embeddings.no-matches',
+                  icon: 'filter_alt_off'
+              })
+            : toEmptyStateConfig(this.#messageService, {
+                  title: 'dotai.embeddings.empty.title',
+                  subtitle: 'dotai.embeddings.empty.sub',
+                  icon: 'database'
+              })
     );
 
-    protected readonly forbiddenConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.index.admin-required'),
-        subtitle: this.#messageService.get('dotai.index.admin-required.sub'),
-        icon: 'lock',
-        iconStyle: 'material-symbols-rounded'
-    };
+    protected readonly forbiddenConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.index.admin-required',
+        subtitle: 'dotai.index.admin-required.sub',
+        icon: 'lock'
+    });
 
     /** Fixed layout plus full height keeps the empty state from collapsing the table. */
     protected readonly tablePt = {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
index 2889cf4634e5..5ec75f75b27c 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
@@ -113,7 +113,7 @@
             type="submit"
             [severity]="$mode() === 'delete' ? 'danger' : 'primary'"
             [disabled]="!$canSubmit()"
-            [loading]="store.indexBuildInFlight()"
+            [loading]="$submitting()"
             [label]="$submitLabel() | dm"
             data-testid="dotai-index-create-submit" />
     </div>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
index f04a1fa9598f..f49adf3a0273 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
@@ -23,7 +23,6 @@ describe('DotAiIndexCreateComponent', () => {
     let store: {
         indexes: ReturnType<typeof signal<DotAiIndex[]>>;
         indexBuildNotice: ReturnType<typeof signal<DotAiIndexBuildNotice | null>>;
-        indexBuildInFlight: ReturnType<typeof signal<boolean>>;
         buildIndex: ReturnType<typeof vi.fn>;
         deleteFromIndex: ReturnType<typeof vi.fn>;
         dismissBuildNotice: ReturnType<typeof vi.fn>;
@@ -48,7 +47,6 @@ describe('DotAiIndexCreateComponent', () => {
                 }
             ]),
             indexBuildNotice: signal<DotAiIndexBuildNotice | null>(null),
-            indexBuildInFlight: signal(false),
             buildIndex: vi.fn(),
             deleteFromIndex: vi.fn(),
             dismissBuildNotice: vi.fn()
@@ -159,13 +157,27 @@ describe('DotAiIndexCreateComponent', () => {
 
     it('should block a second submit while a build is outstanding', () => {
         fillValidForm();
-        store.indexBuildInFlight.set(true);
+        clickButton('dotai-index-create-submit');
         spectator.detectChanges();
 
         expect(
             spectator.query(byTestId('dotai-index-create-submit'))?.querySelector('button')
                 ?.disabled
         ).toBe(true);
+        expect(store.buildIndex).toHaveBeenCalledTimes(1);
+    });
+
+    it('should let the form be submitted again once the build fails', () => {
+        fillValidForm();
+        clickButton('dotai-index-create-submit');
+
+        store.indexBuildNotice.set({ kind: 'failed', indexName: 'blogs', detail: 'bad query' });
+        spectator.detectChanges();
+
+        expect(
+            spectator.query(byTestId('dotai-index-create-submit'))?.querySelector('button')
+                ?.disabled
+        ).toBe(false);
     });
 
     it('should reject a name an existing index already uses', () => {
@@ -178,10 +190,26 @@ describe('DotAiIndexCreateComponent', () => {
     it('should close with nothing on cancel, so the caller does no work', () => {
         clickButton('dotai-index-create-cancel');
 
-        expect(store.dismissBuildNotice).toHaveBeenCalled();
         expect(dialogRef.close).toHaveBeenCalledWith();
     });
 
+    it('should clear an unshown outcome on teardown, however it was dismissed', () => {
+        // PrimeNG's own header X and Escape call DynamicDialogRef.close directly rather than
+        // `cancel()`, so a failure dismissed that way would be left set with nothing rendering
+        // it — the tab shows only `built`, and this dialog is gone.
+        store.indexBuildNotice.set({ kind: 'failed', indexName: 'blogs' });
+        spectator.fixture.destroy();
+
+        expect(store.dismissBuildNotice).toHaveBeenCalled();
+    });
+
+    it('should leave a success standing for the tab behind it', () => {
+        store.indexBuildNotice.set({ kind: 'built', indexName: 'blogs', detail: '12' });
+        spectator.fixture.destroy();
+
+        expect(store.dismissBuildNotice).not.toHaveBeenCalled();
+    });
+
     it('should associate the mode heading with the segmented control', () => {
         const group = spectator.query('[role="group"]');
 
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
index 642d3e896fc6..ec6835e26bc7 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
@@ -1,4 +1,4 @@
-import { Component, computed, effect, inject, signal, untracked } from '@angular/core';
+import { Component, computed, DestroyRef, effect, inject, signal, untracked } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { ButtonModule } from 'primeng/button';
@@ -12,7 +12,7 @@ import { DotMessagePipe } from '@dotcms/ui';
 
 import { DotAiStore } from '../../../store/dot-ai.store';
 
-export type DotAiIndexCreateMode = 'add' | 'delete';
+type DotAiIndexCreateMode = 'add' | 'delete';
 
 /**
  * The server stores whatever it is given — `bad name with spaces` is accepted verbatim, and
@@ -28,12 +28,12 @@ const INDEX_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
  * submit label flips with the toggle so the destructive mode never hides behind a neutral
  * word (FR-030) — the legacy screen did the same remap.
  *
- * Unusually for this codebase, the dialog calls the store itself rather than closing with a
- * form value for the list component to submit. It has to: a build is the one action here whose
- * *failure* is a correction to the form — a malformed Lucene query — and resolving the dialog
- * first threw that message onto the tab behind a modal that had already taken the query with
- * it. Owning the submit is what lets the query survive its own error. The store is still data
- * only; nothing here is dispatched from it.
+ * The dialog calls the store itself rather than closing with a form value for the list
+ * component to submit. It has to: a build is the one action here whose *failure* is a
+ * correction to the form — a malformed Lucene query — and resolving the dialog first threw
+ * that message onto the tab behind a modal that had already taken the query with it. Owning
+ * the submit is what lets the query survive its own error. See the documented exception under
+ * CRUD Patterns in `libs/portlets/CLAUDE.md`.
  */
 @Component({
     selector: 'dot-ai-index-create',
@@ -53,6 +53,12 @@ export class DotAiIndexCreateComponent {
 
     protected readonly store = inject(DotAiStore);
 
+    /**
+     * A build is outstanding. Local rather than store state: it is this dialog's submit button
+     * that it disables, and nothing outside this component ever reads it.
+     */
+    protected readonly $submitting = signal(false);
+
     protected readonly $mode = signal<DotAiIndexCreateMode>('add');
     protected readonly $indexName = signal('');
     protected readonly $query = signal('');
@@ -84,11 +90,31 @@ export class DotAiIndexCreateComponent {
     });
 
     constructor() {
-        // A finished build is the only thing that dismisses this dialog. The success message is
-        // left standing on the tab behind, next to the row it just created.
+        // A finished build is the only thing that dismisses this dialog; anything else is an
+        // outcome the form still has to show. The success message is left standing on the tab
+        // behind, next to the row it just created.
         effect(() => {
-            if (this.store.indexBuildNotice()?.kind === 'built') {
-                untracked(() => this.#dialogRef.close());
+            const notice = this.store.indexBuildNotice();
+
+            if (!notice) {
+                return;
+            }
+
+            untracked(() => {
+                this.$submitting.set(false);
+
+                if (notice.kind === 'built') {
+                    this.#dialogRef.close();
+                }
+            });
+        });
+
+        // On teardown, not in `cancel()`: PrimeNG's own header X and the Escape key call
+        // `DynamicDialogRef.close` directly, so a notice dismissed that way would be left set
+        // with nothing rendering it — the tab shows only `built`, and this dialog is gone.
+        inject(DestroyRef).onDestroy(() => {
+            if (this.store.indexBuildNotice()?.kind !== 'built') {
+                this.store.dismissBuildNotice();
             }
         });
     }
@@ -118,7 +144,7 @@ export class DotAiIndexCreateComponent {
             !!this.$indexName().trim() &&
             !!this.$query().trim() &&
             !this.$nameError() &&
-            !this.store.indexBuildInFlight()
+            !this.$submitting()
     );
 
     protected submit(): void {
@@ -138,6 +164,7 @@ export class DotAiIndexCreateComponent {
             return;
         }
 
+        this.$submitting.set(true);
         this.store.buildIndex({
             indexName,
             query,
@@ -150,7 +177,6 @@ export class DotAiIndexCreateComponent {
     }
 
     protected cancel(): void {
-        this.store.dismissBuildNotice();
         this.#dialogRef.close();
     }
 }
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts
index a3e63e599661..ef472fb1d730 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-image/dot-ai-image.component.ts
@@ -11,9 +11,10 @@ import { TooltipModule } from 'primeng/tooltip';
 import { DotAiPromptInputComponent } from '@dotcms/ai-ui';
 import { DotMessageService } from '@dotcms/data-access';
 import { DotAIImageOrientation } from '@dotcms/dotcms-models';
-import { DotEmptyContainerComponent, DotMessagePipe, PrincipalConfiguration } from '@dotcms/ui';
+import { DotEmptyContainerComponent, DotMessagePipe } from '@dotcms/ui';
 
 import { DotAiStore } from '../../store/dot-ai.store';
+import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
 
 /**
  * Image tab: describe an image, generate it, then decide what to do with it.
@@ -44,12 +45,11 @@ export default class DotAiImageComponent {
 
     readonly #messageService = inject(DotMessageService);
 
-    protected readonly emptyConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.image.empty.title'),
-        subtitle: this.#messageService.get('dotai.image.empty.sub'),
-        icon: 'image',
-        iconStyle: 'material-symbols-rounded'
-    };
+    protected readonly emptyConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.image.empty.title',
+        subtitle: 'dotai.image.empty.sub',
+        icon: 'image'
+    });
 
     protected readonly $prompt = signal('');
 
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts
index 8d1f1ce3ab77..d8283bf8f202 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-search/dot-ai-search.component.ts
@@ -18,6 +18,7 @@ import {
 import { DotAiWorkspaceComponent } from '../../components/dot-ai-workspace/dot-ai-workspace.component';
 import { DotAiStore } from '../../store/dot-ai.store';
 import { toClosenessPercent } from '../../utils/dot-ai-distance.utils';
+import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
 
 /**
  * Search tab: a hero query field over a ranked result list, with the shared retrieval-settings
@@ -49,27 +50,25 @@ export default class DotAiSearchComponent {
 
     readonly #messageService = inject(DotMessageService);
 
-    /** Resolved strings rather than keys: `dot-empty-container` renders `configuration` as-is. */
-    protected readonly firstRunConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.search.first-run.title'),
-        subtitle: this.#messageService.get('dotai.search.first-run.sub'),
-        icon: 'search',
-        iconStyle: 'material-symbols-rounded'
-    };
+    protected readonly firstRunConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.search.first-run.title',
+        subtitle: 'dotai.search.first-run.sub',
+        icon: 'search'
+    });
 
-    protected readonly noResultsConfig: PrincipalConfiguration = {
-        title: this.#messageService.get('dotai.search.no-results.title'),
-        subtitle: this.#messageService.get('dotai.search.no-results.sub'),
-        icon: 'search_off',
-        iconStyle: 'material-symbols-rounded'
-    };
+    protected readonly noResultsConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.search.no-results.title',
+        subtitle: 'dotai.search.no-results.sub',
+        icon: 'search_off'
+    });
 
     /** The only one that has to be computed — the subtitle is the index name from the server. */
     protected readonly $missingIndexConfig = computed<PrincipalConfiguration>(() => ({
-        title: this.#messageService.get('dotai.search.index-missing'),
-        subtitle: this.store.searchMissingIndex() ?? '',
-        icon: 'database_off',
-        iconStyle: 'material-symbols-rounded'
+        ...toEmptyStateConfig(this.#messageService, {
+            title: 'dotai.search.index-missing',
+            icon: 'database_off'
+        }),
+        subtitle: this.store.searchMissingIndex() ?? ''
     }));
 
     /**
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-empty-state.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-empty-state.utils.ts
new file mode 100644
index 000000000000..b01316850e6d
--- /dev/null
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-empty-state.utils.ts
@@ -0,0 +1,24 @@
+import { DotMessageService } from '@dotcms/data-access';
+import { PrincipalConfiguration } from '@dotcms/ui';
+
+/**
+ * A `dot-empty-container` configuration, with the portlet's conventions filled in.
+ *
+ * Ten of these are built across the five tabs, every one of them repeating the same icon set
+ * and the same `messageService.get` per string. Sibling portlets inline the literal because
+ * they have one or two; at ten, the convention needs somewhere to live so that changing it
+ * does not mean editing five components.
+ *
+ * Takes message keys and resolves them here, so the keys stay visible at the call site.
+ */
+export function toEmptyStateConfig(
+    messageService: DotMessageService,
+    keys: { title: string; subtitle?: string; icon: string }
+): PrincipalConfiguration {
+    return {
+        title: messageService.get(keys.title),
+        ...(keys.subtitle ? { subtitle: messageService.get(keys.subtitle) } : {}),
+        icon: keys.icon,
+        iconStyle: 'material-symbols-rounded'
+    };
+}
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
index cce3abb0e426..3c00930f7363 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
@@ -27,7 +27,7 @@ export function toIndexOptions(indexes: DotAiIndex[]): { label: string; value: s
  * `dot_embeddings`, and `indexCount` does not return it. Standing in for it with a zeroed row
  * is what puts it in the table immediately, rather than leaving the user to reload the page.
  */
-export function toPendingIndex(name: string): DotAiIndex {
+function toPendingIndex(name: string): DotAiIndex {
     return { name, fragments: 0, contents: 0, tokenTotal: 0, tokensPerChunk: 0, contentTypes: [] };
 }
 

From e99b9aaf74cf1335c62279cf2a1504db5c08b38a Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 14:12:24 -0600
Subject: [PATCH 05/11] fix(dotai): correct the empty, expiry and
 outcome-reporting edges found in review

Five fixes from a review pass over the #37538 follow-ups, each one a case where
the screen said something that was not true.

Config Values blamed the filter for every empty table. `resolvedConfig` is a
computed that always returns an object, so the rows are empty during the initial
async window and after a failed load as well as after a filter that matched
nothing -- and the pane said "No settings match this filter." with the filter box
untouched, on the one screen that exists to be trusted when nothing else works
(FR-048). A failed load now says so; the loading window renders nothing, because
a brief blank pane says less than a wrong sentence does.

The pending-build expiry only ran on success. It lived inside `applyIndexes`,
which a failing request never reaches, so a build started just before the server
went away held its seed forever: the poll ticked every five seconds for the life
of the page, raising an error dialog each time. Pruning now runs wherever the
request lands, the 403 and generic failure branches included.

A build abandoned mid-flight failed into silence. Escape and the header X destroy
the dialog before the outcome arrives, and the tab rendered `built` only -- so a
success was announced and a failure disappeared. The tab now reports every
outcome the dialog is no longer there to render. The handover fires on
`onDestroy` rather than `onClose`, because `close()` emits `onClose` immediately
and only then plays the leave animation: handing over there would flash an
outcome onto the tab for the frames before the dialog's own teardown withdrew it.

`deriveIndexStatuses` was a seed-survival predicate wearing a status function's
name. The status the table reads comes from the `indexStatuses` computed; this
one's output fed a filter, and every READY it derived was discarded. It is now
`stillBuildingSeeds` and returns what it is actually asked for, so there is one
place that decides what "building" means.

`configHostInherited` claimed an inheritance that had not happened. ConfigService
reports the System Host as the resolved host whenever a site has no secrets of
its own, whether or not the System Host had any either, so an instance with
nothing configured anywhere read "inherited from System Host" underneath the
shell's "not configured" banner. Now gated on there being a configuration.

Tests: 256 in the portlet (11 new), 927 in data-access. The two expiry
regressions were confirmed red without the fix.
Verified `openapi.yaml` is unchanged by a full `mvnw compile -pl :dotcms-core`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../features/with-ai-indexes.feature.spec.ts  | 46 +++++++++++++
 .../store/features/with-ai-indexes.feature.ts | 42 ++++++++----
 .../dot-ai-config-values.component.html       | 10 +--
 .../dot-ai-config-values.component.spec.ts    | 57 +++++++++++++++-
 .../dot-ai-config-values.component.ts         | 35 +++++++++-
 .../dot-ai-embeddings.component.html          | 23 ++++++-
 .../dot-ai-embeddings.component.spec.ts       | 50 +++++++++++++-
 .../dot-ai-embeddings.component.ts            | 60 ++++++++++++-----
 .../src/lib/utils/dot-ai-index.utils.spec.ts  | 65 +++++++++++++------
 .../src/lib/utils/dot-ai-index.utils.ts       | 35 +++++-----
 .../dotcms/ai/rest/CompletionsResource.java   | 15 ++++-
 .../WEB-INF/messages/Language.properties      |  2 +
 12 files changed, 360 insertions(+), 80 deletions(-)

diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
index c9f73aea5a0f..7149cedd9426 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
@@ -263,6 +263,52 @@ describe('withAiIndexes', () => {
             expect(spectator.inject(DotAiEmbeddingsService).getIndexes).toHaveBeenCalledTimes(1);
         });
 
+        it('should give up on a build when the refresh itself keeps failing', () => {
+            // The expiry used to live only in applyIndexes, which a failing request never
+            // reaches — so a build started just before the server went away polled every five
+            // seconds for the life of the page, raising an error dialog on each tick.
+            stubIndexes([index({ name: 'existing' })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+            spectator.flushEffects();
+
+            spectator.inject(DotAiEmbeddingsService).getIndexes = vi
+                .fn()
+                .mockReturnValue(throwError(() => new HttpErrorResponse({ status: 500 })));
+
+            vi.advanceTimersByTime(3 * 60 * 1000);
+            spectator.flushEffects();
+
+            expect(store.indexBuildSeeds()).toEqual({});
+
+            const calls = (spectator.inject(DotAiEmbeddingsService).getIndexes as Mock).mock.calls
+                .length;
+            vi.advanceTimersByTime(20000);
+
+            expect(
+                (spectator.inject(DotAiEmbeddingsService).getIndexes as Mock).mock.calls.length
+            ).toBe(calls);
+        });
+
+        it('should stop polling a forbidden endpoint once the build expires', () => {
+            // A 403 mid-build (the admin role revoked in session) took the same path: nothing
+            // pruned the seed, so the poll retried an endpoint it would never be allowed on.
+            stubIndexes([index({ name: 'existing' })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+            spectator.flushEffects();
+
+            spectator.inject(DotAiEmbeddingsService).getIndexes = vi
+                .fn()
+                .mockReturnValue(throwError(() => new HttpErrorResponse({ status: 403 })));
+
+            vi.advanceTimersByTime(3 * 60 * 1000);
+            spectator.flushEffects();
+
+            expect(store.indexesForbidden()).toBe(true);
+            expect(store.indexBuildSeeds()).toEqual({});
+        });
+
         it('should re-fetch until the build settles, then stop', () => {
             stubIndexes([index({ name: 'blogs', fragments: 10 })]);
             store.loadIndexes();
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
index 8ff7e5202893..9aeb3f08c8d4 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
@@ -19,7 +19,7 @@ import { DOT_AI_INDEX_STATUS, DotAiIndex, DotAiIndexStatus } from '@dotcms/dotcm
 
 import { DotAiPortletState } from '../../models/dot-ai-portlet.models';
 import {
-    deriveIndexStatuses,
+    stillBuildingSeeds,
     toIndexOptions,
     toRetrievalIndexes,
     withPendingIndexes
@@ -86,32 +86,41 @@ export function withAiIndexes() {
             const embeddingsService = inject(DotAiEmbeddingsService);
             const httpErrorManager = inject(DotHttpErrorManagerService);
 
-            const applyIndexes = (indexes: DotAiIndex[]) => {
+            /**
+             * The seeds still worth waiting on: listed by the server, or still inside the
+             * grace period.
+             *
+             * Called from the failure paths as well as the success one. The poll runs while
+             * any seed is held, and a `loadIndexes` that keeps failing never reaches
+             * `applyIndexes` — so with the expiry enforced only there, a build started just
+             * before the server went away would poll every five seconds for the life of the
+             * page, raising an error dialog on each tick. Expiry is exactly the answer to
+             * that, and it has to run wherever the request lands.
+             */
+            const liveSeeds = (listed: Set<string>): Record<string, number> => {
                 const now = Date.now();
-                const listed = new Set(indexes.map((index) => index.name));
 
-                // A seed survives while the server still has not listed its index and the wait
-                // is within the grace period, or once it is listed — from then on
-                // `deriveIndexStatuses` decides, off the fragment delta.
-                const liveSeeds = Object.fromEntries(
+                return Object.fromEntries(
                     Object.entries(store.indexBuildSeeds()).filter(
                         ([name, requestedAt]) =>
                             listed.has(name) || now - requestedAt < PENDING_SEED_TTL_MS
                     )
                 );
+            };
 
-                const seeds = new Set(Object.keys(liveSeeds));
+            const applyIndexes = (indexes: DotAiIndex[]) => {
+                const listed = new Set(indexes.map((index) => index.name));
+                const live = liveSeeds(listed);
+                const seeds = new Set(Object.keys(live));
 
                 // The server's list plus a placeholder for each seeded build it has not caught
                 // up with, so a new index is in the table from the moment it is requested.
                 const merged = withPendingIndexes(indexes, seeds);
-                const statuses = deriveIndexStatuses(merged, store.indexFragmentSnapshot(), seeds);
 
                 // An index that has settled is no longer a candidate for the next poll.
+                const building = stillBuildingSeeds(merged, store.indexFragmentSnapshot(), seeds);
                 const stillBuilding = Object.fromEntries(
-                    Object.entries(liveSeeds).filter(
-                        ([name]) => statuses[name] === DOT_AI_INDEX_STATUS.BUILDING
-                    )
+                    Object.entries(live).filter(([name]) => building.has(name))
                 );
 
                 // Retrieval targets, for the picker's fallback below. Read off `merged` rather
@@ -152,15 +161,22 @@ export function withAiIndexes() {
                             embeddingsService.getIndexes().pipe(
                                 tap(applyIndexes),
                                 catchError((error: HttpErrorResponse) => {
+                                    // Nothing was listed, so only the grace period can keep a
+                                    // seed now — which is what stops the poll rather than
+                                    // letting it retry a dead endpoint forever.
+                                    const surviving = liveSeeds(new Set());
+
                                     if (error?.status === 403) {
                                         patchState(store, {
                                             indexesForbidden: true,
-                                            indexes: []
+                                            indexes: [],
+                                            indexBuildSeeds: surviving
                                         });
 
                                         return EMPTY;
                                     }
 
+                                    patchState(store, { indexBuildSeeds: surviving });
                                     httpErrorManager.handle(error);
 
                                     return EMPTY;
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
index 7046403111d8..7ef6f67f438f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.html
@@ -24,14 +24,16 @@
                 [configuration]="redactionFailedConfig"
                 [hideContactUsLink]="true"
                 data-testid="dotai-config-redaction-failed" />
-        } @else if (!$filteredRows().length) {
+        } @else if ($emptyConfig(); as empty) {
             <!-- Same reason as the Embeddings table: a `<td>` is sized by its content, so an
-                 empty state nested in one cannot centre in the pane. -->
+                 empty state nested in one cannot centre in the pane. Which state this is --
+                 no match, or no config to show -- is decided in the component; an empty table
+                 is not one fact. -->
             <dot-empty-container
-                [configuration]="noMatchesConfig"
+                [configuration]="empty"
                 [hideContactUsLink]="true"
                 data-testid="dotai-config-empty" />
-        } @else {
+        } @else if ($filteredRows().length) {
             <p-table
                 [value]="$filteredRows()"
                 [rowHover]="true"
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts
index 8d3f5e0c9ebc..3de4085d5254 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.spec.ts
@@ -30,7 +30,8 @@ describe('DotAiConfigValuesComponent', () => {
     const storeMock = {
         resolvedConfig: vi.fn().mockReturnValue(resolved()),
         redactionFailed: vi.fn().mockReturnValue(false),
-        isConfigured: vi.fn().mockReturnValue(true)
+        isConfigured: vi.fn().mockReturnValue(true),
+        configUnavailable: vi.fn().mockReturnValue(false)
     };
 
     const createComponent = createComponentFactory({
@@ -44,6 +45,7 @@ describe('DotAiConfigValuesComponent', () => {
         vi.clearAllMocks();
         storeMock.resolvedConfig.mockReturnValue(resolved());
         storeMock.redactionFailed.mockReturnValue(false);
+        storeMock.configUnavailable.mockReturnValue(false);
         spectator = createComponent();
     });
 
@@ -84,6 +86,59 @@ describe('DotAiConfigValuesComponent', () => {
         expect(spectator.query(byTestId('dotai-config-table'))).toBeFalsy();
     });
 
+    describe('an empty table', () => {
+        // Three different reasons the rows can be empty, and the screen has to say which.
+        // resolvedConfig is a computed that always returns an object, so "no rows" is the
+        // state during the initial load and after a failed one as well as after a filter
+        // that matched nothing.
+        const empty = (): HTMLElement | null =>
+            spectator.query(byTestId('dotai-config-empty')) as HTMLElement | null;
+
+        it('should blame the filter only when there is a filter', () => {
+            storeMock.resolvedConfig.mockReturnValue(
+                resolved({ settings: {}, providerConfig: null })
+            );
+            spectator = createComponent();
+            spectator.triggerEventHandler(
+                byTestId('dotai-config-filter'),
+                'search',
+                'nothing-matches-this'
+            );
+            spectator.detectChanges();
+
+            expect(empty()).toBeTruthy();
+            expect(spectator.inject(DotMessageService, true).get).toHaveBeenCalledWith(
+                'dotai.config.empty'
+            );
+        });
+
+        it('should say the config could not be loaded rather than blaming an empty filter', () => {
+            // The regression: a failed load left the diagnostic screen telling the user their
+            // filter matched nothing, with the filter box empty.
+            storeMock.resolvedConfig.mockReturnValue(
+                resolved({ settings: {}, providerConfig: null })
+            );
+            storeMock.configUnavailable.mockReturnValue(true);
+            spectator = createComponent();
+
+            expect(empty()).toBeTruthy();
+            expect(spectator.inject(DotMessageService, true).get).toHaveBeenCalledWith(
+                'dotai.config.unavailable.title'
+            );
+        });
+
+        it('should show nothing at all while the config is still loading', () => {
+            // A brief blank pane says less than a wrong sentence does.
+            storeMock.resolvedConfig.mockReturnValue(
+                resolved({ settings: {}, providerConfig: null })
+            );
+            spectator = createComponent();
+
+            expect(empty()).toBeFalsy();
+            expect(spectator.query(byTestId('dotai-config-table'))).toBeFalsy();
+        });
+    });
+
     it('should not offer a provider config view at all', () => {
         // Removed on review: the raw JSON dump was not something the screen needed to carry.
         expect(spectator.query(byTestId('dotai-config-view-provider'))).toBeFalsy();
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
index 2954b106f2aa..8d3b19ade92f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-config-values/dot-ai-config-values.component.ts
@@ -8,7 +8,8 @@ import {
     DotCopyButtonComponent,
     DotEmptyContainerComponent,
     DotMessagePipe,
-    DotSearchInputComponent
+    DotSearchInputComponent,
+    PrincipalConfiguration
 } from '@dotcms/ui';
 
 import { DotAiStore } from '../../store/dot-ai.store';
@@ -48,11 +49,17 @@ export default class DotAiConfigValuesComponent {
         icon: 'visibility_off'
     });
 
-    protected readonly noMatchesConfig = toEmptyStateConfig(this.#messageService, {
+    readonly #noMatchesConfig = toEmptyStateConfig(this.#messageService, {
         title: 'dotai.config.empty',
         icon: 'filter_alt_off'
     });
 
+    readonly #unavailableConfig = toEmptyStateConfig(this.#messageService, {
+        title: 'dotai.config.unavailable.title',
+        subtitle: 'dotai.config.unavailable.sub',
+        icon: 'cloud_off'
+    });
+
     /**
      * Which site's configuration is on screen, and whether it is actually that site's.
      *
@@ -90,6 +97,30 @@ export default class DotAiConfigValuesComponent {
         );
     });
 
+    /**
+     * Which empty state the pane owes the user, or null when it owes none.
+     *
+     * The rows being empty is not one fact but three, and they need different sentences.
+     * `resolvedConfig` is a computed that always returns an object, so the rows are empty
+     * during the initial async window and after a failed load as well as after a filter that
+     * matched nothing -- and blaming the filter in the first two cases is a lie told by the
+     * one screen that exists to be trusted when nothing else works (FR-048).
+     *
+     * Null while the config is still on its way: a brief blank pane says less than a wrong
+     * sentence does.
+     */
+    protected readonly $emptyConfig = computed<PrincipalConfiguration | null>(() => {
+        if (this.$filteredRows().length) {
+            return null;
+        }
+
+        if (this.$filter().trim()) {
+            return this.#noMatchesConfig;
+        }
+
+        return this.store.configUnavailable() ? this.#unavailableConfig : null;
+    });
+
     protected severityFor(source: string): 'info' | 'secondary' {
         return source === DOT_AI_CONFIG_SOURCE.APP_CONFIG ? 'info' : 'secondary';
     }
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
index 8d2977b6041a..8dff6db1eab2 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
@@ -24,14 +24,31 @@
         </ng-template>
     </p-toolbar>
 
-    @if ($builtNotice(); as notice) {
+    <!-- Everything the create dialog is not around to render itself. A build abandoned with
+         Escape while still in flight has nowhere else to report. -->
+    @if ($notice(); as notice) {
         <p-message
             class="block shrink-0 px-4 pb-2"
-            severity="success"
+            [severity]="
+                notice.kind === 'built' ? 'success' : notice.kind === 'empty' ? 'warn' : 'error'
+            "
             [closable]="true"
             (onClose)="store.dismissBuildNotice()"
             data-testid="dotai-embeddings-build-notice">
-            {{ 'dotai.embeddings.build.ok' | dm: [notice.detail ?? '', notice.indexName] }}
+            @switch (notice.kind) {
+                @case ('built') {
+                    {{ 'dotai.embeddings.build.ok' | dm: [notice.detail ?? '', notice.indexName] }}
+                }
+                @case ('empty') {
+                    {{ 'dotai.embeddings.build.empty' | dm: [notice.indexName] }}
+                }
+                @default {
+                    {{
+                        'dotai.embeddings.build.failed'
+                            | dm: [notice.indexName, notice.detail ?? '']
+                    }}
+                }
+            }
         </p-message>
     }
 
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
index a869200ef125..b0ff539be491 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
@@ -30,6 +30,7 @@ const index = (overrides: Partial<DotAiIndex> = {}): DotAiIndex => ({
 describe('DotAiEmbeddingsComponent', () => {
     let spectator: Spectator<DotAiEmbeddingsComponent>;
     let onClose: Subject<unknown>;
+    let onDialogDestroy: Subject<unknown>;
     let dialogService: DialogService;
     let confirmSpy: MockInstance;
 
@@ -69,9 +70,11 @@ describe('DotAiEmbeddingsComponent', () => {
         storeMock.indexesForbidden.mockReturnValue(false);
         storeMock.filteredIndexes.mockReturnValue([index()]);
         onClose = new Subject();
+        onDialogDestroy = new Subject();
+        storeMock.indexBuildNotice.mockReturnValue(null);
         spectator = createComponent();
         dialogService = spectator.inject(DialogService, true);
-        (dialogService.open as Mock).mockReturnValue({ onClose });
+        (dialogService.open as Mock).mockReturnValue({ onClose, onDestroy: onDialogDestroy });
         confirmSpy = vi.spyOn(spectator.inject(ConfirmationService, true), 'confirm');
     });
 
@@ -156,6 +159,51 @@ describe('DotAiEmbeddingsComponent', () => {
             expect(storeMock.dismissBuildNotice).toHaveBeenCalled();
         });
 
+        it('should stay quiet about an outcome the dialog is there to render', () => {
+            // Otherwise the failure appears twice — once in the form holding the query, once
+            // on the tab behind the modal, which is the report nobody could act on.
+            clickButton('dotai-embeddings-new-index');
+            storeMock.indexBuildNotice.mockReturnValue({
+                kind: 'failed',
+                indexName: 'blogs',
+                detail: 'Cannot parse query'
+            });
+            spectator.detectChanges();
+
+            expect(spectator.query(byTestId('dotai-embeddings-build-notice'))).toBeFalsy();
+        });
+
+        it('should report a build abandoned mid-flight once the dialog has gone', () => {
+            // Escape or the header X while the build is still running: the outcome arrives
+            // after the dialog is destroyed, so this tab is the only thing left that can show
+            // it. It used to render `built` only, so a success was announced and a failure
+            // disappeared.
+            clickButton('dotai-embeddings-new-index');
+            onDialogDestroy.next(undefined);
+            storeMock.indexBuildNotice.mockReturnValue({
+                kind: 'failed',
+                indexName: 'blogs',
+                detail: 'Cannot parse query'
+            });
+            spectator.detectChanges();
+
+            expect(spectator.query(byTestId('dotai-embeddings-build-notice'))).toContainText(
+                'dotai.embeddings.build.failed'
+            );
+        });
+
+        it('should hand back only when the dialog is really gone, not when it starts closing', () => {
+            // `close()` fires onClose and only then plays the leave animation, so the dialog --
+            // and the teardown hook that withdraws an outcome it already showed -- is still
+            // up. Handing over there would flash that outcome onto the tab for those frames.
+            clickButton('dotai-embeddings-new-index');
+            onClose.next(undefined);
+            storeMock.indexBuildNotice.mockReturnValue({ kind: 'failed', indexName: 'blogs' });
+            spectator.detectChanges();
+
+            expect(spectator.query(byTestId('dotai-embeddings-build-notice'))).toBeFalsy();
+        });
+
         it('should leave the build to the dialog rather than submitting on close', () => {
             // The dialog owns the submit now: a rejected Lucene query has to be correctable in
             // the form that produced it, not reported here after the modal took the query away.
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index 288396609c92..a2f59db57dc4 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -1,4 +1,4 @@
-import { Component, computed, inject } from '@angular/core';
+import { Component, computed, inject, signal } from '@angular/core';
 
 import { ConfirmationService } from 'primeng/api';
 import { ButtonModule } from 'primeng/button';
@@ -9,6 +9,8 @@ import { TableModule } from 'primeng/table';
 import { TagModule } from 'primeng/tag';
 import { ToolbarModule } from 'primeng/toolbar';
 
+import { take } from 'rxjs/operators';
+
 import { DotMessageService } from '@dotcms/data-access';
 import { DOT_AI_INDEX_STATUS, DotAiIndex } from '@dotcms/dotcms-models';
 import {
@@ -74,16 +76,28 @@ export default class DotAiEmbeddingsComponent {
 
     protected readonly statuses = DOT_AI_INDEX_STATUS;
 
+    /** Whether the create dialog is up, and so is the one rendering build outcomes. */
+    readonly #createDialogOpen = signal(false);
+
     /**
      * The build outcome this tab owns.
      *
-     * Only a success reaches here. The two outcomes that need the query fixed — nothing
-     * matched, and a query the server rejected — stay inside the create dialog, next to the
-     * field that produced them.
+     * While the dialog is up it owns everything the user has to act on — nothing matched, and
+     * a query the server rejected — because those are corrections to a field it is still
+     * holding; only the success reaches here, next to the row it just created.
+     *
+     * Once the dialog has gone, this tab is the only thing left that can report anything, so
+     * it reports all of it. Without that, a build dismissed with Escape or the header X while
+     * still in flight failed into silence: the notice arrived after the dialog was destroyed,
+     * and a success in the same situation was announced while a failure was not.
      */
-    protected readonly $builtNotice = computed(() => {
+    protected readonly $notice = computed(() => {
         const notice = this.store.indexBuildNotice();
 
+        if (!this.#createDialogOpen()) {
+            return notice;
+        }
+
         return notice?.kind === 'built' ? notice : null;
     });
 
@@ -118,22 +132,34 @@ export default class DotAiEmbeddingsComponent {
     };
 
     /**
-     * Opens the build dialog and leaves it to it.
+     * Opens the build dialog and leaves the submit to it.
      *
-     * No `onClose` handling any more: the dialog submits to the store itself so that a rejected
-     * Lucene query can be corrected in the form that produced it, rather than being reported
-     * onto this tab after the modal has closed over the query.
+     * `onClose` carries no form value any more — the dialog submits to the store itself, so a
+     * rejected Lucene query is corrected in the form that produced it rather than reported
+     * onto this tab after the modal has closed over the query. It is still subscribed, for
+     * the one thing this tab needs to know: whether the dialog is still there to do the
+     * reporting.
      */
     protected openCreateDialog(): void {
         this.store.dismissBuildNotice();
-
-        this.#dialogService.open(DotAiIndexCreateComponent, {
-            header: this.#messageService.get('dotai.index.create.header'),
-            width: '700px',
-            closable: true,
-            closeOnEscape: true,
-            draggable: false
-        });
+        this.#createDialogOpen.set(true);
+
+        // `onDestroy`, not `onClose`: `close()` fires `onClose` immediately and only then
+        // plays the leave animation, so the dialog component — and the `DestroyRef` hook that
+        // clears an outcome it has already shown — lives on for the length of it. Handing over
+        // at `onClose` would render that outcome on the tab for those frames before the
+        // dialog's own teardown withdrew it. `onDestroy` fires once, on every close path
+        // (cancel, success, Escape, the header X), after the dialog has let go.
+        this.#dialogService
+            .open(DotAiIndexCreateComponent, {
+                header: this.#messageService.get('dotai.index.create.header'),
+                width: '700px',
+                closable: true,
+                closeOnEscape: true,
+                draggable: false
+            })
+            .onDestroy.pipe(take(1))
+            .subscribe(() => this.#createDialogOpen.set(false));
     }
 
     protected confirmDeleteIndex(index: DotAiIndex): void {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.spec.ts
index 73c84a0affea..60d87a8dc48a 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.spec.ts
@@ -1,10 +1,11 @@
-import { DOT_AI_INDEX_STATUS, DotAiIndex } from '@dotcms/dotcms-models';
+import { DotAiIndex } from '@dotcms/dotcms-models';
 
 import {
     CACHE_INDEX_NAME,
-    deriveIndexStatuses,
+    stillBuildingSeeds,
     toIndexOptions,
-    toRetrievalIndexes
+    toRetrievalIndexes,
+    withPendingIndexes
 } from './dot-ai-index.utils';
 
 const index = (overrides: Partial<DotAiIndex> = {}): DotAiIndex => ({
@@ -46,49 +47,73 @@ describe('dot-ai-index.utils', () => {
         });
     });
 
-    describe('deriveIndexStatuses', () => {
-        it('should report READY when there is no previous snapshot', () => {
-            const result = deriveIndexStatuses([index({ name: 'a' })], {}, new Set());
+    describe('withPendingIndexes', () => {
+        it('should stand in for a seeded build the server has not listed yet', () => {
+            const result = withPendingIndexes([index({ name: 'a' })], new Set(['blogs']));
 
-            expect(result['a']).toBe(DOT_AI_INDEX_STATUS.READY);
+            expect(result.map((i) => i.name)).toEqual(['a', 'blogs']);
+            expect(result.at(-1)?.fragments).toBe(0);
         });
 
-        it('should report BUILDING when a build was just seeded for that index', () => {
-            const result = deriveIndexStatuses([index({ name: 'a' })], {}, new Set(['a']));
+        it('should return the same array when every seed is already listed', () => {
+            // Identity matters: markIndexBuilding patches `indexes` with this, and a fresh
+            // array there would churn every reader of the list on each poll.
+            const indexes = [index({ name: 'blogs' })];
 
-            expect(result['a']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
+            expect(withPendingIndexes(indexes, new Set(['blogs']))).toBe(indexes);
+        });
+    });
+
+    describe('stillBuildingSeeds', () => {
+        it('should keep a seed whose index the server has not listed yet', () => {
+            expect(stillBuildingSeeds([], {}, new Set(['a']))).toEqual(new Set(['a']));
+        });
+
+        it('should keep a seed with no snapshot to compare against', () => {
+            expect(stillBuildingSeeds([index({ name: 'a' })], {}, new Set(['a']))).toEqual(
+                new Set(['a'])
+            );
         });
 
-        it('should keep BUILDING while the fragment count is still moving', () => {
-            const result = deriveIndexStatuses(
+        it('should keep a seed while the fragment count is still moving', () => {
+            const result = stillBuildingSeeds(
                 [index({ name: 'a', fragments: 20 })],
                 { a: 10 },
                 new Set(['a'])
             );
 
-            expect(result['a']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
+            expect(result).toEqual(new Set(['a']));
         });
 
-        it('should settle to READY once the fragment count stops changing', () => {
-            const result = deriveIndexStatuses(
+        it('should drop a seed once the fragment count stops changing', () => {
+            const result = stillBuildingSeeds(
                 [index({ name: 'a', fragments: 10 })],
                 { a: 10 },
                 new Set(['a'])
             );
 
-            expect(result['a']).toBe(DOT_AI_INDEX_STATUS.READY);
+            expect(result.size).toBe(0);
         });
 
-        it('should derive status per index, not portlet-wide', () => {
+        it('should settle each index on its own, not portlet-wide', () => {
             // The legacy portlet flipped every row at once off a single global delta.
-            const result = deriveIndexStatuses(
+            const result = stillBuildingSeeds(
                 [index({ name: 'a', fragments: 20 }), index({ name: 'b', fragments: 5 })],
                 { a: 10, b: 5 },
                 new Set(['a', 'b'])
             );
 
-            expect(result['a']).toBe(DOT_AI_INDEX_STATUS.BUILDING);
-            expect(result['b']).toBe(DOT_AI_INDEX_STATUS.READY);
+            expect(result).toEqual(new Set(['a']));
+        });
+
+        it('should ignore an index nobody seeded a build for', () => {
+            const result = stillBuildingSeeds(
+                [index({ name: 'a', fragments: 20 })],
+                { a: 10 },
+                new Set()
+            );
+
+            expect(result.size).toBe(0);
         });
     });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
index 3c00930f7363..04c39690f9fd 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index.utils.ts
@@ -1,4 +1,4 @@
-import { DOT_AI_INDEX_STATUS, DotAiIndex, DotAiIndexStatus } from '@dotcms/dotcms-models';
+import { DotAiIndex } from '@dotcms/dotcms-models';
 
 /**
  * Internal cache index. It is real and shows in the Embeddings table, but it is not a
@@ -44,31 +44,34 @@ export function withPendingIndexes(indexes: DotAiIndex[], buildSeeds: Set<string
 }
 
 /**
- * Build status per index, derived rather than read: `dot_embeddings` has no status column.
+ * The seeded builds that are still running.
  *
- * An index counts as building while its fragment count is still moving. `buildSeeds` carries
- * the indexes a build was just requested for, which is what lets the very first poll report
- * BUILDING instead of guessing from a delta that has not appeared yet.
+ * `dot_embeddings` has no status column, so this is derived: a build is finished when its
+ * index's fragment count stops moving. The seeds are what let the very first poll report a
+ * build instead of guessing from a delta that has not appeared yet.
  *
  * A seeded index the server has not listed yet has no `previousFragments` entry — the snapshot
- * is taken from the server's own response, never from the placeholder rows — so it stays
- * BUILDING rather than settling to READY off a fragment count of zero that never moves.
+ * is taken from the server's own response, never from the placeholder rows — so it keeps
+ * building rather than settling off a fragment count of zero that never moves.
  *
  * Deliberately per index. The legacy portlet derived one portlet-wide flag, so starting a
  * build on one index made every row claim to be building.
  */
-export function deriveIndexStatuses(
+export function stillBuildingSeeds(
     indexes: DotAiIndex[],
     previousFragments: Record<string, number>,
     buildSeeds: Set<string>
-): Record<string, DotAiIndexStatus> {
-    return indexes.reduce<Record<string, DotAiIndexStatus>>((statuses, index) => {
-        const previous = previousFragments[index.name];
-        const moved = previous !== undefined && previous !== index.fragments;
-        const building = buildSeeds.has(index.name) && (previous === undefined || moved);
+): Set<string> {
+    const fragments = new Map(indexes.map((index) => [index.name, index.fragments]));
 
-        statuses[index.name] = building ? DOT_AI_INDEX_STATUS.BUILDING : DOT_AI_INDEX_STATUS.READY;
+    return new Set(
+        [...buildSeeds].filter((name) => {
+            const current = fragments.get(name);
+            const previous = previousFragments[name];
 
-        return statuses;
-    }, {});
+            // Unlisted, or never snapshotted: there is nothing to compare, so it cannot have
+            // settled. Otherwise it is building exactly while the count is moving.
+            return current === undefined || previous === undefined || previous !== current;
+        })
+    );
 }
diff --git a/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java b/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
index f53366dffefe..3684090df9f8 100644
--- a/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
+++ b/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
@@ -193,17 +193,26 @@ public final Response getConfig(@Context final HttpServletRequest request,
         final AppConfig appConfig = ConfigService.INSTANCE.config(host);
 
         final Map<String, Object> map = new HashMap<>();
+        final String providerConfig = appConfig.getProviderConfig();
+        final boolean configured = StringUtils.isNotBlank(providerConfig);
+
         // The site the configuration is being read for, and whether it actually came from that
         // site. ConfigService falls back to the System Host's secrets when the site has none of
         // its own, so the two hostnames differing is what "inherited" means here. Reported as
         // separate fields rather than one concatenated English string so the client can label
         // and translate it.
+        //
+        // Gated on there being a configuration at all: ConfigService reports the System Host as
+        // the resolved host whenever the site has no secrets of its own, whether or not the
+        // System Host had any either. Without this, an instance where nothing is configured
+        // anywhere claims to have inherited settings it never found.
         final String requestedHost = host.getHostname();
         map.put(AiKeys.CONFIG_HOST, requestedHost);
-        map.put(AiKeys.CONFIG_HOST_INHERITED, !requestedHost.equalsIgnoreCase(appConfig.getHost()));
+        map.put(
+                AiKeys.CONFIG_HOST_INHERITED,
+                configured && !requestedHost.equalsIgnoreCase(appConfig.getHost()));
 
-        final String providerConfig = appConfig.getProviderConfig();
-        if (StringUtils.isNotBlank(providerConfig)) {
+        if (configured) {
             map.put(AppKeys.PROVIDER_CONFIG.key, redactCredentials(providerConfig));
         }
 
diff --git a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
index 5b134c34a229..febb8dab1c6f 100644
--- a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
+++ b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
@@ -8767,6 +8767,8 @@ dotai.config.column.key=Key
 dotai.config.column.value=Value
 dotai.config.column.source=Source
 dotai.config.empty=No settings match this filter.
+dotai.config.unavailable.title=Settings could not be loaded
+dotai.config.unavailable.sub=The dotAI configuration request failed. Reload the page to try again.
 dotai.config.redaction-failed.title=Provider configuration could not be shown
 dotai.config.redaction-failed.sub=dotCMS could not safely redact the credentials, so the configuration is withheld. Check the server logs.
 dotai.settings.site=Site

From 2f11bdebc7a0915a68e88ad51433ed1cf32e9f3e Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 14:33:56 -0600
Subject: [PATCH 06/11] feat(dotai): split build from remove, and make every
 index action report (#37543)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Embeddings tab packed two opposite actions into one dialog and none of the
destructive ones said what they had done.

**Split.** "Build an index" only builds. The Mode toggle made the form reshape
under the user — Fields and Velocity template vanished on switching — and put a
destructive action one click from a create action, sharing its submit button.

**Removing content moved onto the index row.** It always targets exactly one
index, yet the index name was a free-text field: a typo removed nothing and a
near-miss hit a different index, both silently. The row's trash icon is now a
menu — Remove content…, Delete index — and the dialog opens titled for the row,
with the index as context rather than an input.

**It explains itself.** Three facts the old delete mode stated nowhere: it
removes embeddings and not content; the query matches content as it is now, so
content that has changed and no longer matches is left behind and archived or
deleted content cannot be reached at all; and unlike building, it is not
limited to live content — `embed()` appends `+live:true` to your query and
`deleteByQuery` appends nothing.

**Every action reports.** Rebuild DB, Delete index and Remove content were
completely silent — three of the four returned a count the store dropped on the
floor. `indexBuildNotice` becomes `indexNotice`, one channel carrying the
operation and its outcome, because where an outcome belongs is decided by the
outcome rather than the action: anything the user has to act on stays in the
dialog holding the field that caused it, everything else is a toast. A removal
that matched nothing is `empty`, not success — the server answers 200 with
`deleted: 0`.

**Toasts, as the rest of the admin does.** The tab no longer carries a standing
banner for a successful build; `dot-locales` and `dot-experiments` host their
own `p-toast` the same way.

Closes #37543

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../src/lib/models/dot-ai-portlet.models.ts   |  33 +++-
 .../with-ai-embeddings.feature.spec.ts        |  76 ++++++--
 .../features/with-ai-embeddings.feature.ts    | 111 ++++++++----
 .../dot-ai-embeddings.component.html          |  51 ++----
 .../dot-ai-embeddings.component.spec.ts       | 135 +++++++++-----
 .../dot-ai-embeddings.component.ts            | 143 ++++++++++++---
 .../dot-ai-index-create.component.html        |  80 +++------
 .../dot-ai-index-create.component.spec.ts     |  68 ++++----
 .../dot-ai-index-create.component.ts          |  66 ++-----
 ...dot-ai-index-remove-content.component.html |  57 ++++++
 ...-ai-index-remove-content.component.spec.ts | 165 ++++++++++++++++++
 .../dot-ai-index-remove-content.component.ts  |  93 ++++++++++
 .../WEB-INF/messages/Language.properties      |  23 ++-
 13 files changed, 804 insertions(+), 297 deletions(-)
 create mode 100644 core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
 create mode 100644 core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
 create mode 100644 core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts

diff --git a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
index 33e0d52961df..13b4de85f360 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
@@ -46,17 +46,32 @@ export const DOT_AI_TABS = [
 export type DotAiTab = (typeof DOT_AI_TABS)[number];
 export type DotAiTabId = DotAiTab['id'];
 
+export const DOT_AI_INDEX_OPERATION = {
+    BUILD: 'build',
+    REMOVE_CONTENT: 'removeContent',
+    DELETE_INDEX: 'deleteIndex',
+    REBUILD_DB: 'rebuildDb'
+} as const;
+
+export type DotAiIndexOperation =
+    (typeof DOT_AI_INDEX_OPERATION)[keyof typeof DOT_AI_INDEX_OPERATION];
+
 /**
- * The outcome of the last index build, surfaced in the tab.
+ * What the last index operation did.
+ *
+ * One channel for all four, because where an outcome belongs is decided by the outcome rather
+ * than the operation: anything the user has to act on goes in the dialog still holding the
+ * field that caused it, everything else is a toast.
  *
- * `empty` is its own case on purpose: the server answers 200 with `totalToEmbed: 0` when the
- * query matches nothing, and an index with no rows does not come back from `indexCount` at
- * all — so without this the build looks like it silently did nothing.
+ * `empty` is its own outcome on purpose. A build whose query matches nothing answers 200 with
+ * `totalToEmbed: 0`, and the index it makes never comes back from `indexCount`; a removal whose
+ * query matches nothing answers 200 with `deleted: 0`. Both are a query to fix, not a success.
  */
-export interface DotAiIndexBuildNotice {
-    kind: 'built' | 'empty' | 'failed';
+export interface DotAiIndexNotice {
+    operation: DotAiIndexOperation;
+    outcome: 'ok' | 'empty' | 'failed';
     indexName: string;
-    /** Rows embedded, for `built`; the server's reason, for `failed`. */
+    /** The count, for `ok`; the server's reason, for `failed`. */
     detail?: string;
 }
 
@@ -157,7 +172,7 @@ export interface DotAiPortletState {
 
     // embeddings screen (client-side filters — the whole dataset arrives in one response)
     indexFilter: string;
-    indexBuildNotice: DotAiIndexBuildNotice | null;
+    indexNotice: DotAiIndexNotice | null;
 
     // image
     image: DotAiGeneratedImage | null;
@@ -231,7 +246,7 @@ export const DOT_AI_INITIAL_STATE: DotAiPortletState = {
     chatStreaming: false,
 
     indexFilter: '',
-    indexBuildNotice: null,
+    indexNotice: null,
 
     image: null,
     imageGenerating: false,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
index 7ec62aa7d021..3ed99340ac82 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
@@ -11,7 +11,11 @@ import { DotAiEmbeddingsBuildResult, DotAiIndex } from '@dotcms/dotcms-models';
 import { withAiEmbeddings } from './with-ai-embeddings.feature';
 import { withAiIndexes } from './with-ai-indexes.feature';
 
-import { DOT_AI_INITIAL_STATE, DotAiPortletState } from '../../models/dot-ai-portlet.models';
+import {
+    DOT_AI_INDEX_OPERATION,
+    DOT_AI_INITIAL_STATE,
+    DotAiPortletState
+} from '../../models/dot-ai-portlet.models';
 
 const index = (overrides: Partial<DotAiIndex> = {}): DotAiIndex => ({
     name: 'blogs',
@@ -95,8 +99,9 @@ describe('withAiEmbeddings', () => {
 
             store.buildIndex({ indexName: 'blogs', query: '+++[' });
 
-            expect(store.indexBuildNotice()).toEqual({
-                kind: 'failed',
+            expect(store.indexNotice()).toEqual({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                outcome: 'failed',
                 indexName: 'blogs',
                 detail: 'Index -1 out of bounds for length 0'
             });
@@ -114,7 +119,11 @@ describe('withAiEmbeddings', () => {
 
             store.buildIndex({ indexName: 'blogs', query: '+contentType:NoSuchType' });
 
-            expect(store.indexBuildNotice()).toEqual({ kind: 'empty', indexName: 'blogs' });
+            expect(store.indexNotice()).toEqual({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                outcome: 'empty',
+                indexName: 'blogs'
+            });
         });
 
         it('should report how much was embedded on success', () => {
@@ -126,23 +135,53 @@ describe('withAiEmbeddings', () => {
 
             store.buildIndex({ indexName: 'blogs', query: '+contentType:Blog' });
 
-            expect(store.indexBuildNotice()).toEqual({
-                kind: 'built',
+            expect(store.indexNotice()).toEqual({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                outcome: 'ok',
                 indexName: 'blogs',
                 detail: '6'
             });
         });
     });
 
-    describe('deleteFromIndex', () => {
+    describe('removeFromIndex', () => {
         it('should send the query as a deletion criterion, not as content to embed', () => {
             service.deleteFromIndex = vi.fn().mockReturnValue(of(3));
 
-            store.deleteFromIndex({ indexName: 'blogs', query: '+contentType:Blog' });
+            store.removeFromIndex({ indexName: 'blogs', query: '+contentType:Blog' });
 
             expect(service.deleteFromIndex).toHaveBeenCalledWith('blogs', '+contentType:Blog');
             expect(service.getIndexes).toHaveBeenCalled();
         });
+
+        it('should report how much it removed', () => {
+            // The count came back from the server and was dropped on the floor, so a removal
+            // confirmed and then said nothing at all.
+            service.deleteFromIndex = vi.fn().mockReturnValue(of(3));
+
+            store.removeFromIndex({ indexName: 'blogs', query: '+contentType:Blog' });
+
+            expect(store.indexNotice()).toEqual({
+                operation: DOT_AI_INDEX_OPERATION.REMOVE_CONTENT,
+                outcome: 'ok',
+                indexName: 'blogs',
+                detail: '3'
+            });
+        });
+
+        it('should flag a removal that matched nothing rather than looking successful', () => {
+            // The server answers 200 with `deleted: 0` when the query matches nothing.
+            service.deleteFromIndex = vi.fn().mockReturnValue(of(0));
+
+            store.removeFromIndex({ indexName: 'blogs', query: '+contentType:NoSuchType' });
+
+            expect(store.indexNotice()).toEqual({
+                operation: DOT_AI_INDEX_OPERATION.REMOVE_CONTENT,
+                outcome: 'empty',
+                indexName: 'blogs',
+                detail: '0'
+            });
+        });
     });
 
     describe('deleteIndex (FR-034)', () => {
@@ -173,6 +212,11 @@ describe('withAiEmbeddings', () => {
             store.rebuildEmbeddingsDb();
 
             expect(service.rebuildEmbeddingsDb).toHaveBeenCalled();
+            expect(store.indexNotice()).toEqual({
+                operation: DOT_AI_INDEX_OPERATION.REBUILD_DB,
+                outcome: 'ok',
+                indexName: ''
+            });
             expect(service.getIndexes).toHaveBeenCalled();
         });
 
@@ -202,14 +246,24 @@ describe('withAiEmbeddings', () => {
             expect(spectator.inject(DotHttpErrorManagerService).handle).not.toHaveBeenCalled();
         });
 
-        it('should still route other failures through the error manager', () => {
-            const error = new HttpErrorResponse({ status: 500 });
+        it("should report other failures in the portlet's own words", () => {
+            // Not through DotHttpErrorManagerService: it renders these as "Unknown Error" over
+            // a raw Java message and loses which operation and index it was about.
+            const error = new HttpErrorResponse({
+                status: 500,
+                error: { message: 'relation does not exist' }
+            });
             service.rebuildEmbeddingsDb = vi.fn().mockReturnValue(throwError(() => error));
 
             store.rebuildEmbeddingsDb();
 
             expect(store.indexesForbidden()).toBe(false);
-            expect(spectator.inject(DotHttpErrorManagerService).handle).toHaveBeenCalledWith(error);
+            expect(store.indexNotice()).toEqual({
+                operation: DOT_AI_INDEX_OPERATION.REBUILD_DB,
+                outcome: 'failed',
+                indexName: '',
+                detail: 'relation does not exist'
+            });
         });
     });
 
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
index 2ce7eeba91cb..6f4086b84049 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
@@ -7,10 +7,14 @@ import { computed, inject, Signal } from '@angular/core';
 
 import { catchError, exhaustMap, mergeMap, tap } from 'rxjs/operators';
 
-import { DotAiEmbeddingsService, DotHttpErrorManagerService } from '@dotcms/data-access';
+import { DotAiEmbeddingsService } from '@dotcms/data-access';
 import { DotAiEmbeddingsBuildForm, DotAiIndex } from '@dotcms/dotcms-models';
 
-import { DotAiPortletState } from '../../models/dot-ai-portlet.models';
+import {
+    DOT_AI_INDEX_OPERATION,
+    DotAiIndexNotice,
+    DotAiPortletState
+} from '../../models/dot-ai-portlet.models';
 
 /**
  * Index administration: build, add to, delete from, delete, rebuild.
@@ -19,6 +23,10 @@ import { DotAiPortletState } from '../../models/dot-ai-portlet.models';
  * every mutation here refreshes through that one owner, so the Embeddings table and the
  * retrieval picker update together (FR-033).
  *
+ * Every operation records what it did in `indexNotice`. None of them used to: three of the
+ * four returned a count the store dropped on the floor, so a destructive action confirmed and
+ * then said nothing at all.
+ *
  * The `rxMethod` operator per action is load-bearing:
  * - `exhaustMap` for build, rebuild and delete-from-index — each is one submit of one form, so
  *   a double click must not double-fire (FR-035)
@@ -52,7 +60,6 @@ export function withAiEmbeddings() {
         })),
         withMethods((store) => {
             const embeddingsService = inject(DotAiEmbeddingsService);
-            const httpErrorManager = inject(DotHttpErrorManagerService);
 
             /** The server's own words when it has any, so the reason is not thrown away. */
             const extractReason = (error: HttpErrorResponse): string | undefined => {
@@ -65,20 +72,30 @@ export function withAiEmbeddings() {
                 return body?.message ?? body?.error ?? error?.message;
             };
 
+            const notify = (notice: DotAiIndexNotice) => patchState(store, { indexNotice: notice });
+
             /**
-             * A 403 is the same normal non-admin state `loadIndexes` handles — index
-             * operations require CMS_ADMINISTRATOR_ROLE while portlet access does not — so it
-             * must put the tab into its forbidden state rather than throw a dialog over
-             * someone who has done nothing wrong (FR-050).
+             * Records a failed operation and swallows it.
+             *
+             * A 403 is the same normal non-admin state `loadIndexes` handles — index operations
+             * require CMS_ADMINISTRATOR_ROLE while portlet access does not — so it puts the tab
+             * into its forbidden state rather than throwing a dialog over someone who has done
+             * nothing wrong (FR-050). Everything else is reported in the portlet's own words
+             * rather than through the shared handler, which renders a malformed query as
+             * "Unknown Error" with the index name lost (FR-014).
              */
-            const fail = (error: HttpErrorResponse) => {
+            const report = (
+                operation: DotAiIndexNotice['operation'],
+                indexName: string,
+                error: HttpErrorResponse
+            ) => {
                 if (error?.status === 403) {
                     patchState(store, { indexesForbidden: true });
 
                     return EMPTY;
                 }
 
-                httpErrorManager.handle(error);
+                notify({ operation, outcome: 'failed', indexName, detail: extractReason(error) });
 
                 return EMPTY;
             };
@@ -88,13 +105,13 @@ export function withAiEmbeddings() {
                     patchState(store, { indexFilter });
                 },
 
-                dismissBuildNotice(): void {
-                    patchState(store, { indexBuildNotice: null });
+                dismissIndexNotice(): void {
+                    patchState(store, { indexNotice: null });
                 },
 
                 buildIndex: rxMethod<DotAiEmbeddingsBuildForm>(
                     pipe(
-                        tap(() => patchState(store, { indexBuildNotice: null })),
+                        tap(() => patchState(store, { indexNotice: null })),
                         // exhaustMap: a double submit must not build twice.
                         exhaustMap((form) =>
                             embeddingsService.buildIndex(form).pipe(
@@ -104,8 +121,9 @@ export function withAiEmbeddings() {
                                     // saying nothing here reads as "the build did nothing".
                                     if (!result.totalToEmbed) {
                                         patchState(store, {
-                                            indexBuildNotice: {
-                                                kind: 'empty',
+                                            indexNotice: {
+                                                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                                                outcome: 'empty',
                                                 indexName: result.indexName
                                             }
                                         });
@@ -114,8 +132,9 @@ export function withAiEmbeddings() {
                                     }
 
                                     patchState(store, {
-                                        indexBuildNotice: {
-                                            kind: 'built',
+                                        indexNotice: {
+                                            operation: DOT_AI_INDEX_OPERATION.BUILD,
+                                            outcome: 'ok',
                                             indexName: result.indexName,
                                             detail: `${result.totalToEmbed}`
                                         }
@@ -132,28 +151,33 @@ export function withAiEmbeddings() {
                                 // handler renders it as "Unknown Error" over a raw Java message
                                 // with the index name lost. Same reasoning as the chat stream
                                 // (FR-014).
-                                catchError((error: HttpErrorResponse) => {
-                                    patchState(store, {
-                                        indexBuildNotice: {
-                                            kind: 'failed',
-                                            indexName: form.indexName,
-                                            detail: extractReason(error)
-                                        }
-                                    });
-
-                                    return EMPTY;
-                                })
+                                catchError((error: HttpErrorResponse) =>
+                                    report(DOT_AI_INDEX_OPERATION.BUILD, form.indexName, error)
+                                )
                             )
                         )
                     )
                 ),
 
-                deleteFromIndex: rxMethod<{ indexName: string; query: string }>(
+                removeFromIndex: rxMethod<{ indexName: string; query: string }>(
                     pipe(
+                        tap(() => patchState(store, { indexNotice: null })),
                         exhaustMap(({ indexName, query }) =>
                             embeddingsService.deleteFromIndex(indexName, query).pipe(
-                                tap(() => store.loadIndexes()),
-                                catchError(fail)
+                                tap((deleted) => {
+                                    // The server answers 200 with `deleted: 0` when the query
+                                    // matches nothing, so silence here would read as success.
+                                    notify({
+                                        operation: DOT_AI_INDEX_OPERATION.REMOVE_CONTENT,
+                                        outcome: deleted ? 'ok' : 'empty',
+                                        indexName,
+                                        detail: `${deleted}`
+                                    });
+                                    store.loadIndexes();
+                                }),
+                                catchError((error: HttpErrorResponse) =>
+                                    report(DOT_AI_INDEX_OPERATION.REMOVE_CONTENT, indexName, error)
+                                )
                             )
                         )
                     )
@@ -164,8 +188,18 @@ export function withAiEmbeddings() {
                         // mergeMap: per-row, so deleting one index cannot cancel another.
                         mergeMap((indexName) =>
                             embeddingsService.deleteIndex(indexName).pipe(
-                                tap(() => store.loadIndexes()),
-                                catchError(fail)
+                                tap((deleted) => {
+                                    notify({
+                                        operation: DOT_AI_INDEX_OPERATION.DELETE_INDEX,
+                                        outcome: 'ok',
+                                        indexName,
+                                        detail: `${deleted}`
+                                    });
+                                    store.loadIndexes();
+                                }),
+                                catchError((error: HttpErrorResponse) =>
+                                    report(DOT_AI_INDEX_OPERATION.DELETE_INDEX, indexName, error)
+                                )
                             )
                         )
                     )
@@ -175,8 +209,17 @@ export function withAiEmbeddings() {
                     pipe(
                         exhaustMap(() =>
                             embeddingsService.rebuildEmbeddingsDb().pipe(
-                                tap(() => store.loadIndexes()),
-                                catchError(fail)
+                                tap(() => {
+                                    notify({
+                                        operation: DOT_AI_INDEX_OPERATION.REBUILD_DB,
+                                        outcome: 'ok',
+                                        indexName: ''
+                                    });
+                                    store.loadIndexes();
+                                }),
+                                catchError((error: HttpErrorResponse) =>
+                                    report(DOT_AI_INDEX_OPERATION.REBUILD_DB, '', error)
+                                )
                             )
                         )
                     )
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
index 8dff6db1eab2..37e4545554b3 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
@@ -24,34 +24,6 @@
         </ng-template>
     </p-toolbar>
 
-    <!-- Everything the create dialog is not around to render itself. A build abandoned with
-         Escape while still in flight has nowhere else to report. -->
-    @if ($notice(); as notice) {
-        <p-message
-            class="block shrink-0 px-4 pb-2"
-            [severity]="
-                notice.kind === 'built' ? 'success' : notice.kind === 'empty' ? 'warn' : 'error'
-            "
-            [closable]="true"
-            (onClose)="store.dismissBuildNotice()"
-            data-testid="dotai-embeddings-build-notice">
-            @switch (notice.kind) {
-                @case ('built') {
-                    {{ 'dotai.embeddings.build.ok' | dm: [notice.detail ?? '', notice.indexName] }}
-                }
-                @case ('empty') {
-                    {{ 'dotai.embeddings.build.empty' | dm: [notice.indexName] }}
-                }
-                @default {
-                    {{
-                        'dotai.embeddings.build.failed'
-                            | dm: [notice.indexName, notice.detail ?? '']
-                    }}
-                }
-            }
-        </p-message>
-    }
-
     <div class="min-h-0 flex-1 overflow-hidden">
         @if (store.indexesForbidden()) {
             <!-- indexCount requires CMS_ADMINISTRATOR_ROLE while portlet access does not, so
@@ -141,22 +113,22 @@
                                  glyph's own line-height is what was inflating that content.
                                  Without them this measured 28x37.
 
-                                 Secondary, not danger: a red control on every row reads as a
-                                 warning about the row itself. The destructive step is the
-                                 confirm dialog, whose accept button is `p-button-danger`. -->
+                                 A menu rather than a bare trash icon: removing content from
+                                 an index belongs on the index it acts on, not in a mode of
+                                 the build dialog where the name had to be typed. -->
                             <p-button
                                 [text]="true"
                                 [rounded]="true"
                                 severity="secondary"
                                 size="small"
                                 styleClass="w-8 h-8 p-0"
-                                [ariaLabel]="'dotai.embeddings.delete' | dm"
-                                (onClick)="confirmDeleteIndex(index)"
-                                data-testid="dotai-embeddings-delete">
+                                [ariaLabel]="'dotai.embeddings.row.actions' | dm"
+                                (onClick)="openRowMenu(index); rowMenu.toggle($event)"
+                                data-testid="dotai-embeddings-row-actions">
                                 <span
                                     class="material-symbols-outlined text-lg! leading-none!"
                                     aria-hidden="true">
-                                    delete
+                                    more_vert
                                 </span>
                             </p-button>
                         </td>
@@ -167,6 +139,15 @@
     </div>
 </section>
 
+<!-- One menu for the whole table: `openRowMenu` sets which index it is for just before the
+     toggle, so a row does not each carry an overlay of its own. -->
+<p-menu #rowMenu [model]="$rowActions()" [popup]="true" appendTo="body" />
+
+<!-- Every outcome lands here now, which is what the rest of the admin does. The tab used to
+     carry a standing banner for a successful build and say nothing at all for the three
+     destructive actions. -->
+<p-toast [breakpoints]="{ '640px': { width: '90vw' } }" />
+
 <!-- closeAriaLabel: PrimeNG's own hook. Without it the header's X is announced with no
      name at all, on both the delete and the rebuild confirmation. -->
 <p-confirmDialog [draggable]="false" [closeAriaLabel]="'close' | dm" [style]="{ width: '500px' }" />
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
index b0ff539be491..13a46d9a7de7 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
@@ -7,7 +7,7 @@ import {
 import { Subject } from 'rxjs';
 import { Mock, MockInstance, vi } from 'vitest';
 
-import { ConfirmationService } from 'primeng/api';
+import { ConfirmationService, MenuItem, MessageService } from 'primeng/api';
 import { DialogService } from 'primeng/dynamicdialog';
 
 import { DotMessageService } from '@dotcms/data-access';
@@ -15,6 +15,7 @@ import { DotAiIndex } from '@dotcms/dotcms-models';
 
 import DotAiEmbeddingsComponent from './dot-ai-embeddings.component';
 
+import { DOT_AI_INDEX_OPERATION } from '../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../store/dot-ai.store';
 
 const index = (overrides: Partial<DotAiIndex> = {}): DotAiIndex => ({
@@ -33,6 +34,7 @@ describe('DotAiEmbeddingsComponent', () => {
     let onDialogDestroy: Subject<unknown>;
     let dialogService: DialogService;
     let confirmSpy: MockInstance;
+    let toastSpy: MockInstance;
 
     const storeMock = {
         indexes: vi.fn().mockReturnValue([index()]),
@@ -42,9 +44,9 @@ describe('DotAiEmbeddingsComponent', () => {
         isConfigured: vi.fn().mockReturnValue(true),
         setIndexFilter: vi.fn(),
         buildIndex: vi.fn(),
-        indexBuildNotice: vi.fn().mockReturnValue(null),
-        dismissBuildNotice: vi.fn(),
-        deleteFromIndex: vi.fn(),
+        indexNotice: vi.fn().mockReturnValue(null),
+        dismissIndexNotice: vi.fn(),
+        removeFromIndex: vi.fn(),
         deleteIndex: vi.fn(),
         rebuildEmbeddingsDb: vi.fn()
     };
@@ -57,7 +59,10 @@ describe('DotAiEmbeddingsComponent', () => {
         componentProviders: [
             { provide: DotAiStore, useValue: storeMock },
             ConfirmationService,
-            { provide: DialogService, useValue: { open: vi.fn() } }
+            { provide: DialogService, useValue: { open: vi.fn() } },
+            // Real, for the same reason ConfirmationService is: p-toast subscribes to its
+            // messageObserver at construction and a bare mock has none.
+            MessageService
         ],
         // Echoes the key, so assertions on dialog copy read as the key that was asked
         // for rather than `undefined`.
@@ -71,11 +76,12 @@ describe('DotAiEmbeddingsComponent', () => {
         storeMock.filteredIndexes.mockReturnValue([index()]);
         onClose = new Subject();
         onDialogDestroy = new Subject();
-        storeMock.indexBuildNotice.mockReturnValue(null);
+        storeMock.indexNotice.mockReturnValue(null);
         spectator = createComponent();
         dialogService = spectator.inject(DialogService, true);
         (dialogService.open as Mock).mockReturnValue({ onClose, onDestroy: onDialogDestroy });
         confirmSpy = vi.spyOn(spectator.inject(ConfirmationService, true), 'confirm');
+        toastSpy = vi.spyOn(spectator.inject(MessageService, true), 'add');
     });
 
     const clickButton = (testId: string) =>
@@ -83,6 +89,23 @@ describe('DotAiEmbeddingsComponent', () => {
             spectator.query(byTestId(testId))?.querySelector('button') as HTMLButtonElement
         );
 
+    /**
+     * Runs a row-menu item by its label key.
+     *
+     * The overlay itself is PrimeNG's and does not render in a shallow test, so this opens the
+     * menu for the row and invokes the command the component put on the model — which is the
+     * component's half of the contract.
+     */
+    const openRowMenuItem = (labelKey: string) => {
+        clickButton('dotai-embeddings-row-actions');
+        const item = (spectator.component as unknown as { $rowActions: () => MenuItem[] })
+            .$rowActions()
+            .find((action) => action.label === labelKey);
+
+        item?.command?.({} as never);
+        spectator.detectChanges();
+    };
+
     it('should render the table with the index rows', () => {
         expect(spectator.query(byTestId('dotai-embeddings-table'))).toBeTruthy();
         expect(spectator.queryAll(byTestId('dotai-embeddings-row'))).toHaveLength(1);
@@ -105,7 +128,7 @@ describe('DotAiEmbeddingsComponent', () => {
     const acceptConfirmation = () => confirmSpy.mock.calls[0][0].accept();
 
     it('should confirm before deleting an index (FR-031)', () => {
-        clickButton('dotai-embeddings-delete');
+        openRowMenuItem('dotai.embeddings.delete');
 
         expect(confirmSpy).toHaveBeenCalled();
         // Nothing happens until the confirmation is accepted.
@@ -115,7 +138,7 @@ describe('DotAiEmbeddingsComponent', () => {
     it('should delete once the confirmation is accepted (FR-031)', () => {
         // Asserting only the guard proves the dialog opens, not that accepting it does the
         // thing — a broken `accept` wiring would pass that test alone.
-        clickButton('dotai-embeddings-delete');
+        openRowMenuItem('dotai.embeddings.delete');
 
         acceptConfirmation();
 
@@ -156,52 +179,54 @@ describe('DotAiEmbeddingsComponent', () => {
             // with the last one's error.
             clickButton('dotai-embeddings-new-index');
 
-            expect(storeMock.dismissBuildNotice).toHaveBeenCalled();
+            expect(storeMock.dismissIndexNotice).toHaveBeenCalled();
         });
 
         it('should stay quiet about an outcome the dialog is there to render', () => {
             // Otherwise the failure appears twice — once in the form holding the query, once
-            // on the tab behind the modal, which is the report nobody could act on.
+            // as a toast over a modal, which is the report nobody could act on.
             clickButton('dotai-embeddings-new-index');
-            storeMock.indexBuildNotice.mockReturnValue({
-                kind: 'failed',
+            storeMock.indexNotice.mockReturnValue({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                outcome: 'failed',
                 indexName: 'blogs',
                 detail: 'Cannot parse query'
             });
             spectator.detectChanges();
 
-            expect(spectator.query(byTestId('dotai-embeddings-build-notice'))).toBeFalsy();
+            expect(toastSpy).not.toHaveBeenCalled();
         });
 
         it('should report a build abandoned mid-flight once the dialog has gone', () => {
             // Escape or the header X while the build is still running: the outcome arrives
             // after the dialog is destroyed, so this tab is the only thing left that can show
-            // it. It used to render `built` only, so a success was announced and a failure
-            // disappeared.
+            // it. It used to render the success only, so a failure disappeared.
             clickButton('dotai-embeddings-new-index');
             onDialogDestroy.next(undefined);
-            storeMock.indexBuildNotice.mockReturnValue({
-                kind: 'failed',
+            storeMock.indexNotice.mockReturnValue({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                outcome: 'failed',
                 indexName: 'blogs',
                 detail: 'Cannot parse query'
             });
             spectator.detectChanges();
 
-            expect(spectator.query(byTestId('dotai-embeddings-build-notice'))).toContainText(
-                'dotai.embeddings.build.failed'
-            );
+            expect(toastSpy).toHaveBeenCalledWith(expect.objectContaining({ severity: 'error' }));
         });
 
         it('should hand back only when the dialog is really gone, not when it starts closing', () => {
-            // `close()` fires onClose and only then plays the leave animation, so the dialog --
-            // and the teardown hook that withdraws an outcome it already showed -- is still
-            // up. Handing over there would flash that outcome onto the tab for those frames.
+            // `close()` fires onClose and only then plays the leave animation, so the dialog is
+            // still up and still owns what the user has to act on.
             clickButton('dotai-embeddings-new-index');
             onClose.next(undefined);
-            storeMock.indexBuildNotice.mockReturnValue({ kind: 'failed', indexName: 'blogs' });
+            storeMock.indexNotice.mockReturnValue({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                outcome: 'failed',
+                indexName: 'blogs'
+            });
             spectator.detectChanges();
 
-            expect(spectator.query(byTestId('dotai-embeddings-build-notice'))).toBeFalsy();
+            expect(toastSpy).not.toHaveBeenCalled();
         });
 
         it('should leave the build to the dialog rather than submitting on close', () => {
@@ -212,7 +237,7 @@ describe('DotAiEmbeddingsComponent', () => {
             onClose.next(undefined);
 
             expect(storeMock.buildIndex).not.toHaveBeenCalled();
-            expect(storeMock.deleteFromIndex).not.toHaveBeenCalled();
+            expect(storeMock.removeFromIndex).not.toHaveBeenCalled();
         });
     });
 
@@ -220,7 +245,7 @@ describe('DotAiEmbeddingsComponent', () => {
         const config = () => confirmSpy.mock.calls[0][0];
 
         it('should give the delete confirmation a primary accept', () => {
-            clickButton('dotai-embeddings-delete');
+            openRowMenuItem('dotai.embeddings.delete');
 
             // Absent, not 'p-button-primary': the theme defines no such class — `.p-button`
             // carries the primary styling itself — so asking for one renders nothing.
@@ -228,7 +253,7 @@ describe('DotAiEmbeddingsComponent', () => {
         });
 
         it('should give the delete confirmation an outlined cancel', () => {
-            clickButton('dotai-embeddings-delete');
+            openRowMenuItem('dotai.embeddings.delete');
 
             expect(config().rejectButtonStyleClass).toBe('p-button-outlined');
         });
@@ -251,22 +276,48 @@ describe('DotAiEmbeddingsComponent', () => {
         });
     });
 
-    describe('the per-row delete action', () => {
-        const deleteButton = () =>
-            spectator.query(byTestId('dotai-embeddings-delete'))?.querySelector('button');
+    describe('the per-row action menu', () => {
+        const trigger = () =>
+            spectator.query(byTestId('dotai-embeddings-row-actions'))?.querySelector('button');
+
+        it('should offer removing content as well as deleting the index', () => {
+            // Removing content belongs on the index it acts on. It used to be a mode of the
+            // build dialog, where the index name was a free-text field: a typo removed nothing
+            // and a near-miss hit a different index, both silently.
+            clickButton('dotai-embeddings-row-actions');
+
+            const labels = (spectator.component as unknown as { $rowActions: () => MenuItem[] })
+                .$rowActions()
+                .map((action) => action.label);
+
+            expect(labels).toEqual(['dotai.embeddings.remove-content', 'dotai.embeddings.delete']);
+        });
+
+        it('should open the remove-content dialog with the row as its index', () => {
+            openRowMenuItem('dotai.embeddings.remove-content');
+
+            expect(dialogService.open).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.objectContaining({
+                    width: '700px',
+                    closable: true,
+                    closeOnEscape: true,
+                    data: { indexName: 'blogs' }
+                })
+            );
+        });
 
         it('should be secondary, so a red control does not sit on every row', () => {
             // The destructive step is the confirm dialog, whose accept button carries
-            // p-button-danger; the row action only opens it.
-            expect(deleteButton()?.className).toContain('p-button-secondary');
-            expect(deleteButton()?.className).not.toContain('p-button-danger');
+            // p-button-danger; the row action only opens a menu.
+            expect(trigger()?.className).toContain('p-button-secondary');
+            expect(trigger()?.className).not.toContain('p-button-danger');
         });
 
         it('should force its own square rather than rely on the icon-only token', () => {
             // PrimeNG's icon-only width sets a width and leaves the height to padding plus
             // content, so with a full-size glyph the button came out 28x37 — the distortion.
-            // dot-plugins and dot-locales both pin the box in `styleClass` for this reason.
-            const classes = deleteButton()?.className.split(/\s+/) ?? [];
+            const classes = trigger()?.className.split(/\s+/) ?? [];
 
             expect(classes).toContain('w-8');
             expect(classes).toContain('h-8');
@@ -274,22 +325,12 @@ describe('DotAiEmbeddingsComponent', () => {
         });
 
         it('should collapse the glyph line box, which is what inflated the height', () => {
-            // `leading-none` is the other half: without it the glyph's own line-height sets
-            // the button's content height and no width class can square it up.
-            const glyph = deleteButton()?.querySelector('.material-symbols-outlined');
+            const glyph = trigger()?.querySelector('.material-symbols-outlined');
 
             expect(glyph?.className).toContain('leading-none!');
             expect(glyph?.className).toContain('text-lg!');
         });
 
-        it('should be a borderless round action, like the other tables row actions', () => {
-            const classes = deleteButton()?.className.split(/\s+/) ?? [];
-
-            expect(classes).toContain('p-button-text');
-            expect(classes).toContain('p-button-rounded');
-            expect(classes).not.toContain('p-button-outlined');
-        });
-
         it('should keep Rebuild DB a plain outlined button, not a red one', () => {
             // A permanently-red control in the toolbar read as a warning about the screen.
             // The destructive step is the confirm dialog it opens.
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index a2f59db57dc4..7589cbf71c7f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -1,12 +1,13 @@
-import { Component, computed, inject, signal } from '@angular/core';
+import { Component, computed, effect, inject, signal, untracked } from '@angular/core';
 
-import { ConfirmationService } from 'primeng/api';
+import { ConfirmationService, MenuItem, MessageService } from 'primeng/api';
 import { ButtonModule } from 'primeng/button';
 import { ConfirmDialogModule } from 'primeng/confirmdialog';
 import { DialogService } from 'primeng/dynamicdialog';
-import { MessageModule } from 'primeng/message';
+import { MenuModule } from 'primeng/menu';
 import { TableModule } from 'primeng/table';
 import { TagModule } from 'primeng/tag';
+import { ToastModule } from 'primeng/toast';
 import { ToolbarModule } from 'primeng/toolbar';
 
 import { take } from 'rxjs/operators';
@@ -21,7 +22,9 @@ import {
 } from '@dotcms/ui';
 
 import { DotAiIndexCreateComponent } from './dot-ai-index-create/dot-ai-index-create.component';
+import { DotAiIndexRemoveContentComponent } from './dot-ai-index-remove-content/dot-ai-index-remove-content.component';
 
+import { DOT_AI_INDEX_OPERATION, DotAiIndexNotice } from '../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../store/dot-ai.store';
 import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
 
@@ -55,15 +58,16 @@ const CONFIRM_BUTTONS = {
     imports: [
         DotEmptyContainerComponent,
         ToolbarModule,
-        MessageModule,
+        MenuModule,
         TableModule,
         TagModule,
+        ToastModule,
         ButtonModule,
         ConfirmDialogModule,
         DotSearchInputComponent,
         DotMessagePipe
     ],
-    providers: [ConfirmationService, DialogService],
+    providers: [ConfirmationService, DialogService, MessageService],
     templateUrl: './dot-ai-embeddings.component.html',
     host: { class: 'block h-full' }
 })
@@ -71,36 +75,65 @@ export default class DotAiEmbeddingsComponent {
     protected readonly store = inject(DotAiStore);
 
     readonly #confirmationService = inject(ConfirmationService);
+    readonly #toast = inject(MessageService);
     readonly #dialogService = inject(DialogService);
     readonly #messageService = inject(DotMessageService);
 
     protected readonly statuses = DOT_AI_INDEX_STATUS;
 
-    /** Whether the create dialog is up, and so is the one rendering build outcomes. */
-    readonly #createDialogOpen = signal(false);
+    /** Whether a dialog is up, and so is the one rendering what the user must act on. */
+    readonly #dialogOpen = signal(false);
 
-    /**
-     * The build outcome this tab owns.
-     *
-     * While the dialog is up it owns everything the user has to act on — nothing matched, and
-     * a query the server rejected — because those are corrections to a field it is still
-     * holding; only the success reaches here, next to the row it just created.
-     *
-     * Once the dialog has gone, this tab is the only thing left that can report anything, so
-     * it reports all of it. Without that, a build dismissed with Escape or the header X while
-     * still in flight failed into silence: the notice arrived after the dialog was destroyed,
-     * and a success in the same situation was announced while a failure was not.
-     */
-    protected readonly $notice = computed(() => {
-        const notice = this.store.indexBuildNotice();
+    /** The index whose row menu is open; its actions are built from this. */
+    readonly #menuIndex = signal<DotAiIndex | null>(null);
 
-        if (!this.#createDialogOpen()) {
-            return notice;
+    /** Identity guard: each operation makes a fresh notice, so this toasts each one once. */
+    #toasted: DotAiIndexNotice | null = null;
+
+    protected readonly $rowActions = computed<MenuItem[]>(() => {
+        const index = this.#menuIndex();
+
+        if (!index) {
+            return [];
         }
 
-        return notice?.kind === 'built' ? notice : null;
+        return [
+            {
+                label: this.#messageService.get('dotai.embeddings.remove-content'),
+                icon: 'pi pi-eraser',
+                command: () => this.openRemoveContentDialog(index)
+            },
+            {
+                label: this.#messageService.get('dotai.embeddings.delete'),
+                icon: 'pi pi-trash',
+                styleClass: 'p-error',
+                command: () => this.confirmDeleteIndex(index)
+            }
+        ];
     });
 
+    constructor() {
+        // Every outcome is announced somewhere. A dialog that is still up owns anything the
+        // user has to act on, because those are corrections to a field it is still holding;
+        // everything else — successes, and failures whose dialog has gone — is a toast, which
+        // is what the rest of the admin does. Nothing renders a standing banner on the tab.
+        effect(() => {
+            const notice = this.store.indexNotice();
+            const dialogOpen = this.#dialogOpen();
+
+            if (!notice || notice === this.#toasted) {
+                return;
+            }
+
+            if (dialogOpen && notice.outcome !== 'ok') {
+                return;
+            }
+
+            this.#toasted = notice;
+            untracked(() => this.#toast.add(this.#toastFor(notice)));
+        });
+    }
+
     /**
      * Two different empty states behind one slot: an instance with no indexes at all, and a
      * filter that matched none of the ones there are. Telling someone to create their first
@@ -141,8 +174,8 @@ export default class DotAiEmbeddingsComponent {
      * reporting.
      */
     protected openCreateDialog(): void {
-        this.store.dismissBuildNotice();
-        this.#createDialogOpen.set(true);
+        this.store.dismissIndexNotice();
+        this.#dialogOpen.set(true);
 
         // `onDestroy`, not `onClose`: `close()` fires `onClose` immediately and only then
         // plays the leave animation, so the dialog component — and the `DestroyRef` hook that
@@ -159,7 +192,63 @@ export default class DotAiEmbeddingsComponent {
                 draggable: false
             })
             .onDestroy.pipe(take(1))
-            .subscribe(() => this.#createDialogOpen.set(false));
+            .subscribe(() => this.#dialogOpen.set(false));
+    }
+
+    /** Opens the row menu for one index. One menu instance serves every row. */
+    protected openRowMenu(index: DotAiIndex): void {
+        this.#menuIndex.set(index);
+    }
+
+    protected openRemoveContentDialog(index: DotAiIndex): void {
+        this.store.dismissIndexNotice();
+        this.#dialogOpen.set(true);
+
+        this.#dialogService
+            .open(DotAiIndexRemoveContentComponent, {
+                header: this.#messageService.get(
+                    'dotai.embeddings.remove-content.header',
+                    index.name
+                ),
+                width: '700px',
+                closable: true,
+                closeOnEscape: true,
+                draggable: false,
+                data: { indexName: index.name }
+            })
+            // Same reason as the build dialog: `onDestroy` fires once, on every close path,
+            // after the dialog has let go — `onClose` fires before the leave animation.
+            .onDestroy.pipe(take(1))
+            .subscribe(() => this.#dialogOpen.set(false));
+    }
+
+    /** The one place an outcome becomes words. Severity follows the outcome, not the action. */
+    #toastFor(notice: DotAiIndexNotice): {
+        severity: string;
+        summary: string;
+        detail: string;
+        life: number;
+    } {
+        const severity =
+            notice.outcome === 'ok' ? 'success' : notice.outcome === 'empty' ? 'warn' : 'error';
+
+        const key = `dotai.embeddings.${
+            {
+                [DOT_AI_INDEX_OPERATION.BUILD]: 'build',
+                [DOT_AI_INDEX_OPERATION.REMOVE_CONTENT]: 'remove-content',
+                [DOT_AI_INDEX_OPERATION.DELETE_INDEX]: 'delete',
+                [DOT_AI_INDEX_OPERATION.REBUILD_DB]: 'rebuild'
+            }[notice.operation]
+        }.${notice.outcome}`;
+
+        return {
+            severity,
+            summary: this.#messageService.get(`dotai.embeddings.toast.${severity}`),
+            // Every notice key takes the same two, in the same order: the index, then the
+            // count or the server's reason. Anything else and a generic mapper cannot exist.
+            detail: this.#messageService.get(key, notice.indexName, notice.detail ?? ''),
+            life: severity === 'success' ? 4000 : 8000
+        };
     }
 
     protected confirmDeleteIndex(index: DotAiIndex): void {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
index 5ec75f75b27c..3acbe8c332b1 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
@@ -1,22 +1,4 @@
 <form class="form" (ngSubmit)="submit()">
-    <!-- Same reason as the operator group in the settings panel: the heading needs to be
-         programmatically associated, and a segmented control has no single input to point a
-         `for` at. -->
-    <div class="field" role="group" aria-labelledby="dotai-index-create-mode-label">
-        <label id="dotai-index-create-mode-label">{{ 'dotai.index.create.mode' | dm }}</label>
-        <p-selectButton
-            [options]="modes"
-            optionLabel="label"
-            optionValue="value"
-            [allowEmpty]="false"
-            [ngModel]="$mode()"
-            (ngModelChange)="$mode.set($event)"
-            [ngModelOptions]="{ standalone: true }"
-            data-testid="dotai-index-create-mode">
-            <ng-template let-item pTemplate="item">{{ item.label | dm }}</ng-template>
-        </p-selectButton>
-    </div>
-
     <div class="field">
         <!-- `p-label-input-required` is the asterisk `dotFieldRequired` applies. The
              directive itself is unusable here: it injects `FormGroupDirective`, and this
@@ -56,35 +38,32 @@
         <small class="p-field-hint">{{ 'dotai.index.create.query.hint' | dm }}</small>
     </div>
 
-    <!-- Both only shape what gets embedded, so they are meaningless when deleting. -->
-    @if ($mode() === 'add') {
-        <div class="field">
-            <label for="dotai-index-fields">{{ 'dotai.index.create.fields' | dm }}</label>
-            <input
-                pInputText
-                id="dotai-index-fields"
-                [ngModel]="$fields()"
-                [ngModelOptions]="{ standalone: true }"
-                (ngModelChange)="$fields.set($event)"
-                [placeholder]="'dotai.index.create.fields.placeholder' | dm"
-                data-testid="dotai-index-create-fields" />
-            <small class="p-field-hint">{{ 'dotai.index.create.fields.hint' | dm }}</small>
-        </div>
+    <div class="field">
+        <label for="dotai-index-fields">{{ 'dotai.index.create.fields' | dm }}</label>
+        <input
+            pInputText
+            id="dotai-index-fields"
+            [ngModel]="$fields()"
+            [ngModelOptions]="{ standalone: true }"
+            (ngModelChange)="$fields.set($event)"
+            [placeholder]="'dotai.index.create.fields.placeholder' | dm"
+            data-testid="dotai-index-create-fields" />
+        <small class="p-field-hint">{{ 'dotai.index.create.fields.hint' | dm }}</small>
+    </div>
 
-        <div class="field">
-            <label for="dotai-index-template">{{ 'dotai.index.create.template' | dm }}</label>
-            <textarea
-                pTextarea
-                id="dotai-index-template"
-                rows="3"
-                [ngModel]="$velocityTemplate()"
-                [ngModelOptions]="{ standalone: true }"
-                (ngModelChange)="$velocityTemplate.set($event)"
-                [placeholder]="'dotai.index.create.template.placeholder' | dm"
-                data-testid="dotai-index-create-template"></textarea>
-            <small class="p-field-hint">{{ 'dotai.index.create.template.hint' | dm }}</small>
-        </div>
-    }
+    <div class="field">
+        <label for="dotai-index-template">{{ 'dotai.index.create.template' | dm }}</label>
+        <textarea
+            pTextarea
+            id="dotai-index-template"
+            rows="3"
+            [ngModel]="$velocityTemplate()"
+            [ngModelOptions]="{ standalone: true }"
+            (ngModelChange)="$velocityTemplate.set($event)"
+            [placeholder]="'dotai.index.create.template.placeholder' | dm"
+            data-testid="dotai-index-create-template"></textarea>
+        <small class="p-field-hint">{{ 'dotai.index.create.template.hint' | dm }}</small>
+    </div>
 
     <!-- The build outcome belongs here, not on the tab behind: a rejected Lucene query is a
          correction to the field two rows up, and the dialog is still holding it. Only the
@@ -92,10 +71,10 @@
     @if ($notice(); as notice) {
         <p-message
             class="mt-4 block"
-            [severity]="notice.kind === 'empty' ? 'warn' : 'error'"
+            [severity]="notice.outcome === 'empty' ? 'warn' : 'error'"
             data-testid="dotai-index-create-notice">
-            @if (notice.kind === 'empty') {
-                {{ 'dotai.embeddings.build.empty' | dm: [notice.indexName] }}
+            @if (notice.outcome === 'empty') {
+                {{ 'dotai.embeddings.build.empty' | dm: [notice.indexName, notice.detail ?? ''] }}
             } @else {
                 {{ 'dotai.embeddings.build.failed' | dm: [notice.indexName, notice.detail ?? ''] }}
             }
@@ -111,10 +90,9 @@
             data-testid="dotai-index-create-cancel" />
         <p-button
             type="submit"
-            [severity]="$mode() === 'delete' ? 'danger' : 'primary'"
             [disabled]="!$canSubmit()"
             [loading]="$submitting()"
-            [label]="$submitLabel() | dm"
+            [label]="'dotai.index.create.submit.add' | dm"
             data-testid="dotai-index-create-submit" />
     </div>
 </form>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
index f49adf3a0273..7148b928f1e5 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
@@ -14,7 +14,7 @@ import { DotAiIndex } from '@dotcms/dotcms-models';
 
 import { DotAiIndexCreateComponent } from './dot-ai-index-create.component';
 
-import { DotAiIndexBuildNotice } from '../../../models/dot-ai-portlet.models';
+import { DOT_AI_INDEX_OPERATION, DotAiIndexNotice } from '../../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../../store/dot-ai.store';
 
 describe('DotAiIndexCreateComponent', () => {
@@ -22,10 +22,9 @@ describe('DotAiIndexCreateComponent', () => {
     let dialogRef: DynamicDialogRef;
     let store: {
         indexes: ReturnType<typeof signal<DotAiIndex[]>>;
-        indexBuildNotice: ReturnType<typeof signal<DotAiIndexBuildNotice | null>>;
+        indexNotice: ReturnType<typeof signal<DotAiIndexNotice | null>>;
         buildIndex: ReturnType<typeof vi.fn>;
-        deleteFromIndex: ReturnType<typeof vi.fn>;
-        dismissBuildNotice: ReturnType<typeof vi.fn>;
+        dismissIndexNotice: ReturnType<typeof vi.fn>;
     };
 
     const createComponent = createComponentFactory({
@@ -46,10 +45,9 @@ describe('DotAiIndexCreateComponent', () => {
                     contentTypes: []
                 }
             ]),
-            indexBuildNotice: signal<DotAiIndexBuildNotice | null>(null),
+            indexNotice: signal<DotAiIndexNotice | null>(null),
             buildIndex: vi.fn(),
-            deleteFromIndex: vi.fn(),
-            dismissBuildNotice: vi.fn()
+            dismissIndexNotice: vi.fn()
         };
 
         spectator = createComponent({
@@ -120,8 +118,9 @@ describe('DotAiIndexCreateComponent', () => {
         fillValidForm();
         clickButton('dotai-index-create-submit');
 
-        store.indexBuildNotice.set({
-            kind: 'failed',
+        store.indexNotice.set({
+            operation: DOT_AI_INDEX_OPERATION.BUILD,
+            outcome: 'failed',
             indexName: 'blogs',
             detail: 'Cannot parse query'
         });
@@ -138,7 +137,11 @@ describe('DotAiIndexCreateComponent', () => {
         fillValidForm();
         clickButton('dotai-index-create-submit');
 
-        store.indexBuildNotice.set({ kind: 'empty', indexName: 'blogs' });
+        store.indexNotice.set({
+            operation: DOT_AI_INDEX_OPERATION.BUILD,
+            outcome: 'empty',
+            indexName: 'blogs'
+        });
         spectator.detectChanges();
 
         expect(spectator.query(byTestId('dotai-index-create-notice'))).toBeTruthy();
@@ -149,7 +152,12 @@ describe('DotAiIndexCreateComponent', () => {
         fillValidForm();
         clickButton('dotai-index-create-submit');
 
-        store.indexBuildNotice.set({ kind: 'built', indexName: 'blogs', detail: '12' });
+        store.indexNotice.set({
+            operation: DOT_AI_INDEX_OPERATION.BUILD,
+            outcome: 'ok',
+            indexName: 'blogs',
+            detail: '12'
+        });
         spectator.detectChanges();
 
         expect(dialogRef.close).toHaveBeenCalled();
@@ -171,7 +179,12 @@ describe('DotAiIndexCreateComponent', () => {
         fillValidForm();
         clickButton('dotai-index-create-submit');
 
-        store.indexBuildNotice.set({ kind: 'failed', indexName: 'blogs', detail: 'bad query' });
+        store.indexNotice.set({
+            operation: DOT_AI_INDEX_OPERATION.BUILD,
+            outcome: 'failed',
+            indexName: 'blogs',
+            detail: 'bad query'
+        });
         spectator.detectChanges();
 
         expect(
@@ -193,28 +206,23 @@ describe('DotAiIndexCreateComponent', () => {
         expect(dialogRef.close).toHaveBeenCalledWith();
     });
 
-    it('should clear an unshown outcome on teardown, however it was dismissed', () => {
-        // PrimeNG's own header X and Escape call DynamicDialogRef.close directly rather than
-        // `cancel()`, so a failure dismissed that way would be left set with nothing rendering
-        // it — the tab shows only `built`, and this dialog is gone.
-        store.indexBuildNotice.set({ kind: 'failed', indexName: 'blogs' });
-        spectator.fixture.destroy();
-
-        expect(store.dismissBuildNotice).toHaveBeenCalled();
-    });
-
-    it('should leave a success standing for the tab behind it', () => {
-        store.indexBuildNotice.set({ kind: 'built', indexName: 'blogs', detail: '12' });
+    it('should leave an unshown outcome standing for the tab to report', () => {
+        // PrimeNG's own header X and Escape call DynamicDialogRef.close directly, so a build
+        // abandoned mid-flight used to fail into silence. The tab toasts whatever this dialog
+        // was not around to render, which means the notice has to survive its teardown.
+        store.indexNotice.set({
+            operation: DOT_AI_INDEX_OPERATION.BUILD,
+            outcome: 'failed',
+            indexName: 'blogs'
+        });
         spectator.fixture.destroy();
 
-        expect(store.dismissBuildNotice).not.toHaveBeenCalled();
+        expect(store.dismissIndexNotice).not.toHaveBeenCalled();
     });
 
-    it('should associate the mode heading with the segmented control', () => {
-        const group = spectator.query('[role="group"]');
-
-        expect(group?.getAttribute('aria-labelledby')).toBe('dotai-index-create-mode-label');
-        expect(spectator.query('#dotai-index-create-mode-label')).toBeTruthy();
+    it('should not offer a delete mode any more', () => {
+        // Removing content is its own dialog now, opened from the row of the index it acts on.
+        expect(spectator.query(byTestId('dotai-index-create-mode'))).toBeFalsy();
     });
 
     it('should mark the two genuinely-required fields as required', () => {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
index ec6835e26bc7..75f56e46df49 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
@@ -5,15 +5,13 @@ import { ButtonModule } from 'primeng/button';
 import { DynamicDialogRef } from 'primeng/dynamicdialog';
 import { InputTextModule } from 'primeng/inputtext';
 import { MessageModule } from 'primeng/message';
-import { SelectButtonModule } from 'primeng/selectbutton';
 import { TextareaModule } from 'primeng/textarea';
 
 import { DotMessagePipe } from '@dotcms/ui';
 
+import { DOT_AI_INDEX_OPERATION } from '../../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../../store/dot-ai.store';
 
-type DotAiIndexCreateMode = 'add' | 'delete';
-
 /**
  * The server stores whatever it is given — `bad name with spaces` is accepted verbatim, and
  * `Blog` and `blog` become two separate indexes. Neither is useful, so the name is constrained
@@ -22,11 +20,11 @@ type DotAiIndexCreateMode = 'add' | 'delete';
 const INDEX_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 
 /**
- * One dialog, two modes.
+ * Builds an index, and only builds one.
  *
- * Add mode embeds the content the query matches; delete mode removes it from the index. The
- * submit label flips with the toggle so the destructive mode never hides behind a neutral
- * word (FR-030) — the legacy screen did the same remap.
+ * Removing content used to be a mode on this same form, which meant a destructive action sat
+ * one click from a create action behind a toggle, sharing its submit button, reshaping the
+ * fields underneath it. It has its own dialog now, opened from the row of the index it acts on.
  *
  * The dialog calls the store itself rather than closing with a form value for the list
  * component to submit. It has to: a build is the one action here whose *failure* is a
@@ -42,7 +40,6 @@ const INDEX_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
         ButtonModule,
         InputTextModule,
         TextareaModule,
-        SelectButtonModule,
         MessageModule,
         DotMessagePipe
     ],
@@ -59,23 +56,11 @@ export class DotAiIndexCreateComponent {
      */
     protected readonly $submitting = signal(false);
 
-    protected readonly $mode = signal<DotAiIndexCreateMode>('add');
     protected readonly $indexName = signal('');
     protected readonly $query = signal('');
     protected readonly $fields = signal('');
     protected readonly $velocityTemplate = signal('');
 
-    protected readonly modes = [
-        { label: 'dotai.index.create.mode.add', value: 'add' as const },
-        { label: 'dotai.index.create.mode.delete', value: 'delete' as const }
-    ];
-
-    protected readonly $submitLabel = computed(() =>
-        this.$mode() === 'delete'
-            ? 'dotai.index.create.submit.delete'
-            : 'dotai.index.create.submit.add'
-    );
-
     /**
      * The build outcome, while it is this dialog's to show.
      *
@@ -84,9 +69,11 @@ export class DotAiIndexCreateComponent {
      * query the server rejected.
      */
     protected readonly $notice = computed(() => {
-        const notice = this.store.indexBuildNotice();
+        const notice = this.store.indexNotice();
 
-        return notice?.kind === 'built' ? null : notice;
+        return notice?.operation === DOT_AI_INDEX_OPERATION.BUILD && notice.outcome !== 'ok'
+            ? notice
+            : null;
     });
 
     constructor() {
@@ -94,7 +81,7 @@ export class DotAiIndexCreateComponent {
         // outcome the form still has to show. The success message is left standing on the tab
         // behind, next to the row it just created.
         effect(() => {
-            const notice = this.store.indexBuildNotice();
+            const notice = this.store.indexNotice();
 
             if (!notice) {
                 return;
@@ -103,20 +90,16 @@ export class DotAiIndexCreateComponent {
             untracked(() => {
                 this.$submitting.set(false);
 
-                if (notice.kind === 'built') {
+                if (notice.operation === DOT_AI_INDEX_OPERATION.BUILD && notice.outcome === 'ok') {
                     this.#dialogRef.close();
                 }
             });
         });
 
-        // On teardown, not in `cancel()`: PrimeNG's own header X and the Escape key call
-        // `DynamicDialogRef.close` directly, so a notice dismissed that way would be left set
-        // with nothing rendering it — the tab shows only `built`, and this dialog is gone.
-        inject(DestroyRef).onDestroy(() => {
-            if (this.store.indexBuildNotice()?.kind !== 'built') {
-                this.store.dismissBuildNotice();
-            }
-        });
+        // Nothing is cleared on teardown any more. A build abandoned with Escape or the
+        // header X while still in flight used to fail into silence; the tab now toasts
+        // whatever this dialog was not around to render, so the notice has to survive it.
+        inject(DestroyRef).onDestroy(() => this.$submitting.set(false));
     }
 
     /** Empty until the field has been touched, so the form does not scold you on open. */
@@ -131,8 +114,7 @@ export class DotAiIndexCreateComponent {
             return 'dotai.index.create.name.invalid';
         }
 
-        // Only for a build: deleting names an index that must already exist.
-        if (this.$mode() === 'add' && this.store.indexes().some((index) => index.name === name)) {
+        if (this.store.indexes().some((index) => index.name === name)) {
             return 'dotai.index.create.name.exists';
         }
 
@@ -152,22 +134,10 @@ export class DotAiIndexCreateComponent {
             return;
         }
 
-        const indexName = this.$indexName().trim();
-        const query = this.$query().trim();
-
-        // A delete has no outcome to report back into the form — it either works or goes
-        // through the shared error handler — so it keeps the original resolve-and-close shape.
-        if (this.$mode() === 'delete') {
-            this.store.deleteFromIndex({ indexName, query });
-            this.#dialogRef.close();
-
-            return;
-        }
-
         this.$submitting.set(true);
         this.store.buildIndex({
-            indexName,
-            query,
+            indexName: this.$indexName().trim(),
+            query: this.$query().trim(),
             // Both only shape what gets embedded, so they are omitted rather than sent blank.
             ...(this.$fields().trim() ? { fields: this.$fields().trim() } : {}),
             ...(this.$velocityTemplate().trim()
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
new file mode 100644
index 000000000000..cb7bfc2af930
--- /dev/null
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
@@ -0,0 +1,57 @@
+<form class="form" (ngSubmit)="submit()">
+    <!-- The three things the old delete mode never said, and which decide whether the query
+         someone is about to run does what they think it does. -->
+    <p-message class="block" severity="secondary" data-testid="dotai-index-remove-explainer">
+        {{ 'dotai.embeddings.remove-content.explainer' | dm: [indexName] }}
+    </p-message>
+
+    <div class="field mt-4">
+        <label class="p-label-input-required" for="dotai-index-remove-query">
+            {{ 'dotai.embeddings.remove-content.query' | dm }}
+        </label>
+        <textarea
+            pTextarea
+            id="dotai-index-remove-query"
+            rows="3"
+            [ngModel]="$query()"
+            [ngModelOptions]="{ standalone: true }"
+            (ngModelChange)="$query.set($event)"
+            [placeholder]="'dotai.index.create.query.placeholder' | dm"
+            data-testid="dotai-index-remove-query"></textarea>
+        <small class="p-field-hint">
+            {{ 'dotai.embeddings.remove-content.query.hint' | dm }}
+        </small>
+    </div>
+
+    @if ($notice(); as notice) {
+        <p-message
+            class="mt-4 block"
+            [severity]="notice.outcome === 'empty' ? 'warn' : 'error'"
+            data-testid="dotai-index-remove-notice">
+            @if (notice.outcome === 'empty') {
+                {{ 'dotai.embeddings.remove-content.empty' | dm: [notice.indexName] }}
+            } @else {
+                {{
+                    'dotai.embeddings.remove-content.failed'
+                        | dm: [notice.indexName, notice.detail ?? '']
+                }}
+            }
+        </p-message>
+    }
+
+    <div class="mt-4 flex justify-end gap-2">
+        <p-button
+            severity="secondary"
+            [text]="true"
+            [label]="'dotai.index.create.cancel' | dm"
+            (onClick)="cancel()"
+            data-testid="dotai-index-remove-cancel" />
+        <p-button
+            type="submit"
+            severity="danger"
+            [disabled]="!$canSubmit()"
+            [loading]="$submitting()"
+            [label]="'dotai.embeddings.remove-content.submit' | dm"
+            data-testid="dotai-index-remove-submit" />
+    </div>
+</form>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
new file mode 100644
index 000000000000..98d8efb9f289
--- /dev/null
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
@@ -0,0 +1,165 @@
+import {
+    byTestId,
+    createComponentFactory,
+    mockProvider,
+    Spectator
+} from '@openng/spectator/vitest';
+
+import { signal } from '@angular/core';
+
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+
+import { DotMessageService } from '@dotcms/data-access';
+
+import { DotAiIndexRemoveContentComponent } from './dot-ai-index-remove-content.component';
+
+import { DOT_AI_INDEX_OPERATION, DotAiIndexNotice } from '../../../models/dot-ai-portlet.models';
+import { DotAiStore } from '../../../store/dot-ai.store';
+
+describe('DotAiIndexRemoveContentComponent', () => {
+    let spectator: Spectator<DotAiIndexRemoveContentComponent>;
+    let dialogRef: DynamicDialogRef;
+    let store: {
+        indexNotice: ReturnType<typeof signal<DotAiIndexNotice | null>>;
+        removeFromIndex: ReturnType<typeof vi.fn>;
+        dismissIndexNotice: ReturnType<typeof vi.fn>;
+    };
+
+    const createComponent = createComponentFactory({
+        component: DotAiIndexRemoveContentComponent,
+        providers: [
+            mockProvider(DynamicDialogRef),
+            mockProvider(DotMessageService, { get: (key: string) => key }),
+            { provide: DynamicDialogConfig, useValue: { data: { indexName: 'blogs' } } }
+        ],
+        shallow: true
+    });
+
+    beforeEach(() => {
+        store = {
+            indexNotice: signal<DotAiIndexNotice | null>(null),
+            removeFromIndex: vi.fn(),
+            dismissIndexNotice: vi.fn()
+        };
+
+        spectator = createComponent({ providers: [{ provide: DotAiStore, useValue: store }] });
+        dialogRef = spectator.inject(DynamicDialogRef);
+    });
+
+    /** PrimeNG puts its click handler on the inner <button>, not the p-button host. */
+    const clickButton = (testId: string) =>
+        spectator.click(
+            spectator.query(byTestId(testId))?.querySelector('button') as HTMLButtonElement
+        );
+
+    const fillQuery = (value: string) => {
+        spectator.typeInElement(
+            value,
+            spectator.query(byTestId('dotai-index-remove-query')) as HTMLElement
+        );
+        spectator.detectChanges();
+    };
+
+    const notice = (outcome: DotAiIndexNotice['outcome'], detail?: string): DotAiIndexNotice => ({
+        operation: DOT_AI_INDEX_OPERATION.REMOVE_CONTENT,
+        outcome,
+        indexName: 'blogs',
+        detail
+    });
+
+    it('should take the index from the row rather than asking for it', () => {
+        // It used to be a free-text field on the build dialog: a typo removed nothing and a
+        // near-miss hit a different index, both silently.
+        expect(spectator.query(byTestId('dotai-index-create-name'))).toBeFalsy();
+        expect(spectator.query(byTestId('dotai-index-remove-explainer'))).toContainText(
+            'dotai.embeddings.remove-content.explainer'
+        );
+    });
+
+    it('should keep submit disabled until a query is given', () => {
+        const submit = () =>
+            spectator.query(byTestId('dotai-index-remove-submit'))?.querySelector('button');
+
+        expect(submit()?.disabled).toBe(true);
+
+        fillQuery('+contentType:Blog');
+
+        expect(submit()?.disabled).toBe(false);
+    });
+
+    it('should remove through the store rather than resolving the dialog', () => {
+        fillQuery('  +contentType:Blog  ');
+
+        clickButton('dotai-index-remove-submit');
+
+        expect(store.removeFromIndex).toHaveBeenCalledWith({
+            indexName: 'blogs',
+            query: '+contentType:Blog'
+        });
+        expect(dialogRef.close).not.toHaveBeenCalled();
+    });
+
+    it('should keep a query that matched nothing on screen to be corrected', () => {
+        // The server answers 200 with `deleted: 0`, which would otherwise read as a success.
+        fillQuery('+contentType:NoSuchType');
+        clickButton('dotai-index-remove-submit');
+
+        store.indexNotice.set(notice('empty', '0'));
+        spectator.detectChanges();
+
+        expect(spectator.query(byTestId('dotai-index-remove-notice'))).toBeTruthy();
+        expect(dialogRef.close).not.toHaveBeenCalled();
+        expect(
+            (spectator.query(byTestId('dotai-index-remove-query')) as HTMLTextAreaElement).value
+        ).toBe('+contentType:NoSuchType');
+    });
+
+    it('should show a rejected query inline', () => {
+        fillQuery('+++[');
+        clickButton('dotai-index-remove-submit');
+
+        store.indexNotice.set(notice('failed', 'Cannot parse query'));
+        spectator.detectChanges();
+
+        expect(spectator.query(byTestId('dotai-index-remove-notice'))).toBeTruthy();
+        expect(dialogRef.close).not.toHaveBeenCalled();
+    });
+
+    it('should close itself once something was actually removed', () => {
+        fillQuery('+contentType:Blog');
+        clickButton('dotai-index-remove-submit');
+
+        store.indexNotice.set(notice('ok', '3'));
+        spectator.detectChanges();
+
+        expect(dialogRef.close).toHaveBeenCalled();
+    });
+
+    it('should ignore an outcome belonging to another operation', () => {
+        // One notice channel serves all four operations, so each dialog has to read only its own.
+        fillQuery('+contentType:Blog');
+        clickButton('dotai-index-remove-submit');
+
+        store.indexNotice.set({
+            operation: DOT_AI_INDEX_OPERATION.BUILD,
+            outcome: 'failed',
+            indexName: 'other'
+        });
+        spectator.detectChanges();
+
+        expect(spectator.query(byTestId('dotai-index-remove-notice'))).toBeFalsy();
+        expect(dialogRef.close).not.toHaveBeenCalled();
+    });
+
+    it('should block a second submit while a removal is outstanding', () => {
+        fillQuery('+contentType:Blog');
+        clickButton('dotai-index-remove-submit');
+        spectator.detectChanges();
+
+        expect(
+            spectator.query(byTestId('dotai-index-remove-submit'))?.querySelector('button')
+                ?.disabled
+        ).toBe(true);
+        expect(store.removeFromIndex).toHaveBeenCalledTimes(1);
+    });
+});
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
new file mode 100644
index 000000000000..b762839d494b
--- /dev/null
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
@@ -0,0 +1,93 @@
+import { Component, computed, DestroyRef, effect, inject, signal, untracked } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+
+import { ButtonModule } from 'primeng/button';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { MessageModule } from 'primeng/message';
+import { TextareaModule } from 'primeng/textarea';
+
+import { DotMessagePipe } from '@dotcms/ui';
+
+import { DOT_AI_INDEX_OPERATION } from '../../../models/dot-ai-portlet.models';
+import { DotAiStore } from '../../../store/dot-ai.store';
+
+/**
+ * Removes the embeddings for content matching a query, from one index.
+ *
+ * Opened from the row of the index it acts on, so the index is context rather than an input.
+ * It used to be a mode on the build dialog, where the name was a free-text field: a typo
+ * removed nothing and a near-miss hit a different index, both in silence.
+ *
+ * Owns its submit for the same reason the build dialog does — a rejected query is a correction
+ * to the field still on screen — and stays open when the query matched nothing, which the
+ * server reports as a perfectly successful `deleted: 0`.
+ */
+@Component({
+    selector: 'dot-ai-index-remove-content',
+    imports: [FormsModule, ButtonModule, TextareaModule, MessageModule, DotMessagePipe],
+    templateUrl: './dot-ai-index-remove-content.component.html'
+})
+export class DotAiIndexRemoveContentComponent {
+    readonly #dialogRef = inject(DynamicDialogRef);
+    readonly #config = inject(DynamicDialogConfig<{ indexName: string }>);
+
+    protected readonly store = inject(DotAiStore);
+
+    protected readonly indexName = this.#config.data?.indexName ?? '';
+
+    protected readonly $query = signal('');
+    protected readonly $submitting = signal(false);
+
+    /** This dialog's own outcomes, and only the ones it can do something about. */
+    protected readonly $notice = computed(() => {
+        const notice = this.store.indexNotice();
+
+        return notice?.operation === DOT_AI_INDEX_OPERATION.REMOVE_CONTENT &&
+            notice.outcome !== 'ok'
+            ? notice
+            : null;
+    });
+
+    protected readonly $canSubmit = computed(() => !!this.$query().trim() && !this.$submitting());
+
+    constructor() {
+        effect(() => {
+            const notice = this.store.indexNotice();
+
+            if (notice?.operation !== DOT_AI_INDEX_OPERATION.REMOVE_CONTENT) {
+                return;
+            }
+
+            untracked(() => {
+                this.$submitting.set(false);
+
+                // Only an actual removal closes this. "Nothing matched" leaves the query on
+                // screen to be corrected, which is the whole reason the dialog owns the submit.
+                if (notice.outcome === 'ok') {
+                    this.#dialogRef.close();
+                }
+            });
+        });
+
+        // The tab reports whatever is still unrendered when this goes, so nothing is cleared
+        // here — see DotAiEmbeddingsComponent. Kept to drop a notice the tab has no business
+        // repeating once the user has already read it inline and dismissed the dialog.
+        inject(DestroyRef).onDestroy(() => this.$submitting.set(false));
+    }
+
+    protected submit(): void {
+        if (!this.$canSubmit()) {
+            return;
+        }
+
+        this.$submitting.set(true);
+        this.store.removeFromIndex({
+            indexName: this.indexName,
+            query: this.$query().trim()
+        });
+    }
+
+    protected cancel(): void {
+        this.#dialogRef.close();
+    }
+}
diff --git a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
index febb8dab1c6f..541aafb9f0d1 100644
--- a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
+++ b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
@@ -8708,9 +8708,26 @@ dotai.chat.stopped=Answer stopped.
 dotai.chat.thinking=Reading your content
 dotai.chat.error.empty=No answer came back. Try asking again, or loosen the closeness threshold so the index returns something to answer from.
 dotai.embeddings.filter.placeholder=Filter indexes
-dotai.embeddings.build.ok=Indexed {0} items into "{1}".
+dotai.embeddings.build.ok=Indexed {1} items into "{0}".
 dotai.embeddings.build.empty=Nothing matched that query, so "{0}" was created with no content. Check the query and build again.
 dotai.embeddings.build.failed=Could not build "{0}". {1} Check the query syntax and try again.
+dotai.embeddings.delete.ok=Deleted "{0}" and the {1} embeddings in it.
+dotai.embeddings.delete.failed=Could not delete "{0}". {1}
+dotai.embeddings.rebuild.ok=Embeddings store rebuilt. Every index has to be built again.
+dotai.embeddings.rebuild.failed=Could not rebuild the embeddings store. {1}
+dotai.embeddings.toast.success=Done
+dotai.embeddings.toast.warn=Nothing changed
+dotai.embeddings.toast.error=Failed
+dotai.embeddings.row.actions=Actions for this index
+dotai.embeddings.remove-content=Remove content…
+dotai.embeddings.remove-content.header=Remove content from "{0}"
+dotai.embeddings.remove-content.explainer=This removes the embeddings for the content your query matches from "{0}". The content itself is not deleted. The query runs against your content as it is now, not against what is in the index, so content that has changed and no longer matches is left behind, and archived or deleted content cannot be reached this way.
+dotai.embeddings.remove-content.query=Content query
+dotai.embeddings.remove-content.query.hint=Lucene query selecting the content to remove. Unlike building, this is not limited to live content.
+dotai.embeddings.remove-content.submit=Remove content
+dotai.embeddings.remove-content.ok=Removed {1} items from "{0}".
+dotai.embeddings.remove-content.empty=Nothing in "{0}" matched that query, so nothing was removed. Check the query and try again.
+dotai.embeddings.remove-content.failed=Could not remove content from "{0}". {1} Check the query syntax and try again.
 dotai.embeddings.rebuild=Rebuild DB
 dotai.embeddings.rebuild.header=Rebuild the embeddings store?
 dotai.embeddings.rebuild.message=This discards every embedding on this instance. Indexes must be rebuilt afterwards. This cannot be undone.
@@ -8731,9 +8748,6 @@ dotai.embeddings.empty.sub=Create an index from a content query to start searchi
 dotai.index.admin-required.sub=Ask an administrator to grant the role, or to build the indexes for you.
 dotai.index.create.action=New Index
 dotai.index.create.header=Build an index
-dotai.index.create.mode=Mode
-dotai.index.create.mode.add=Add to index
-dotai.index.create.mode.delete=Delete from index
 dotai.index.create.name=Index name
 dotai.index.create.name.placeholder=default
 dotai.index.create.name.invalid=Use letters, numbers, hyphens or underscores only — no spaces.
@@ -8749,7 +8763,6 @@ dotai.index.create.template.placeholder=$contentlet.title $contentlet.body.toHtm
 dotai.index.create.template.hint=Renders the exact text to embed, once per matching content. Use $contentlet.fieldVariable for field values, or $contentletToString for what dotCMS would pick on its own. HTML is stripped to plain text. Takes precedence over Fields.
 dotai.index.create.cancel=Cancel
 dotai.index.create.submit.add=Build index
-dotai.index.create.submit.delete=Delete from index
 dotai.image.placeholder=Describe the image to generate...
 dotai.image.input.aria=Describe the image to generate
 dotai.image.size.aria=Image size

From 0f2687530fd343fd53d50c0b5ecddd9bf8be8566 Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 14:41:24 -0600
Subject: [PATCH 07/11] fix(dotai): make Remove content a toolbar action, not a
 row action
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On a row it implied it knew what was in that index. Nothing records the query
that built an index, so the query typed here is written blind either way, and
the row placement promised a context the backend cannot give.

The two are also the same shape of operation — a Lucene query plus an index to
scope it to, run against current content — so making one a toolbar button and
the other a row action made them look like different kinds of thing.

The index is a picker over the real list rather than a free-text field, which
is the one thing the row placement was right about: as free text on the old
delete mode, a typo removed nothing and a near-miss hit a different index, both
in silence. The row goes back to a single delete action, so the toolbar reads
Remove content / Rebuild DB as quiet outlined buttons beside a primary
New Index.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../dot-ai-embeddings.component.html          | 29 ++++---
 .../dot-ai-embeddings.component.spec.ts       | 80 +++++++++----------
 .../dot-ai-embeddings.component.ts            | 44 +---------
 ...dot-ai-index-remove-content.component.html | 18 ++++-
 ...-ai-index-remove-content.component.spec.ts | 42 ++++++++--
 .../dot-ai-index-remove-content.component.ts  | 37 ++++++---
 .../WEB-INF/messages/Language.properties      |  9 ++-
 7 files changed, 145 insertions(+), 114 deletions(-)

diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
index 37e4545554b3..02ea525bf882 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.html
@@ -9,6 +9,17 @@
 
         <ng-template pTemplate="end">
             <div class="flex items-center gap-2">
+                <!-- Beside New Index rather than on a row: the two are the same shape of
+                     operation, a Lucene query plus an index to scope it to. Hanging this one
+                     off a row implied it knew what was in that index, and nothing records the
+                     query that built one. -->
+                <p-button
+                    severity="secondary"
+                    [outlined]="true"
+                    [label]="'dotai.embeddings.remove-content.action' | dm"
+                    [disabled]="!store.indexes().length"
+                    (onClick)="openRemoveContentDialog()"
+                    data-testid="dotai-embeddings-remove-content" />
                 <p-button
                     severity="secondary"
                     [outlined]="true"
@@ -113,22 +124,22 @@
                                  glyph's own line-height is what was inflating that content.
                                  Without them this measured 28x37.
 
-                                 A menu rather than a bare trash icon: removing content from
-                                 an index belongs on the index it acts on, not in a mode of
-                                 the build dialog where the name had to be typed. -->
+                                 Secondary, not danger: a red control on every row reads as a
+                                 warning about the row itself. The destructive step is the
+                                 confirm dialog, whose accept button is `p-button-danger`. -->
                             <p-button
                                 [text]="true"
                                 [rounded]="true"
                                 severity="secondary"
                                 size="small"
                                 styleClass="w-8 h-8 p-0"
-                                [ariaLabel]="'dotai.embeddings.row.actions' | dm"
-                                (onClick)="openRowMenu(index); rowMenu.toggle($event)"
-                                data-testid="dotai-embeddings-row-actions">
+                                [ariaLabel]="'dotai.embeddings.delete' | dm"
+                                (onClick)="confirmDeleteIndex(index)"
+                                data-testid="dotai-embeddings-delete">
                                 <span
                                     class="material-symbols-outlined text-lg! leading-none!"
                                     aria-hidden="true">
-                                    more_vert
+                                    delete
                                 </span>
                             </p-button>
                         </td>
@@ -139,10 +150,6 @@
     </div>
 </section>
 
-<!-- One menu for the whole table: `openRowMenu` sets which index it is for just before the
-     toggle, so a row does not each carry an overlay of its own. -->
-<p-menu #rowMenu [model]="$rowActions()" [popup]="true" appendTo="body" />
-
 <!-- Every outcome lands here now, which is what the rest of the admin does. The tab used to
      carry a standing banner for a successful build and say nothing at all for the three
      destructive actions. -->
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
index 13a46d9a7de7..61a51384c839 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
@@ -7,7 +7,7 @@ import {
 import { Subject } from 'rxjs';
 import { Mock, MockInstance, vi } from 'vitest';
 
-import { ConfirmationService, MenuItem, MessageService } from 'primeng/api';
+import { ConfirmationService, MessageService } from 'primeng/api';
 import { DialogService } from 'primeng/dynamicdialog';
 
 import { DotMessageService } from '@dotcms/data-access';
@@ -89,23 +89,6 @@ describe('DotAiEmbeddingsComponent', () => {
             spectator.query(byTestId(testId))?.querySelector('button') as HTMLButtonElement
         );
 
-    /**
-     * Runs a row-menu item by its label key.
-     *
-     * The overlay itself is PrimeNG's and does not render in a shallow test, so this opens the
-     * menu for the row and invokes the command the component put on the model — which is the
-     * component's half of the contract.
-     */
-    const openRowMenuItem = (labelKey: string) => {
-        clickButton('dotai-embeddings-row-actions');
-        const item = (spectator.component as unknown as { $rowActions: () => MenuItem[] })
-            .$rowActions()
-            .find((action) => action.label === labelKey);
-
-        item?.command?.({} as never);
-        spectator.detectChanges();
-    };
-
     it('should render the table with the index rows', () => {
         expect(spectator.query(byTestId('dotai-embeddings-table'))).toBeTruthy();
         expect(spectator.queryAll(byTestId('dotai-embeddings-row'))).toHaveLength(1);
@@ -128,7 +111,7 @@ describe('DotAiEmbeddingsComponent', () => {
     const acceptConfirmation = () => confirmSpy.mock.calls[0][0].accept();
 
     it('should confirm before deleting an index (FR-031)', () => {
-        openRowMenuItem('dotai.embeddings.delete');
+        clickButton('dotai-embeddings-delete');
 
         expect(confirmSpy).toHaveBeenCalled();
         // Nothing happens until the confirmation is accepted.
@@ -138,7 +121,7 @@ describe('DotAiEmbeddingsComponent', () => {
     it('should delete once the confirmation is accepted (FR-031)', () => {
         // Asserting only the guard proves the dialog opens, not that accepting it does the
         // thing — a broken `accept` wiring would pass that test alone.
-        openRowMenuItem('dotai.embeddings.delete');
+        clickButton('dotai-embeddings-delete');
 
         acceptConfirmation();
 
@@ -245,7 +228,7 @@ describe('DotAiEmbeddingsComponent', () => {
         const config = () => confirmSpy.mock.calls[0][0];
 
         it('should give the delete confirmation a primary accept', () => {
-            openRowMenuItem('dotai.embeddings.delete');
+            clickButton('dotai-embeddings-delete');
 
             // Absent, not 'p-button-primary': the theme defines no such class — `.p-button`
             // carries the primary styling itself — so asking for one renders nothing.
@@ -253,7 +236,7 @@ describe('DotAiEmbeddingsComponent', () => {
         });
 
         it('should give the delete confirmation an outlined cancel', () => {
-            openRowMenuItem('dotai.embeddings.delete');
+            clickButton('dotai-embeddings-delete');
 
             expect(config().rejectButtonStyleClass).toBe('p-button-outlined');
         });
@@ -276,40 +259,53 @@ describe('DotAiEmbeddingsComponent', () => {
         });
     });
 
-    describe('the per-row action menu', () => {
-        const trigger = () =>
-            spectator.query(byTestId('dotai-embeddings-row-actions'))?.querySelector('button');
-
-        it('should offer removing content as well as deleting the index', () => {
-            // Removing content belongs on the index it acts on. It used to be a mode of the
-            // build dialog, where the index name was a free-text field: a typo removed nothing
-            // and a near-miss hit a different index, both silently.
-            clickButton('dotai-embeddings-row-actions');
-
-            const labels = (spectator.component as unknown as { $rowActions: () => MenuItem[] })
-                .$rowActions()
-                .map((action) => action.label);
-
-            expect(labels).toEqual(['dotai.embeddings.remove-content', 'dotai.embeddings.delete']);
+    describe('removing content', () => {
+        it('should be a toolbar action beside New Index, not a row action', () => {
+            // The two are the same shape of operation — a Lucene query plus an index to scope
+            // it to. On a row it implied it knew what was in that index, and nothing records
+            // the query that built one, so the query here is written blind either way.
+            expect(spectator.query(byTestId('dotai-embeddings-remove-content'))).toBeTruthy();
+            expect(spectator.query(byTestId('dotai-embeddings-row-actions'))).toBeFalsy();
         });
 
-        it('should open the remove-content dialog with the row as its index', () => {
-            openRowMenuItem('dotai.embeddings.remove-content');
+        it('should open its dialog at the mandated width and be dismissible', () => {
+            clickButton('dotai-embeddings-remove-content');
 
             expect(dialogService.open).toHaveBeenCalledWith(
                 expect.anything(),
                 expect.objectContaining({
                     width: '700px',
                     closable: true,
-                    closeOnEscape: true,
-                    data: { indexName: 'blogs' }
+                    closeOnEscape: true
                 })
             );
         });
 
+        it('should clear a previous outcome so the dialog opens clean', () => {
+            clickButton('dotai-embeddings-remove-content');
+
+            expect(storeMock.dismissIndexNotice).toHaveBeenCalled();
+        });
+
+        it('should be unavailable when there is no index to remove from', () => {
+            storeMock.indexes.mockReturnValue([]);
+            spectator = createComponent();
+
+            expect(
+                spectator
+                    .query(byTestId('dotai-embeddings-remove-content'))
+                    ?.querySelector('button')?.disabled
+            ).toBe(true);
+        });
+    });
+
+    describe('the per-row delete action', () => {
+        const trigger = () =>
+            spectator.query(byTestId('dotai-embeddings-delete'))?.querySelector('button');
+
         it('should be secondary, so a red control does not sit on every row', () => {
             // The destructive step is the confirm dialog, whose accept button carries
-            // p-button-danger; the row action only opens a menu.
+            // p-button-danger; the row action only opens it.
             expect(trigger()?.className).toContain('p-button-secondary');
             expect(trigger()?.className).not.toContain('p-button-danger');
         });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index 7589cbf71c7f..d748a7ed80e1 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -1,10 +1,9 @@
 import { Component, computed, effect, inject, signal, untracked } from '@angular/core';
 
-import { ConfirmationService, MenuItem, MessageService } from 'primeng/api';
+import { ConfirmationService, MessageService } from 'primeng/api';
 import { ButtonModule } from 'primeng/button';
 import { ConfirmDialogModule } from 'primeng/confirmdialog';
 import { DialogService } from 'primeng/dynamicdialog';
-import { MenuModule } from 'primeng/menu';
 import { TableModule } from 'primeng/table';
 import { TagModule } from 'primeng/tag';
 import { ToastModule } from 'primeng/toast';
@@ -58,7 +57,6 @@ const CONFIRM_BUTTONS = {
     imports: [
         DotEmptyContainerComponent,
         ToolbarModule,
-        MenuModule,
         TableModule,
         TagModule,
         ToastModule,
@@ -84,34 +82,9 @@ export default class DotAiEmbeddingsComponent {
     /** Whether a dialog is up, and so is the one rendering what the user must act on. */
     readonly #dialogOpen = signal(false);
 
-    /** The index whose row menu is open; its actions are built from this. */
-    readonly #menuIndex = signal<DotAiIndex | null>(null);
-
     /** Identity guard: each operation makes a fresh notice, so this toasts each one once. */
     #toasted: DotAiIndexNotice | null = null;
 
-    protected readonly $rowActions = computed<MenuItem[]>(() => {
-        const index = this.#menuIndex();
-
-        if (!index) {
-            return [];
-        }
-
-        return [
-            {
-                label: this.#messageService.get('dotai.embeddings.remove-content'),
-                icon: 'pi pi-eraser',
-                command: () => this.openRemoveContentDialog(index)
-            },
-            {
-                label: this.#messageService.get('dotai.embeddings.delete'),
-                icon: 'pi pi-trash',
-                styleClass: 'p-error',
-                command: () => this.confirmDeleteIndex(index)
-            }
-        ];
-    });
-
     constructor() {
         // Every outcome is announced somewhere. A dialog that is still up owns anything the
         // user has to act on, because those are corrections to a field it is still holding;
@@ -195,26 +168,17 @@ export default class DotAiEmbeddingsComponent {
             .subscribe(() => this.#dialogOpen.set(false));
     }
 
-    /** Opens the row menu for one index. One menu instance serves every row. */
-    protected openRowMenu(index: DotAiIndex): void {
-        this.#menuIndex.set(index);
-    }
-
-    protected openRemoveContentDialog(index: DotAiIndex): void {
+    protected openRemoveContentDialog(): void {
         this.store.dismissIndexNotice();
         this.#dialogOpen.set(true);
 
         this.#dialogService
             .open(DotAiIndexRemoveContentComponent, {
-                header: this.#messageService.get(
-                    'dotai.embeddings.remove-content.header',
-                    index.name
-                ),
+                header: this.#messageService.get('dotai.embeddings.remove-content.header'),
                 width: '700px',
                 closable: true,
                 closeOnEscape: true,
-                draggable: false,
-                data: { indexName: index.name }
+                draggable: false
             })
             // Same reason as the build dialog: `onDestroy` fires once, on every close path,
             // after the dialog has let go — `onClose` fires before the leave animation.
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
index cb7bfc2af930..97b02592f60f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
@@ -2,10 +2,26 @@
     <!-- The three things the old delete mode never said, and which decide whether the query
          someone is about to run does what they think it does. -->
     <p-message class="block" severity="secondary" data-testid="dotai-index-remove-explainer">
-        {{ 'dotai.embeddings.remove-content.explainer' | dm: [indexName] }}
+        {{ 'dotai.embeddings.remove-content.explainer' | dm }}
     </p-message>
 
     <div class="field mt-4">
+        <label class="p-label-input-required" for="dotai-index-remove-index">
+            {{ 'dotai.embeddings.remove-content.index' | dm }}
+        </label>
+        <!-- Picked, never typed: as a free-text field this silently removed nothing on a typo
+             and hit a different index on a near-miss. -->
+        <p-select
+            inputId="dotai-index-remove-index"
+            [options]="$indexOptions()"
+            [ngModel]="$indexName()"
+            [ngModelOptions]="{ standalone: true }"
+            (ngModelChange)="$indexName.set($event)"
+            [placeholder]="'dotai.embeddings.remove-content.index.placeholder' | dm"
+            data-testid="dotai-index-remove-index" />
+    </div>
+
+    <div class="field">
         <label class="p-label-input-required" for="dotai-index-remove-query">
             {{ 'dotai.embeddings.remove-content.query' | dm }}
         </label>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
index 98d8efb9f289..39dd57af3e50 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
@@ -7,9 +7,10 @@ import {
 
 import { signal } from '@angular/core';
 
-import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DynamicDialogRef } from 'primeng/dynamicdialog';
 
 import { DotMessageService } from '@dotcms/data-access';
+import { DotAiIndex } from '@dotcms/dotcms-models';
 
 import { DotAiIndexRemoveContentComponent } from './dot-ai-index-remove-content.component';
 
@@ -20,6 +21,7 @@ describe('DotAiIndexRemoveContentComponent', () => {
     let spectator: Spectator<DotAiIndexRemoveContentComponent>;
     let dialogRef: DynamicDialogRef;
     let store: {
+        indexes: ReturnType<typeof signal<DotAiIndex[]>>;
         indexNotice: ReturnType<typeof signal<DotAiIndexNotice | null>>;
         removeFromIndex: ReturnType<typeof vi.fn>;
         dismissIndexNotice: ReturnType<typeof vi.fn>;
@@ -29,14 +31,23 @@ describe('DotAiIndexRemoveContentComponent', () => {
         component: DotAiIndexRemoveContentComponent,
         providers: [
             mockProvider(DynamicDialogRef),
-            mockProvider(DotMessageService, { get: (key: string) => key }),
-            { provide: DynamicDialogConfig, useValue: { data: { indexName: 'blogs' } } }
+            mockProvider(DotMessageService, { get: (key: string) => key })
         ],
         shallow: true
     });
 
     beforeEach(() => {
+        const index = (name: string): DotAiIndex => ({
+            name,
+            fragments: 1,
+            contents: 1,
+            tokenTotal: 1,
+            tokensPerChunk: 1,
+            contentTypes: []
+        });
+
         store = {
+            indexes: signal<DotAiIndex[]>([index('blogs'), index('product')]),
             indexNotice: signal<DotAiIndexNotice | null>(null),
             removeFromIndex: vi.fn(),
             dismissIndexNotice: vi.fn()
@@ -67,15 +78,32 @@ describe('DotAiIndexRemoveContentComponent', () => {
         detail
     });
 
-    it('should take the index from the row rather than asking for it', () => {
-        // It used to be a free-text field on the build dialog: a typo removed nothing and a
-        // near-miss hit a different index, both silently.
-        expect(spectator.query(byTestId('dotai-index-create-name'))).toBeFalsy();
+    it('should offer the real indexes rather than a free-text name', () => {
+        // As a free-text field on the old delete mode, a typo removed nothing and a near-miss
+        // hit a different index, both silently.
+        expect(spectator.query(byTestId('dotai-index-remove-index'))).toBeTruthy();
+        expect(spectator.query('input[type="text"]#dotai-index-remove-index')).toBeFalsy();
+        expect(
+            (spectator.component as unknown as { $indexOptions: () => string[] }).$indexOptions()
+        ).toEqual(['blogs', 'product']);
+    });
+
+    it('should explain that it removes embeddings rather than content', () => {
         expect(spectator.query(byTestId('dotai-index-remove-explainer'))).toContainText(
             'dotai.embeddings.remove-content.explainer'
         );
     });
 
+    it('should default to the first index so the form is usable straight away', () => {
+        fillQuery('+contentType:Blog');
+
+        clickButton('dotai-index-remove-submit');
+
+        expect(store.removeFromIndex).toHaveBeenCalledWith(
+            expect.objectContaining({ indexName: 'blogs' })
+        );
+    });
+
     it('should keep submit disabled until a query is given', () => {
         const submit = () =>
             spectator.query(byTestId('dotai-index-remove-submit'))?.querySelector('button');
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
index b762839d494b..d7e5c86fa1e9 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
@@ -2,8 +2,9 @@ import { Component, computed, DestroyRef, effect, inject, signal, untracked } fr
 import { FormsModule } from '@angular/forms';
 
 import { ButtonModule } from 'primeng/button';
-import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DynamicDialogRef } from 'primeng/dynamicdialog';
 import { MessageModule } from 'primeng/message';
+import { SelectModule } from 'primeng/select';
 import { TextareaModule } from 'primeng/textarea';
 
 import { DotMessagePipe } from '@dotcms/ui';
@@ -14,9 +15,15 @@ import { DotAiStore } from '../../../store/dot-ai.store';
 /**
  * Removes the embeddings for content matching a query, from one index.
  *
- * Opened from the row of the index it acts on, so the index is context rather than an input.
- * It used to be a mode on the build dialog, where the name was a free-text field: a typo
- * removed nothing and a near-miss hit a different index, both in silence.
+ * A sibling of the build dialog, not a row action. The two are the same shape of operation —
+ * a Lucene query plus an index to scope it to, run against current content — and hanging this
+ * one off a row implied it knew what was in that index. Nothing records the query that built
+ * an index, so the query typed here is written blind either way; pretending otherwise was the
+ * problem with putting it on the row.
+ *
+ * The index is picked from the real list rather than typed, which is the one thing the row
+ * placement was right about: as a free-text field on the old delete mode, a typo removed
+ * nothing and a near-miss hit a different index, both in silence.
  *
  * Owns its submit for the same reason the build dialog does — a rejected query is a correction
  * to the field still on screen — and stays open when the query matched nothing, which the
@@ -24,17 +31,27 @@ import { DotAiStore } from '../../../store/dot-ai.store';
  */
 @Component({
     selector: 'dot-ai-index-remove-content',
-    imports: [FormsModule, ButtonModule, TextareaModule, MessageModule, DotMessagePipe],
+    imports: [
+        FormsModule,
+        ButtonModule,
+        TextareaModule,
+        SelectModule,
+        MessageModule,
+        DotMessagePipe
+    ],
     templateUrl: './dot-ai-index-remove-content.component.html'
 })
 export class DotAiIndexRemoveContentComponent {
     readonly #dialogRef = inject(DynamicDialogRef);
-    readonly #config = inject(DynamicDialogConfig<{ indexName: string }>);
 
     protected readonly store = inject(DotAiStore);
 
-    protected readonly indexName = this.#config.data?.indexName ?? '';
+    /** Every index in the table, the cache pseudo-index included — it is removable like any other. */
+    protected readonly $indexOptions = computed(() =>
+        this.store.indexes().map((index) => index.name)
+    );
 
+    protected readonly $indexName = signal(this.store.indexes()[0]?.name ?? '');
     protected readonly $query = signal('');
     protected readonly $submitting = signal(false);
 
@@ -48,7 +65,9 @@ export class DotAiIndexRemoveContentComponent {
             : null;
     });
 
-    protected readonly $canSubmit = computed(() => !!this.$query().trim() && !this.$submitting());
+    protected readonly $canSubmit = computed(
+        () => !!this.$indexName() && !!this.$query().trim() && !this.$submitting()
+    );
 
     constructor() {
         effect(() => {
@@ -82,7 +101,7 @@ export class DotAiIndexRemoveContentComponent {
 
         this.$submitting.set(true);
         this.store.removeFromIndex({
-            indexName: this.indexName,
+            indexName: this.$indexName(),
             query: this.$query().trim()
         });
     }
diff --git a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
index 541aafb9f0d1..10e8468749f8 100644
--- a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
+++ b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
@@ -8718,10 +8718,11 @@ dotai.embeddings.rebuild.failed=Could not rebuild the embeddings store. {1}
 dotai.embeddings.toast.success=Done
 dotai.embeddings.toast.warn=Nothing changed
 dotai.embeddings.toast.error=Failed
-dotai.embeddings.row.actions=Actions for this index
-dotai.embeddings.remove-content=Remove content…
-dotai.embeddings.remove-content.header=Remove content from "{0}"
-dotai.embeddings.remove-content.explainer=This removes the embeddings for the content your query matches from "{0}". The content itself is not deleted. The query runs against your content as it is now, not against what is in the index, so content that has changed and no longer matches is left behind, and archived or deleted content cannot be reached this way.
+dotai.embeddings.remove-content.action=Remove content
+dotai.embeddings.remove-content.header=Remove content from an index
+dotai.embeddings.remove-content.index=Index
+dotai.embeddings.remove-content.index.placeholder=Select an index
+dotai.embeddings.remove-content.explainer=This removes the embeddings for the content your query matches from the index you pick. The content itself is not deleted. The query runs against your content as it is now, not against what is in the index, so content that has changed and no longer matches is left behind, and archived or deleted content cannot be reached this way.
 dotai.embeddings.remove-content.query=Content query
 dotai.embeddings.remove-content.query.hint=Lucene query selecting the content to remove. Unlike building, this is not limited to live content.
 dotai.embeddings.remove-content.submit=Remove content

From f5d39b09ac4e321b6e35cb8b18bcff62978a1722 Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 15:22:08 -0600
Subject: [PATCH 08/11] fix(dotai): correct the index-operation defects found
 in review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Six findings from a review pass over the notice and seed machinery.

**A deleted index came back as a ghost row.** Nothing cleared a build seed when
its index was deleted, so `withPendingIndexes` put the index straight back in
the table as a zeroed BUILDING row for the rest of the two-minute grace period —
offered in the retrieval picker, and eligible to become `settingsIndexName`, so
Search and Chat could point at an index that no longer existed. Rebuild DB had
the same hole. `forgetIndexBuildSeeds` is called by both.

**A reopened dialog closed on the previous submission's outcome.** Both store
methods are rxMethods on the shell-scoped store, so they outlive the dialog that
started them: abandon a slow build, reopen, submit another, and `exhaustMap`
dropped the second request while the first one's success closed the dialog and
reported an index the user never asked for. Dialogs now match the notice against
the index they themselves submitted, and the operator is `concatMap` so a second
submit is neither dropped nor cancels the first. Double-submit is already
prevented by the dialog disabling its own button.

**A failure shown inline was toasted again on close.** Suppressed notices were
not marked as reported, so dismissing the dialog re-ran the effect and toasted
the error the user had just read. The comment claiming the teardown hook dropped
it described behaviour that did not exist.

**The build dialog's effect did not filter by operation**, so any other
operation's result cleared its spinner mid-build — the remove dialog filtered
correctly. Both now share `watchIndexOperation`; writing this twice is what let
them drift.

**Opening a dialog discarded an unreported outcome.** `dismissIndexNotice` on
open threw away a delete that had just failed. With dialogs filtering by their
own index, a stale notice cannot reach them anyway, so the call is gone — and
with it the now-unused store method.

**Remove content preselected a target the user never chose** — `indexes()[0]`,
which is alphabetically first and often `cache`. It starts empty.

Also: the toast message keys are an explicit `Record` rather than interpolated
at call time. Assembled keys are invisible to a grep, so a copy audit reports
them as orphaned, and an undefined combination renders its own key to the user.

`CompletionsResource.isInheritedConfig` is extracted and unit tested — the
"nothing configured anywhere" branch it exists for had no coverage.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../with-ai-embeddings.feature.spec.ts        | 25 ++++++
 .../features/with-ai-embeddings.feature.ts    | 28 ++++---
 .../features/with-ai-indexes.feature.spec.ts  | 31 ++++++++
 .../store/features/with-ai-indexes.feature.ts | 25 ++++++
 .../dot-ai-embeddings.component.spec.ts       | 56 +++++++++++---
 .../dot-ai-embeddings.component.ts            | 73 ++++++++++++++----
 .../dot-ai-index-create.component.ts          | 62 ++++-----------
 ...-ai-index-remove-content.component.spec.ts | 57 +++++++++++---
 .../dot-ai-index-remove-content.component.ts  | 53 ++++---------
 .../lib/utils/dot-ai-index-dialog.utils.ts    | 71 +++++++++++++++++
 .../dotcms/ai/rest/CompletionsResource.java   | 40 ++++++----
 .../ai/rest/CompletionsResourceTest.java      | 76 +++++++++++++++++++
 12 files changed, 446 insertions(+), 151 deletions(-)
 create mode 100644 core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
 create mode 100644 dotCMS/src/test/java/com/dotcms/ai/rest/CompletionsResourceTest.java

diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
index 3ed99340ac82..0c16a8f49f0f 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
@@ -185,6 +185,19 @@ describe('withAiEmbeddings', () => {
     });
 
     describe('deleteIndex (FR-034)', () => {
+        it('should end any build outstanding for the index it deletes', () => {
+            // A surviving seed put the deleted index straight back in the table as a zeroed
+            // BUILDING row, for the rest of the two-minute grace period.
+            service.getIndexes = vi.fn().mockReturnValue(of([]));
+            service.deleteIndex = vi.fn().mockReturnValue(of(4));
+            store.markIndexBuilding('blogs');
+
+            store.deleteIndex('blogs');
+
+            expect(store.indexBuildSeeds()).toEqual({});
+            expect(store.indexes().map((row) => row.name)).not.toContain('blogs');
+        });
+
         it('should let concurrent deletions of different indexes both complete', () => {
             const first = new Subject<number>();
             const second = new Subject<number>();
@@ -206,6 +219,18 @@ describe('withAiEmbeddings', () => {
     });
 
     describe('rebuildEmbeddingsDb', () => {
+        it('should end every outstanding build, since every index went with the store', () => {
+            service.getIndexes = vi.fn().mockReturnValue(of([]));
+            service.rebuildEmbeddingsDb = vi.fn().mockReturnValue(of(true));
+            store.markIndexBuilding('blogs');
+            store.markIndexBuilding('other');
+
+            store.rebuildEmbeddingsDb();
+
+            expect(store.indexBuildSeeds()).toEqual({});
+            expect(store.indexes()).toEqual([]);
+        });
+
         it('should rebuild and refresh', () => {
             service.rebuildEmbeddingsDb = vi.fn().mockReturnValue(of(true));
 
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
index 6f4086b84049..1fb81c4390e2 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
@@ -5,7 +5,7 @@ import { EMPTY, pipe } from 'rxjs';
 import { HttpErrorResponse } from '@angular/common/http';
 import { computed, inject, Signal } from '@angular/core';
 
-import { catchError, exhaustMap, mergeMap, tap } from 'rxjs/operators';
+import { catchError, concatMap, mergeMap, tap } from 'rxjs/operators';
 
 import { DotAiEmbeddingsService } from '@dotcms/data-access';
 import { DotAiEmbeddingsBuildForm, DotAiIndex } from '@dotcms/dotcms-models';
@@ -28,8 +28,12 @@ import {
  * then said nothing at all.
  *
  * The `rxMethod` operator per action is load-bearing:
- * - `exhaustMap` for build, rebuild and delete-from-index — each is one submit of one form, so
- *   a double click must not double-fire (FR-035)
+ * - `concatMap` for build and remove — these are submitted from a dialog that can be abandoned
+ *   mid-flight and reopened, so a second submit must neither be dropped (`exhaustMap`, which
+ *   left the new dialog spinning on a request that was never sent) nor cancel the first
+ *   (`switchMap`, which would abandon a build the server has already started). Double-submit
+ *   is prevented in the dialog, which disables its own button while a request is outstanding
+ *   (FR-035)
  * - `mergeMap` for `deleteIndex`, because that one is per row — deleting A must not cancel the
  *   delete of B (FR-034)
  */
@@ -41,6 +45,7 @@ export function withAiEmbeddings() {
             methods: {
                 loadIndexes: () => void;
                 markIndexBuilding: (indexName: string) => void;
+                forgetIndexBuildSeeds: (indexName?: string) => void;
             };
         }>(),
         withComputed((store) => ({
@@ -105,15 +110,10 @@ export function withAiEmbeddings() {
                     patchState(store, { indexFilter });
                 },
 
-                dismissIndexNotice(): void {
-                    patchState(store, { indexNotice: null });
-                },
-
                 buildIndex: rxMethod<DotAiEmbeddingsBuildForm>(
                     pipe(
                         tap(() => patchState(store, { indexNotice: null })),
-                        // exhaustMap: a double submit must not build twice.
-                        exhaustMap((form) =>
+                        concatMap((form) =>
                             embeddingsService.buildIndex(form).pipe(
                                 tap((result) => {
                                     // A query that matches nothing still answers 200, and the
@@ -162,7 +162,7 @@ export function withAiEmbeddings() {
                 removeFromIndex: rxMethod<{ indexName: string; query: string }>(
                     pipe(
                         tap(() => patchState(store, { indexNotice: null })),
-                        exhaustMap(({ indexName, query }) =>
+                        concatMap(({ indexName, query }) =>
                             embeddingsService.deleteFromIndex(indexName, query).pipe(
                                 tap((deleted) => {
                                     // The server answers 200 with `deleted: 0` when the query
@@ -195,6 +195,10 @@ export function withAiEmbeddings() {
                                         indexName,
                                         detail: `${deleted}`
                                     });
+                                    // The index is gone, so any build outstanding for it is
+                                    // too — a surviving seed would put it straight back in
+                                    // the table as a zeroed BUILDING row.
+                                    store.forgetIndexBuildSeeds(indexName);
                                     store.loadIndexes();
                                 }),
                                 catchError((error: HttpErrorResponse) =>
@@ -207,7 +211,7 @@ export function withAiEmbeddings() {
 
                 rebuildEmbeddingsDb: rxMethod<void>(
                     pipe(
-                        exhaustMap(() =>
+                        concatMap(() =>
                             embeddingsService.rebuildEmbeddingsDb().pipe(
                                 tap(() => {
                                     notify({
@@ -215,6 +219,8 @@ export function withAiEmbeddings() {
                                         outcome: 'ok',
                                         indexName: ''
                                     });
+                                    // Every index went with the store, and so does every seed.
+                                    store.forgetIndexBuildSeeds();
                                     store.loadIndexes();
                                 }),
                                 catchError((error: HttpErrorResponse) =>
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
index 7149cedd9426..028ff3aaa4ce 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
@@ -205,6 +205,37 @@ describe('withAiIndexes', () => {
             }
         });
 
+        it('should forget a seed when its index is deleted, so no ghost row returns', () => {
+            // The seed outlived the index: `withPendingIndexes` put the deleted index straight
+            // back in the table as a zeroed BUILDING row, offered in the retrieval picker and
+            // eligible to become settingsIndexName, for the rest of the grace period.
+            stubIndexes([index({ name: 'blogs', fragments: 10 })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+
+            store.forgetIndexBuildSeeds('blogs');
+            stubIndexes([]);
+            store.loadIndexes();
+
+            expect(store.indexes()).toEqual([]);
+            expect(store.indexStatuses()).toEqual({});
+            expect(store.indexBuildSeeds()).toEqual({});
+        });
+
+        it('should forget every seed when the whole store is rebuilt', () => {
+            stubIndexes([index({ name: 'blogs' }), index({ name: 'other' })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+            store.markIndexBuilding('other');
+
+            store.forgetIndexBuildSeeds();
+            stubIndexes([]);
+            store.loadIndexes();
+
+            expect(store.indexes()).toEqual([]);
+            expect(store.indexBuildSeeds()).toEqual({});
+        });
+
         it('should stop waiting on a build that never materialises', () => {
             // Without an expiry the seed would keep the badge up and the poll running for the
             // life of the page.
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
index 9aeb3f08c8d4..76f56c567248 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
@@ -193,6 +193,31 @@ export function withAiIndexes() {
                  * "a build just started here", so the first poll does not have to infer it
                  * from a delta that has not appeared yet.
                  */
+                /**
+                 * Drops build seeds, by name or all of them.
+                 *
+                 * Deleting an index, or rebuilding the store, ends any build outstanding for
+                 * it. Without this the seed outlives the index it was for and
+                 * `withPendingIndexes` puts the deleted index straight back in the table as a
+                 * zeroed BUILDING row — offered in the retrieval picker, and eligible to
+                 * become `settingsIndexName`, for the rest of the grace period.
+                 */
+                forgetIndexBuildSeeds(indexName?: string): void {
+                    if (!indexName) {
+                        patchState(store, { indexBuildSeeds: {} });
+
+                        return;
+                    }
+
+                    patchState(store, {
+                        indexBuildSeeds: Object.fromEntries(
+                            Object.entries(store.indexBuildSeeds()).filter(
+                                ([name]) => name !== indexName
+                            )
+                        )
+                    });
+                },
+
                 markIndexBuilding(indexName: string): void {
                     patchState(store, {
                         indexBuildSeeds: { ...store.indexBuildSeeds(), [indexName]: Date.now() },
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
index 61a51384c839..76f9febeef8d 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
@@ -7,6 +7,8 @@ import {
 import { Subject } from 'rxjs';
 import { Mock, MockInstance, vi } from 'vitest';
 
+import { signal } from '@angular/core';
+
 import { ConfirmationService, MessageService } from 'primeng/api';
 import { DialogService } from 'primeng/dynamicdialog';
 
@@ -15,7 +17,7 @@ import { DotAiIndex } from '@dotcms/dotcms-models';
 
 import DotAiEmbeddingsComponent from './dot-ai-embeddings.component';
 
-import { DOT_AI_INDEX_OPERATION } from '../../models/dot-ai-portlet.models';
+import { DOT_AI_INDEX_OPERATION, DotAiIndexNotice } from '../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../store/dot-ai.store';
 
 const index = (overrides: Partial<DotAiIndex> = {}): DotAiIndex => ({
@@ -44,7 +46,9 @@ describe('DotAiEmbeddingsComponent', () => {
         isConfigured: vi.fn().mockReturnValue(true),
         setIndexFilter: vi.fn(),
         buildIndex: vi.fn(),
-        indexNotice: vi.fn().mockReturnValue(null),
+        // A real signal, not a mock fn: the component reads this inside an `effect`, which
+        // only re-runs for tracked dependencies.
+        indexNotice: signal<DotAiIndexNotice | null>(null),
         dismissIndexNotice: vi.fn(),
         removeFromIndex: vi.fn(),
         deleteIndex: vi.fn(),
@@ -76,7 +80,7 @@ describe('DotAiEmbeddingsComponent', () => {
         storeMock.filteredIndexes.mockReturnValue([index()]);
         onClose = new Subject();
         onDialogDestroy = new Subject();
-        storeMock.indexNotice.mockReturnValue(null);
+        storeMock.indexNotice.set(null);
         spectator = createComponent();
         dialogService = spectator.inject(DialogService, true);
         (dialogService.open as Mock).mockReturnValue({ onClose, onDestroy: onDialogDestroy });
@@ -157,19 +161,29 @@ describe('DotAiEmbeddingsComponent', () => {
             );
         });
 
-        it('should clear a previous outcome so the dialog opens clean', () => {
-            // The dialog reads the same notice signal; a stale one would greet the next build
-            // with the last one's error.
+        it('should not discard an outcome that has not been reported yet', () => {
+            // Opening a dialog used to clear the notice unconditionally, so a delete that had
+            // failed a moment earlier was thrown away before anything announced it — the exact
+            // silence this change exists to remove. The dialogs filter by the index they
+            // themselves submitted, so a stale notice cannot greet them anyway.
+            storeMock.indexNotice.set({
+                operation: DOT_AI_INDEX_OPERATION.DELETE_INDEX,
+                outcome: 'failed',
+                indexName: 'blogs'
+            });
+            spectator = createComponent();
+            toastSpy = vi.spyOn(spectator.inject(MessageService, true), 'add');
+
             clickButton('dotai-embeddings-new-index');
 
-            expect(storeMock.dismissIndexNotice).toHaveBeenCalled();
+            expect(storeMock.dismissIndexNotice).not.toHaveBeenCalled();
         });
 
         it('should stay quiet about an outcome the dialog is there to render', () => {
             // Otherwise the failure appears twice — once in the form holding the query, once
             // as a toast over a modal, which is the report nobody could act on.
             clickButton('dotai-embeddings-new-index');
-            storeMock.indexNotice.mockReturnValue({
+            storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.BUILD,
                 outcome: 'failed',
                 indexName: 'blogs',
@@ -186,7 +200,7 @@ describe('DotAiEmbeddingsComponent', () => {
             // it. It used to render the success only, so a failure disappeared.
             clickButton('dotai-embeddings-new-index');
             onDialogDestroy.next(undefined);
-            storeMock.indexNotice.mockReturnValue({
+            storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.BUILD,
                 outcome: 'failed',
                 indexName: 'blogs',
@@ -197,12 +211,30 @@ describe('DotAiEmbeddingsComponent', () => {
             expect(toastSpy).toHaveBeenCalledWith(expect.objectContaining({ severity: 'error' }));
         });
 
+        it('should not toast a failure the dialog already showed inline', () => {
+            // Suppressed while the dialog is up, and marked reported all the same — otherwise
+            // closing the dialog toasts the error the user has just read and dismissed.
+            clickButton('dotai-embeddings-new-index');
+            storeMock.indexNotice.set({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                outcome: 'failed',
+                indexName: 'blogs',
+                detail: 'Cannot parse query'
+            });
+            spectator.detectChanges();
+
+            onDialogDestroy.next(undefined);
+            spectator.detectChanges();
+
+            expect(toastSpy).not.toHaveBeenCalled();
+        });
+
         it('should hand back only when the dialog is really gone, not when it starts closing', () => {
             // `close()` fires onClose and only then plays the leave animation, so the dialog is
             // still up and still owns what the user has to act on.
             clickButton('dotai-embeddings-new-index');
             onClose.next(undefined);
-            storeMock.indexNotice.mockReturnValue({
+            storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.BUILD,
                 outcome: 'failed',
                 indexName: 'blogs'
@@ -281,10 +313,10 @@ describe('DotAiEmbeddingsComponent', () => {
             );
         });
 
-        it('should clear a previous outcome so the dialog opens clean', () => {
+        it('should not discard an unreported outcome when it opens', () => {
             clickButton('dotai-embeddings-remove-content');
 
-            expect(storeMock.dismissIndexNotice).toHaveBeenCalled();
+            expect(storeMock.dismissIndexNotice).not.toHaveBeenCalled();
         });
 
         it('should be unavailable when there is no index to remove from', () => {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index d748a7ed80e1..3cd585fa99c4 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -23,7 +23,11 @@ import {
 import { DotAiIndexCreateComponent } from './dot-ai-index-create/dot-ai-index-create.component';
 import { DotAiIndexRemoveContentComponent } from './dot-ai-index-remove-content/dot-ai-index-remove-content.component';
 
-import { DOT_AI_INDEX_OPERATION, DotAiIndexNotice } from '../../models/dot-ai-portlet.models';
+import {
+    DOT_AI_INDEX_OPERATION,
+    DotAiIndexNotice,
+    DotAiIndexOperation
+} from '../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../store/dot-ai.store';
 import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
 
@@ -38,6 +42,47 @@ import { toEmptyStateConfig } from '../../utils/dot-ai-empty-state.utils';
  * itself and the theme defines no `p-button-primary` to ask for — `p-button-secondary` exists
  * there, `p-button-primary` does not. Setting one would resolve to nothing.
  */
+/**
+ * The message key per operation and outcome.
+ *
+ * Spelled out rather than assembled from the operation name at call time: interpolated keys
+ * are invisible to a grep, so a copy audit reports them as orphaned and a cleanup deletes
+ * them, and a combination nobody defined renders its own key to the user instead of failing.
+ * `Record` makes TypeScript require every one.
+ */
+const NOTICE_MESSAGE_KEYS: Record<
+    DotAiIndexOperation,
+    Record<DotAiIndexNotice['outcome'], string>
+> = {
+    [DOT_AI_INDEX_OPERATION.BUILD]: {
+        ok: 'dotai.embeddings.build.ok',
+        empty: 'dotai.embeddings.build.empty',
+        failed: 'dotai.embeddings.build.failed'
+    },
+    [DOT_AI_INDEX_OPERATION.REMOVE_CONTENT]: {
+        ok: 'dotai.embeddings.remove-content.ok',
+        empty: 'dotai.embeddings.remove-content.empty',
+        failed: 'dotai.embeddings.remove-content.failed'
+    },
+    [DOT_AI_INDEX_OPERATION.DELETE_INDEX]: {
+        ok: 'dotai.embeddings.delete.ok',
+        empty: 'dotai.embeddings.delete.ok',
+        failed: 'dotai.embeddings.delete.failed'
+    },
+    [DOT_AI_INDEX_OPERATION.REBUILD_DB]: {
+        ok: 'dotai.embeddings.rebuild.ok',
+        empty: 'dotai.embeddings.rebuild.ok',
+        failed: 'dotai.embeddings.rebuild.failed'
+    }
+} as const;
+
+/** Toast severity per outcome, and the summary key that goes with it. */
+const NOTICE_SEVERITY: Record<DotAiIndexNotice['outcome'], 'success' | 'warn' | 'error'> = {
+    ok: 'success',
+    empty: 'warn',
+    failed: 'error'
+} as const;
+
 const CONFIRM_BUTTONS = {
     rejectButtonStyleClass: 'p-button-outlined'
 } as const;
@@ -99,6 +144,10 @@ export default class DotAiEmbeddingsComponent {
             }
 
             if (dialogOpen && notice.outcome !== 'ok') {
+                // The dialog is showing it inline. Marked as reported all the same, so closing
+                // the dialog does not then toast the error the user has just read and dismissed.
+                this.#toasted = notice;
+
                 return;
             }
 
@@ -147,7 +196,6 @@ export default class DotAiEmbeddingsComponent {
      * reporting.
      */
     protected openCreateDialog(): void {
-        this.store.dismissIndexNotice();
         this.#dialogOpen.set(true);
 
         // `onDestroy`, not `onClose`: `close()` fires `onClose` immediately and only then
@@ -169,7 +217,6 @@ export default class DotAiEmbeddingsComponent {
     }
 
     protected openRemoveContentDialog(): void {
-        this.store.dismissIndexNotice();
         this.#dialogOpen.set(true);
 
         this.#dialogService
@@ -193,24 +240,18 @@ export default class DotAiEmbeddingsComponent {
         detail: string;
         life: number;
     } {
-        const severity =
-            notice.outcome === 'ok' ? 'success' : notice.outcome === 'empty' ? 'warn' : 'error';
-
-        const key = `dotai.embeddings.${
-            {
-                [DOT_AI_INDEX_OPERATION.BUILD]: 'build',
-                [DOT_AI_INDEX_OPERATION.REMOVE_CONTENT]: 'remove-content',
-                [DOT_AI_INDEX_OPERATION.DELETE_INDEX]: 'delete',
-                [DOT_AI_INDEX_OPERATION.REBUILD_DB]: 'rebuild'
-            }[notice.operation]
-        }.${notice.outcome}`;
+        const severity = NOTICE_SEVERITY[notice.outcome];
 
         return {
             severity,
             summary: this.#messageService.get(`dotai.embeddings.toast.${severity}`),
             // Every notice key takes the same two, in the same order: the index, then the
-            // count or the server's reason. Anything else and a generic mapper cannot exist.
-            detail: this.#messageService.get(key, notice.indexName, notice.detail ?? ''),
+            // count or the server's reason. Anything else and one mapper cannot serve them all.
+            detail: this.#messageService.get(
+                NOTICE_MESSAGE_KEYS[notice.operation][notice.outcome],
+                notice.indexName,
+                notice.detail ?? ''
+            ),
             life: severity === 'success' ? 4000 : 8000
         };
     }
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
index 75f56e46df49..30427405068b 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
@@ -1,4 +1,4 @@
-import { Component, computed, DestroyRef, effect, inject, signal, untracked } from '@angular/core';
+import { Component, computed, inject, signal } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { ButtonModule } from 'primeng/button';
@@ -11,6 +11,7 @@ import { DotMessagePipe } from '@dotcms/ui';
 
 import { DOT_AI_INDEX_OPERATION } from '../../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../../store/dot-ai.store';
+import { watchIndexOperation } from '../../../utils/dot-ai-index-dialog.utils';
 
 /**
  * The server stores whatever it is given — `bad name with spaces` is accepted verbatim, and
@@ -51,57 +52,22 @@ export class DotAiIndexCreateComponent {
     protected readonly store = inject(DotAiStore);
 
     /**
-     * A build is outstanding. Local rather than store state: it is this dialog's submit button
-     * that it disables, and nothing outside this component ever reads it.
+     * Settles and closes on this dialog's own build, and nothing else. Shared with the remove
+     * dialog because the two had already drifted apart once.
      */
-    protected readonly $submitting = signal(false);
+    readonly #operation = watchIndexOperation(DOT_AI_INDEX_OPERATION.BUILD, {
+        notice: this.store.indexNotice,
+        close: () => this.#dialogRef.close()
+    });
+
+    protected readonly $submitting = this.#operation.$submitting;
+    protected readonly $notice = this.#operation.$notice;
 
     protected readonly $indexName = signal('');
     protected readonly $query = signal('');
     protected readonly $fields = signal('');
     protected readonly $velocityTemplate = signal('');
 
-    /**
-     * The build outcome, while it is this dialog's to show.
-     *
-     * `built` is absent by construction — the effect below closes on it — so what is left is
-     * exactly the two outcomes the user has to act on: a query that matched nothing, and a
-     * query the server rejected.
-     */
-    protected readonly $notice = computed(() => {
-        const notice = this.store.indexNotice();
-
-        return notice?.operation === DOT_AI_INDEX_OPERATION.BUILD && notice.outcome !== 'ok'
-            ? notice
-            : null;
-    });
-
-    constructor() {
-        // A finished build is the only thing that dismisses this dialog; anything else is an
-        // outcome the form still has to show. The success message is left standing on the tab
-        // behind, next to the row it just created.
-        effect(() => {
-            const notice = this.store.indexNotice();
-
-            if (!notice) {
-                return;
-            }
-
-            untracked(() => {
-                this.$submitting.set(false);
-
-                if (notice.operation === DOT_AI_INDEX_OPERATION.BUILD && notice.outcome === 'ok') {
-                    this.#dialogRef.close();
-                }
-            });
-        });
-
-        // Nothing is cleared on teardown any more. A build abandoned with Escape or the
-        // header X while still in flight used to fail into silence; the tab now toasts
-        // whatever this dialog was not around to render, so the notice has to survive it.
-        inject(DestroyRef).onDestroy(() => this.$submitting.set(false));
-    }
-
     /** Empty until the field has been touched, so the form does not scold you on open. */
     protected readonly $nameError = computed<string | null>(() => {
         const name = this.$indexName().trim();
@@ -134,9 +100,11 @@ export class DotAiIndexCreateComponent {
             return;
         }
 
-        this.$submitting.set(true);
+        const indexName = this.$indexName().trim();
+
+        this.#operation.submitted(indexName);
         this.store.buildIndex({
-            indexName: this.$indexName().trim(),
+            indexName,
             query: this.$query().trim(),
             // Both only shape what gets embedded, so they are omitted rather than sent blank.
             ...(this.$fields().trim() ? { fields: this.$fields().trim() } : {}),
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
index 39dd57af3e50..7bbbdd708c7d 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
@@ -24,7 +24,6 @@ describe('DotAiIndexRemoveContentComponent', () => {
         indexes: ReturnType<typeof signal<DotAiIndex[]>>;
         indexNotice: ReturnType<typeof signal<DotAiIndexNotice | null>>;
         removeFromIndex: ReturnType<typeof vi.fn>;
-        dismissIndexNotice: ReturnType<typeof vi.fn>;
     };
 
     const createComponent = createComponentFactory({
@@ -49,8 +48,7 @@ describe('DotAiIndexRemoveContentComponent', () => {
         store = {
             indexes: signal<DotAiIndex[]>([index('blogs'), index('product')]),
             indexNotice: signal<DotAiIndexNotice | null>(null),
-            removeFromIndex: vi.fn(),
-            dismissIndexNotice: vi.fn()
+            removeFromIndex: vi.fn()
         };
 
         spectator = createComponent({ providers: [{ provide: DotAiStore, useValue: store }] });
@@ -71,13 +69,25 @@ describe('DotAiIndexRemoveContentComponent', () => {
         spectator.detectChanges();
     };
 
-    const notice = (outcome: DotAiIndexNotice['outcome'], detail?: string): DotAiIndexNotice => ({
+    const notice = (
+        outcome: DotAiIndexNotice['outcome'],
+        detail?: string,
+        indexName = 'blogs'
+    ): DotAiIndexNotice => ({
         operation: DOT_AI_INDEX_OPERATION.REMOVE_CONTENT,
         outcome,
-        indexName: 'blogs',
+        indexName,
         detail
     });
 
+    /** Picks an index, since nothing is preselected for a destructive action. */
+    const pickIndex = (name: string) => {
+        (
+            spectator.component as unknown as { $indexName: { set: (v: string) => void } }
+        ).$indexName.set(name);
+        spectator.detectChanges();
+    };
+
     it('should offer the real indexes rather than a free-text name', () => {
         // As a free-text field on the old delete mode, a typo removed nothing and a near-miss
         // hit a different index, both silently.
@@ -94,28 +104,32 @@ describe('DotAiIndexRemoveContentComponent', () => {
         );
     });
 
-    it('should default to the first index so the form is usable straight away', () => {
+    it('should preselect nothing, so the target is always a choice', () => {
+        // indexes() is a TreeMap from the server, so a default would silently be whichever
+        // index sorts first — often `cache`. This removes embeddings; it has to be picked.
         fillQuery('+contentType:Blog');
 
-        clickButton('dotai-index-remove-submit');
-
-        expect(store.removeFromIndex).toHaveBeenCalledWith(
-            expect.objectContaining({ indexName: 'blogs' })
-        );
+        expect(
+            spectator.query(byTestId('dotai-index-remove-submit'))?.querySelector('button')
+                ?.disabled
+        ).toBe(true);
     });
 
-    it('should keep submit disabled until a query is given', () => {
+    it('should keep submit disabled until both an index and a query are given', () => {
         const submit = () =>
             spectator.query(byTestId('dotai-index-remove-submit'))?.querySelector('button');
 
         expect(submit()?.disabled).toBe(true);
 
         fillQuery('+contentType:Blog');
+        expect(submit()?.disabled).toBe(true);
 
+        pickIndex('blogs');
         expect(submit()?.disabled).toBe(false);
     });
 
     it('should remove through the store rather than resolving the dialog', () => {
+        pickIndex('blogs');
         fillQuery('  +contentType:Blog  ');
 
         clickButton('dotai-index-remove-submit');
@@ -129,6 +143,7 @@ describe('DotAiIndexRemoveContentComponent', () => {
 
     it('should keep a query that matched nothing on screen to be corrected', () => {
         // The server answers 200 with `deleted: 0`, which would otherwise read as a success.
+        pickIndex('blogs');
         fillQuery('+contentType:NoSuchType');
         clickButton('dotai-index-remove-submit');
 
@@ -143,6 +158,7 @@ describe('DotAiIndexRemoveContentComponent', () => {
     });
 
     it('should show a rejected query inline', () => {
+        pickIndex('blogs');
         fillQuery('+++[');
         clickButton('dotai-index-remove-submit');
 
@@ -154,6 +170,7 @@ describe('DotAiIndexRemoveContentComponent', () => {
     });
 
     it('should close itself once something was actually removed', () => {
+        pickIndex('blogs');
         fillQuery('+contentType:Blog');
         clickButton('dotai-index-remove-submit');
 
@@ -165,6 +182,7 @@ describe('DotAiIndexRemoveContentComponent', () => {
 
     it('should ignore an outcome belonging to another operation', () => {
         // One notice channel serves all four operations, so each dialog has to read only its own.
+        pickIndex('blogs');
         fillQuery('+contentType:Blog');
         clickButton('dotai-index-remove-submit');
 
@@ -180,6 +198,7 @@ describe('DotAiIndexRemoveContentComponent', () => {
     });
 
     it('should block a second submit while a removal is outstanding', () => {
+        pickIndex('blogs');
         fillQuery('+contentType:Blog');
         clickButton('dotai-index-remove-submit');
         spectator.detectChanges();
@@ -190,4 +209,18 @@ describe('DotAiIndexRemoveContentComponent', () => {
         ).toBe(true);
         expect(store.removeFromIndex).toHaveBeenCalledTimes(1);
     });
+
+    it('should ignore an outcome for an index it did not submit', () => {
+        // Abandon a slow removal, reopen, submit another: both rxMethods live on the
+        // shell-scoped store and outlive the dialog that started them, so without matching the
+        // index this dialog would close on the first one's success and report the wrong index.
+        pickIndex('product');
+        fillQuery('+contentType:Blog');
+        clickButton('dotai-index-remove-submit');
+
+        store.indexNotice.set(notice('ok', '3', 'blogs'));
+        spectator.detectChanges();
+
+        expect(dialogRef.close).not.toHaveBeenCalled();
+    });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
index d7e5c86fa1e9..fced2af9923e 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
@@ -1,4 +1,4 @@
-import { Component, computed, DestroyRef, effect, inject, signal, untracked } from '@angular/core';
+import { Component, computed, inject, signal } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { ButtonModule } from 'primeng/button';
@@ -11,6 +11,7 @@ import { DotMessagePipe } from '@dotcms/ui';
 
 import { DOT_AI_INDEX_OPERATION } from '../../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../../store/dot-ai.store';
+import { watchIndexOperation } from '../../../utils/dot-ai-index-dialog.utils';
 
 /**
  * Removes the embeddings for content matching a query, from one index.
@@ -51,55 +52,33 @@ export class DotAiIndexRemoveContentComponent {
         this.store.indexes().map((index) => index.name)
     );
 
-    protected readonly $indexName = signal(this.store.indexes()[0]?.name ?? '');
+    /**
+     * Nothing is preselected. This removes embeddings, so the target has to be a choice — and
+     * `indexes()` is a TreeMap from the server, so a default would silently be whichever index
+     * sorts first, often `cache`.
+     */
+    protected readonly $indexName = signal('');
     protected readonly $query = signal('');
-    protected readonly $submitting = signal(false);
 
-    /** This dialog's own outcomes, and only the ones it can do something about. */
-    protected readonly $notice = computed(() => {
-        const notice = this.store.indexNotice();
-
-        return notice?.operation === DOT_AI_INDEX_OPERATION.REMOVE_CONTENT &&
-            notice.outcome !== 'ok'
-            ? notice
-            : null;
+    /** Settles and closes on this dialog's own removal, and nothing else. */
+    readonly #operation = watchIndexOperation(DOT_AI_INDEX_OPERATION.REMOVE_CONTENT, {
+        notice: this.store.indexNotice,
+        close: () => this.#dialogRef.close()
     });
 
+    protected readonly $submitting = this.#operation.$submitting;
+    protected readonly $notice = this.#operation.$notice;
+
     protected readonly $canSubmit = computed(
         () => !!this.$indexName() && !!this.$query().trim() && !this.$submitting()
     );
 
-    constructor() {
-        effect(() => {
-            const notice = this.store.indexNotice();
-
-            if (notice?.operation !== DOT_AI_INDEX_OPERATION.REMOVE_CONTENT) {
-                return;
-            }
-
-            untracked(() => {
-                this.$submitting.set(false);
-
-                // Only an actual removal closes this. "Nothing matched" leaves the query on
-                // screen to be corrected, which is the whole reason the dialog owns the submit.
-                if (notice.outcome === 'ok') {
-                    this.#dialogRef.close();
-                }
-            });
-        });
-
-        // The tab reports whatever is still unrendered when this goes, so nothing is cleared
-        // here — see DotAiEmbeddingsComponent. Kept to drop a notice the tab has no business
-        // repeating once the user has already read it inline and dismissed the dialog.
-        inject(DestroyRef).onDestroy(() => this.$submitting.set(false));
-    }
-
     protected submit(): void {
         if (!this.$canSubmit()) {
             return;
         }
 
-        this.$submitting.set(true);
+        this.#operation.submitted(this.$indexName());
         this.store.removeFromIndex({
             indexName: this.$indexName(),
             query: this.$query().trim()
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
new file mode 100644
index 000000000000..e76531e96c95
--- /dev/null
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
@@ -0,0 +1,71 @@
+import { computed, effect, Signal, signal, untracked, WritableSignal } from '@angular/core';
+
+import { DotAiIndexNotice, DotAiIndexOperation } from '../models/dot-ai-portlet.models';
+
+export interface DotAiIndexOperationDialog {
+    /** A request this dialog submitted is outstanding. */
+    readonly $submitting: Signal<boolean>;
+    /** The outcome of *this dialog's* request, while it is still this dialog's to show. */
+    readonly $notice: Signal<DotAiIndexNotice | null>;
+    /** Call as the request goes out, with the index it is for. */
+    readonly submitted: (indexName: string) => void;
+}
+
+/**
+ * The half of an index dialog that watches for its own outcome.
+ *
+ * Both dialogs need identically subtle behaviour — settle on my outcome, close on my success,
+ * stay open on anything I can still correct — and writing it twice is what let them drift:
+ * one filtered by operation and the other did not, so any operation's result cleared the
+ * build dialog's spinner mid-build.
+ *
+ * Matching on `indexName` as well as operation is what makes "my own" mean anything. Both
+ * store methods are `rxMethod`s on the shell-scoped store, so they outlive the dialog that
+ * started them: abandon a slow build and open the dialog again, and without this the second
+ * dialog closes on the first one's success and reports an index the user never asked for.
+ */
+export function watchIndexOperation(
+    operation: DotAiIndexOperation,
+    deps: { notice: Signal<DotAiIndexNotice | null>; close: () => void }
+): DotAiIndexOperationDialog {
+    const $submitting = signal(false);
+    const $target: WritableSignal<string | null> = signal(null);
+
+    const $own = computed(() => {
+        const notice = deps.notice();
+
+        return notice?.operation === operation && notice.indexName === $target() ? notice : null;
+    });
+
+    effect(() => {
+        const notice = $own();
+
+        if (!notice) {
+            return;
+        }
+
+        untracked(() => {
+            $submitting.set(false);
+
+            // Only a real success dismisses the dialog. Everything else — a query that matched
+            // nothing, a query the server rejected — is a correction to a field still on
+            // screen, which is the whole reason the dialog owns its submit.
+            if (notice.outcome === 'ok') {
+                deps.close();
+            }
+        });
+    });
+
+    return {
+        $submitting,
+        $notice: computed(() => {
+            const notice = $own();
+
+            return notice && notice.outcome !== 'ok' ? notice : null;
+        }),
+        submitted: (indexName: string) => {
+            $target.set(indexName);
+            $submitting.set(true);
+        }
+    };
+}
diff --git a/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java b/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
index 3684090df9f8..a4e286e52850 100644
--- a/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
+++ b/dotCMS/src/main/java/com/dotcms/ai/rest/CompletionsResource.java
@@ -194,25 +194,12 @@ public final Response getConfig(@Context final HttpServletRequest request,
 
         final Map<String, Object> map = new HashMap<>();
         final String providerConfig = appConfig.getProviderConfig();
-        final boolean configured = StringUtils.isNotBlank(providerConfig);
-
-        // The site the configuration is being read for, and whether it actually came from that
-        // site. ConfigService falls back to the System Host's secrets when the site has none of
-        // its own, so the two hostnames differing is what "inherited" means here. Reported as
-        // separate fields rather than one concatenated English string so the client can label
-        // and translate it.
-        //
-        // Gated on there being a configuration at all: ConfigService reports the System Host as
-        // the resolved host whenever the site has no secrets of its own, whether or not the
-        // System Host had any either. Without this, an instance where nothing is configured
-        // anywhere claims to have inherited settings it never found.
         final String requestedHost = host.getHostname();
+
         map.put(AiKeys.CONFIG_HOST, requestedHost);
-        map.put(
-                AiKeys.CONFIG_HOST_INHERITED,
-                configured && !requestedHost.equalsIgnoreCase(appConfig.getHost()));
+        map.put(AiKeys.CONFIG_HOST_INHERITED, isInheritedConfig(requestedHost, appConfig));
 
-        if (configured) {
+        if (StringUtils.isNotBlank(providerConfig)) {
             map.put(AppKeys.PROVIDER_CONFIG.key, redactCredentials(providerConfig));
         }
 
@@ -225,6 +212,27 @@ public final Response getConfig(@Context final HttpServletRequest request,
         return Response.ok(map).build();
     }
 
+    /**
+     * Whether the configuration being reported came from the System Host rather than from the
+     * site it was asked for.
+     *
+     * {@link ConfigService#config(Host)} falls back to the System Host's secrets when a site
+     * has none of its own, keeping only the hostname it ended up using — so the two hostnames
+     * differing is what "inherited" means here.
+     *
+     * Gated on there being a configuration at all, because that same fallback reports the
+     * System Host whether or not the System Host had any secrets either. Without the gate, an
+     * instance with nothing configured anywhere claims to have inherited settings it never
+     * found.
+     *
+     * Reported as its own field rather than concatenated into the hostname so the client can
+     * label and translate it.
+     */
+    static boolean isInheritedConfig(final String requestedHost, final AppConfig appConfig) {
+        return StringUtils.isNotBlank(appConfig.getProviderConfig())
+                && !requestedHost.equalsIgnoreCase(appConfig.getHost());
+    }
+
     @PUT
     @JSONP
     @Path("/config")
diff --git a/dotCMS/src/test/java/com/dotcms/ai/rest/CompletionsResourceTest.java b/dotCMS/src/test/java/com/dotcms/ai/rest/CompletionsResourceTest.java
new file mode 100644
index 000000000000..1f8690f6de4a
--- /dev/null
+++ b/dotCMS/src/test/java/com/dotcms/ai/rest/CompletionsResourceTest.java
@@ -0,0 +1,76 @@
+package com.dotcms.ai.rest;
+
+import com.dotcms.ai.app.AppConfig;
+import com.dotcms.ai.app.AppKeys;
+import com.dotcms.security.apps.Secret;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Unit tests for {@link CompletionsResource#isInheritedConfig(String, AppConfig)}.
+ *
+ * The rule is small but it decides a label the user reads on the Config Values screen, and the
+ * "nothing configured anywhere" case is the one it exists to get right.
+ */
+public class CompletionsResourceTest {
+
+    private static final String SITE = "demo.dotcms.com";
+    private static final String SYSTEM_HOST = "System Host";
+    private static final String PROVIDER_CONFIG = "{\"chat\":{\"provider\":\"openai\"}}";
+
+    /**
+     * The site has its own configuration, so nothing was inherited.
+     */
+    @Test
+    public void test_isInheritedConfig_ownConfig() {
+        assertFalse(CompletionsResource.isInheritedConfig(SITE, appConfig(SITE, PROVIDER_CONFIG)));
+    }
+
+    /**
+     * ConfigService fell back to the System Host's secrets and found some, which is what
+     * "inherited" means.
+     */
+    @Test
+    public void test_isInheritedConfig_fellBackToSystemHost() {
+        assertTrue(CompletionsResource.isInheritedConfig(
+                SITE, appConfig(SYSTEM_HOST, PROVIDER_CONFIG)));
+    }
+
+    /**
+     * Nothing is configured anywhere. ConfigService still reports the System Host as the
+     * resolved host, so without the blank check this claimed to have inherited settings it
+     * never found.
+     */
+    @Test
+    public void test_isInheritedConfig_nothingConfiguredAnywhere() {
+        assertFalse(CompletionsResource.isInheritedConfig(SITE, appConfig(SYSTEM_HOST, null)));
+        assertFalse(CompletionsResource.isInheritedConfig(SITE, appConfig(SYSTEM_HOST, "  ")));
+    }
+
+    /**
+     * Hostnames are compared without regard to case, as hostnames are.
+     */
+    @Test
+    public void test_isInheritedConfig_hostnameCaseIsNotAChange() {
+        assertFalse(CompletionsResource.isInheritedConfig(
+                "DEMO.dotCMS.com", appConfig(SITE, PROVIDER_CONFIG)));
+    }
+
+    private static AppConfig appConfig(final String host, final String providerConfigJson) {
+        final Map<String, Secret> secrets = new HashMap<>();
+        if (providerConfigJson != null) {
+            final Secret secret = mock(Secret.class);
+            when(secret.getString()).thenReturn(providerConfigJson);
+            secrets.put(AppKeys.PROVIDER_CONFIG.key, secret);
+        }
+
+        return new AppConfig(host, secrets);
+    }
+}

From 79f7a7b2e674c997b2f8133292402f68642e733e Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 15:39:46 -0600
Subject: [PATCH 09/11] fix(dotai): hold the index dialogs open until the
 response is back
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The answer comes back into the form — a rejected query belongs in the field
that produced it — so the dialog has to still be there to receive it. All three
ways out are closed while a request is outstanding: the header X is hidden,
Cancel is disabled, and Escape declines.

Escape needed taking over. PrimeNG binds its own document listener once, when
the dialog opens, and never rereads `closeOnEscape` — so mutating the config
mid-flight does nothing. Both dialogs now open with `closeOnEscape: false` and
the shared helper owns the key, which keeps Escape closing the dialog as the
portlet guide requires while letting it stand down mid-request.

Known gap, deliberately not papered over: `closable` is a plain property the
dialog host reads in a template binding, so hiding the X lands immediately (it
happens in a click handler) but restoring it waits for that host's next
change-detection pass — the unlock runs inside an effect, already part of the
pass in progress. The X therefore returns on the user's next interaction rather
than instantly. It only happens on a failed or empty outcome, which is exactly
when they are about to type in the field again, and Cancel and Escape are live
throughout. A `setTimeout` was tried and changed nothing, so it is not left
behind for the look of it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../dot-ai-embeddings.component.spec.ts       |  8 ++-
 .../dot-ai-embeddings.component.ts            | 10 +++-
 .../dot-ai-index-create.component.html        |  1 +
 .../dot-ai-index-create.component.spec.ts     | 53 ++++++++++++++++-
 .../dot-ai-index-create.component.ts          |  6 +-
 ...dot-ai-index-remove-content.component.html |  1 +
 ...-ai-index-remove-content.component.spec.ts | 41 ++++++++++++-
 .../dot-ai-index-remove-content.component.ts  |  6 +-
 .../lib/utils/dot-ai-index-dialog.utils.ts    | 59 ++++++++++++++++++-
 9 files changed, 171 insertions(+), 14 deletions(-)

diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
index 76f9febeef8d..2b0efcaa3f1e 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
@@ -156,7 +156,9 @@ describe('DotAiEmbeddingsComponent', () => {
                 expect.objectContaining({
                     width: '700px',
                     closable: true,
-                    closeOnEscape: true
+                    // The dialog handles Escape itself, so that it can decline while a
+                    // request is in flight — PrimeNG binds its own listener once at open.
+                    closeOnEscape: false
                 })
             );
         });
@@ -308,7 +310,9 @@ describe('DotAiEmbeddingsComponent', () => {
                 expect.objectContaining({
                     width: '700px',
                     closable: true,
-                    closeOnEscape: true
+                    // The dialog handles Escape itself, so that it can decline while a
+                    // request is in flight — PrimeNG binds its own listener once at open.
+                    closeOnEscape: false
                 })
             );
         });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index 3cd585fa99c4..6c0e31553bad 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -209,7 +209,10 @@ export default class DotAiEmbeddingsComponent {
                 header: this.#messageService.get('dotai.index.create.header'),
                 width: '700px',
                 closable: true,
-                closeOnEscape: true,
+                // Escape is handled by the dialog itself: PrimeNG binds its own listener once
+                // at open time and never rereads the flag, so it cannot be told to stand down
+                // while a request is in flight. See `watchIndexOperation`.
+                closeOnEscape: false,
                 draggable: false
             })
             .onDestroy.pipe(take(1))
@@ -224,7 +227,10 @@ export default class DotAiEmbeddingsComponent {
                 header: this.#messageService.get('dotai.embeddings.remove-content.header'),
                 width: '700px',
                 closable: true,
-                closeOnEscape: true,
+                // Escape is handled by the dialog itself: PrimeNG binds its own listener once
+                // at open time and never rereads the flag, so it cannot be told to stand down
+                // while a request is in flight. See `watchIndexOperation`.
+                closeOnEscape: false,
                 draggable: false
             })
             // Same reason as the build dialog: `onDestroy` fires once, on every close path,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
index 3acbe8c332b1..9c497708c80c 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.html
@@ -86,6 +86,7 @@
             severity="secondary"
             [text]="true"
             [label]="'dotai.index.create.cancel' | dm"
+            [disabled]="$submitting()"
             (onClick)="cancel()"
             data-testid="dotai-index-create-cancel" />
         <p-button
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
index 7148b928f1e5..fe3ca562215d 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
@@ -7,7 +7,7 @@ import {
 
 import { signal } from '@angular/core';
 
-import { DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
 import { DotMessageService } from '@dotcms/data-access';
 import { DotAiIndex } from '@dotcms/dotcms-models';
@@ -17,6 +17,8 @@ import { DotAiIndexCreateComponent } from './dot-ai-index-create.component';
 import { DOT_AI_INDEX_OPERATION, DotAiIndexNotice } from '../../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../../store/dot-ai.store';
 
+const dialogConfig = { closable: true, closeOnEscape: true };
+
 describe('DotAiIndexCreateComponent', () => {
     let spectator: Spectator<DotAiIndexCreateComponent>;
     let dialogRef: DynamicDialogRef;
@@ -29,11 +31,18 @@ describe('DotAiIndexCreateComponent', () => {
 
     const createComponent = createComponentFactory({
         component: DotAiIndexCreateComponent,
-        providers: [mockProvider(DynamicDialogRef), mockProvider(DotMessageService)],
+        providers: [
+            mockProvider(DynamicDialogRef),
+            mockProvider(DotMessageService),
+            { provide: DynamicDialogConfig, useValue: dialogConfig }
+        ],
         shallow: true
     });
 
     beforeEach(() => {
+        dialogConfig.closable = true;
+        dialogConfig.closeOnEscape = true;
+
         store = {
             indexes: signal<DotAiIndex[]>([
                 {
@@ -60,6 +69,10 @@ describe('DotAiIndexCreateComponent', () => {
         spectator.typeInElement(value, spectator.query(byTestId(testId)) as HTMLElement);
 
     /** PrimeNG puts its click handler on the inner <button>, not the p-button host. */
+    /** PrimeNG binds its Escape listener once at open, so the dialog owns the key itself. */
+    const pressEscape = () =>
+        document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }));
+
     const clickButton = (testId: string) =>
         spectator.click(
             spectator.query(byTestId(testId))?.querySelector('button') as HTMLButtonElement
@@ -244,4 +257,40 @@ describe('DotAiIndexCreateComponent', () => {
         expect(template.getAttribute('placeholder')).toBeTruthy();
         expect(spectator.query('label[for="dotai-index-template"]')).toBeTruthy();
     });
+
+    it('should not be dismissible while a build is outstanding', () => {
+        // The answer is coming back into this form, so it has to still be here to receive it.
+        // PrimeNG drives its header X and Escape straight off the dialog config.
+        fillValidForm();
+        clickButton('dotai-index-create-submit');
+
+        expect(dialogConfig.closable).toBe(false);
+        pressEscape();
+        expect(dialogRef.close).not.toHaveBeenCalled();
+        expect(
+            spectator.query(byTestId('dotai-index-create-cancel'))?.querySelector('button')
+                ?.disabled
+        ).toBe(true);
+    });
+
+    it('should be dismissible again once the build settles', () => {
+        fillValidForm();
+        clickButton('dotai-index-create-submit');
+
+        store.indexNotice.set({
+            operation: DOT_AI_INDEX_OPERATION.BUILD,
+            outcome: 'failed',
+            indexName: 'blogs',
+            detail: 'bad query'
+        });
+        spectator.detectChanges();
+
+        expect(dialogConfig.closable).toBe(true);
+        pressEscape();
+        expect(dialogRef.close).toHaveBeenCalled();
+        expect(
+            spectator.query(byTestId('dotai-index-create-cancel'))?.querySelector('button')
+                ?.disabled
+        ).toBe(false);
+    });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
index 30427405068b..85cd0e0d5c41 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
@@ -2,7 +2,7 @@ import { Component, computed, inject, signal } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { ButtonModule } from 'primeng/button';
-import { DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 import { InputTextModule } from 'primeng/inputtext';
 import { MessageModule } from 'primeng/message';
 import { TextareaModule } from 'primeng/textarea';
@@ -48,6 +48,7 @@ const INDEX_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 })
 export class DotAiIndexCreateComponent {
     readonly #dialogRef = inject(DynamicDialogRef);
+    readonly #dialogConfig = inject(DynamicDialogConfig);
 
     protected readonly store = inject(DotAiStore);
 
@@ -57,7 +58,8 @@ export class DotAiIndexCreateComponent {
      */
     readonly #operation = watchIndexOperation(DOT_AI_INDEX_OPERATION.BUILD, {
         notice: this.store.indexNotice,
-        close: () => this.#dialogRef.close()
+        close: () => this.#dialogRef.close(),
+        config: this.#dialogConfig
     });
 
     protected readonly $submitting = this.#operation.$submitting;
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
index 97b02592f60f..861971381324 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.html
@@ -60,6 +60,7 @@
             severity="secondary"
             [text]="true"
             [label]="'dotai.index.create.cancel' | dm"
+            [disabled]="$submitting()"
             (onClick)="cancel()"
             data-testid="dotai-index-remove-cancel" />
         <p-button
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
index 7bbbdd708c7d..3ec421f67380 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
@@ -7,7 +7,7 @@ import {
 
 import { signal } from '@angular/core';
 
-import { DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 
 import { DotMessageService } from '@dotcms/data-access';
 import { DotAiIndex } from '@dotcms/dotcms-models';
@@ -17,6 +17,8 @@ import { DotAiIndexRemoveContentComponent } from './dot-ai-index-remove-content.
 import { DOT_AI_INDEX_OPERATION, DotAiIndexNotice } from '../../../models/dot-ai-portlet.models';
 import { DotAiStore } from '../../../store/dot-ai.store';
 
+const dialogConfig = { closable: true, closeOnEscape: true };
+
 describe('DotAiIndexRemoveContentComponent', () => {
     let spectator: Spectator<DotAiIndexRemoveContentComponent>;
     let dialogRef: DynamicDialogRef;
@@ -30,12 +32,16 @@ describe('DotAiIndexRemoveContentComponent', () => {
         component: DotAiIndexRemoveContentComponent,
         providers: [
             mockProvider(DynamicDialogRef),
-            mockProvider(DotMessageService, { get: (key: string) => key })
+            mockProvider(DotMessageService, { get: (key: string) => key }),
+            { provide: DynamicDialogConfig, useValue: dialogConfig }
         ],
         shallow: true
     });
 
     beforeEach(() => {
+        dialogConfig.closable = true;
+        dialogConfig.closeOnEscape = true;
+
         const index = (name: string): DotAiIndex => ({
             name,
             fragments: 1,
@@ -56,6 +62,10 @@ describe('DotAiIndexRemoveContentComponent', () => {
     });
 
     /** PrimeNG puts its click handler on the inner <button>, not the p-button host. */
+    /** PrimeNG binds its Escape listener once at open, so the dialog owns the key itself. */
+    const pressEscape = () =>
+        document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' }));
+
     const clickButton = (testId: string) =>
         spectator.click(
             spectator.query(byTestId(testId))?.querySelector('button') as HTMLButtonElement
@@ -223,4 +233,31 @@ describe('DotAiIndexRemoveContentComponent', () => {
 
         expect(dialogRef.close).not.toHaveBeenCalled();
     });
+
+    it('should not be dismissible while a removal is outstanding', () => {
+        pickIndex('blogs');
+        fillQuery('+contentType:Blog');
+        clickButton('dotai-index-remove-submit');
+
+        expect(dialogConfig.closable).toBe(false);
+        pressEscape();
+        expect(dialogRef.close).not.toHaveBeenCalled();
+        expect(
+            spectator.query(byTestId('dotai-index-remove-cancel'))?.querySelector('button')
+                ?.disabled
+        ).toBe(true);
+    });
+
+    it('should be dismissible again once the removal settles', () => {
+        pickIndex('blogs');
+        fillQuery('+contentType:Blog');
+        clickButton('dotai-index-remove-submit');
+
+        store.indexNotice.set(notice('empty', '0'));
+        spectator.detectChanges();
+
+        expect(dialogConfig.closable).toBe(true);
+        pressEscape();
+        expect(dialogRef.close).toHaveBeenCalled();
+    });
 });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
index fced2af9923e..7e083d2ede3d 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
@@ -2,7 +2,7 @@ import { Component, computed, inject, signal } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { ButtonModule } from 'primeng/button';
-import { DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
 import { MessageModule } from 'primeng/message';
 import { SelectModule } from 'primeng/select';
 import { TextareaModule } from 'primeng/textarea';
@@ -44,6 +44,7 @@ import { watchIndexOperation } from '../../../utils/dot-ai-index-dialog.utils';
 })
 export class DotAiIndexRemoveContentComponent {
     readonly #dialogRef = inject(DynamicDialogRef);
+    readonly #dialogConfig = inject(DynamicDialogConfig);
 
     protected readonly store = inject(DotAiStore);
 
@@ -63,7 +64,8 @@ export class DotAiIndexRemoveContentComponent {
     /** Settles and closes on this dialog's own removal, and nothing else. */
     readonly #operation = watchIndexOperation(DOT_AI_INDEX_OPERATION.REMOVE_CONTENT, {
         notice: this.store.indexNotice,
-        close: () => this.#dialogRef.close()
+        close: () => this.#dialogRef.close(),
+        config: this.#dialogConfig
     });
 
     protected readonly $submitting = this.#operation.$submitting;
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
index e76531e96c95..2238e9d92b58 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
@@ -1,4 +1,16 @@
-import { computed, effect, Signal, signal, untracked, WritableSignal } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import {
+    computed,
+    DestroyRef,
+    effect,
+    inject,
+    Signal,
+    signal,
+    untracked,
+    WritableSignal
+} from '@angular/core';
+
+import { DynamicDialogConfig } from 'primeng/dynamicdialog';
 
 import { DotAiIndexNotice, DotAiIndexOperation } from '../models/dot-ai-portlet.models';
 
@@ -23,14 +35,55 @@ export interface DotAiIndexOperationDialog {
  * store methods are `rxMethod`s on the shell-scoped store, so they outlive the dialog that
  * started them: abandon a slow build and open the dialog again, and without this the second
  * dialog closes on the first one's success and reports an index the user never asked for.
+ *
+ * While a request is outstanding the dialog cannot be dismissed at all. The answer is coming
+ * back *into this form* — a rejected query belongs in the field that produced it — so letting
+ * it be closed first is what created the abandoned-mid-flight case in the first place.
+ *
+ * The header X is a live binding off `DynamicDialogConfig`, so hiding it is a matter of
+ * setting `closable`. Escape is not: PrimeNG binds a document listener **once**, when the
+ * dialog opens, and never rereads the flag — so both dialogs open with `closeOnEscape: false`
+ * and Escape is handled here instead. It still closes the dialog, as the portlet guide
+ * requires; it just declines to while the server is mid-answer.
  */
 export function watchIndexOperation(
     operation: DotAiIndexOperation,
-    deps: { notice: Signal<DotAiIndexNotice | null>; close: () => void }
+    deps: {
+        notice: Signal<DotAiIndexNotice | null>;
+        close: () => void;
+        config: DynamicDialogConfig;
+    }
 ): DotAiIndexOperationDialog {
     const $submitting = signal(false);
     const $target: WritableSignal<string | null> = signal(null);
 
+    /**
+     * Shows or hides PrimeNG's header X.
+     *
+     * `closable` is a plain property the dialog host reads in a template binding, so it lands
+     * on that host's next change-detection pass. Locking gets one for free — it runs from a
+     * click handler — but the unlock runs inside an effect, already part of the pass in
+     * progress, so the X comes back on the user's next interaction rather than instantly. A
+     * `setTimeout` was tried and changes nothing, so it is not carried here for the illusion.
+     *
+     * The gap is cosmetic and self-healing: it only occurs on a failed or empty outcome, which
+     * is exactly when the user is about to type in the field again, and Cancel and Escape are
+     * both live throughout.
+     */
+    const dismissable = (allowed: boolean) => {
+        deps.config.closable = allowed;
+    };
+
+    const documentRef = inject(DOCUMENT);
+    const onEscape = (event: KeyboardEvent) => {
+        if (event.key === 'Escape' && !$submitting()) {
+            deps.close();
+        }
+    };
+
+    documentRef.addEventListener('keydown', onEscape);
+    inject(DestroyRef).onDestroy(() => documentRef.removeEventListener('keydown', onEscape));
+
     const $own = computed(() => {
         const notice = deps.notice();
 
@@ -46,6 +99,7 @@ export function watchIndexOperation(
 
         untracked(() => {
             $submitting.set(false);
+            dismissable(true);
 
             // Only a real success dismisses the dialog. Everything else — a query that matched
             // nothing, a query the server rejected — is a correction to a field still on
@@ -66,6 +120,7 @@ export function watchIndexOperation(
         submitted: (indexName: string) => {
             $target.set(indexName);
             $submitting.set(true);
+            dismissable(false);
         }
     };
 }

From 80d6810e596058b3001e1104ba03e0a8f0204d57 Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Mon, 14 Sep 2026 15:58:26 -0600
Subject: [PATCH 10/11] fix(dotai): unlock the dialog on every failure, and
 stop swallowing outcomes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Second review pass, on the fixes from the first.

**A 403 left an unclosable modal.** `report` returned early on 403 without a
notice, and a dialog settles only on one — so with the new "cannot dismiss
while outstanding" rule, `$submitting` stayed true, the header X stayed hidden,
Cancel stayed disabled and Escape kept declining. Nothing but a page reload got
the user out. Every path notifies now, 403 included; the tab still enters its
forbidden state.

**Outcomes no dialog would render were suppressed anyway.** The tab decided
"this belongs to the dialog" from `#dialogOpen` alone, but a dialog renders
only outcomes matching the operation *and* index it submitted. A delete that
failed while the build dialog happened to be up was therefore suppressed by the
tab, ignored by the dialog, and never reported — the silence this whole change
set exists to remove. Ownership is now declared: the dialog claims
`(operation, indexName)` at submit and releases it on teardown, and the tab
reports everything else. Declaring at submit rather than at render keeps it
independent of which effect runs first. `#dialogOpen` and the tab's two
`onDestroy` subscriptions go with it.

**A deleted index could still be left standing.** `forgetIndexBuildSeeds`
dropped the seed but left the placeholder row for the next refresh to clear —
and `loadIndexes`' error branch leaves `indexes` untouched, so a failed refresh
left the deleted index there as a plausible READY row with zeroes. The row goes
with the seed now.

**Three tests could never fail.** They asserted `dismissIndexNotice` was not
called, on a method deleted in the same change — tautologies where the one at
"should not discard an outcome that has not been reported yet" was precisely
the test that should have caught the swallowing above. Rewritten against
observable behaviour; they fail without these fixes.

Also: `forgetIndexBuildSeeds('')` cleared every seed, and '' is a real index
name in this module (a store-wide rebuild reports it) — it checks `undefined`
now. The Escape handler bails on `defaultPrevented` so nested overlays close
themselves first, and unbinds at close rather than at teardown, which for
DynamicDialog runs after the leave animation.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../src/lib/models/dot-ai-portlet.models.ts   |  7 ++
 .../with-ai-embeddings.feature.spec.ts        | 21 ++++++
 .../features/with-ai-embeddings.feature.ts    | 22 +++++-
 .../features/with-ai-indexes.feature.spec.ts  | 24 +++++++
 .../store/features/with-ai-indexes.feature.ts | 13 +++-
 .../dot-ai-embeddings.component.spec.ts       | 64 ++++++++++++-----
 .../dot-ai-embeddings.component.ts            | 72 +++++++------------
 .../dot-ai-index-create.component.spec.ts     | 25 +++----
 .../dot-ai-index-create.component.ts          |  4 +-
 ...-ai-index-remove-content.component.spec.ts |  6 +-
 .../dot-ai-index-remove-content.component.ts  |  4 +-
 .../lib/utils/dot-ai-index-dialog.utils.ts    | 27 +++++--
 12 files changed, 199 insertions(+), 90 deletions(-)

diff --git a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
index 13b4de85f360..fb0930935212 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
@@ -173,6 +173,12 @@ export interface DotAiPortletState {
     // embeddings screen (client-side filters — the whole dataset arrives in one response)
     indexFilter: string;
     indexNotice: DotAiIndexNotice | null;
+    /**
+     * The operation and index whose outcome an open dialog will render itself.
+     *
+     * Declared at submit, not at render, so nothing depends on which effect runs first.
+     */
+    indexNoticeOwner: { operation: DotAiIndexOperation; indexName: string } | null;
 
     // image
     image: DotAiGeneratedImage | null;
@@ -247,6 +253,7 @@ export const DOT_AI_INITIAL_STATE: DotAiPortletState = {
 
     indexFilter: '',
     indexNotice: null,
+    indexNoticeOwner: null,
 
     image: null,
     imageGenerating: false,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
index 0c16a8f49f0f..893bb9351e04 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.spec.ts
@@ -218,6 +218,27 @@ describe('withAiEmbeddings', () => {
         });
     });
 
+    describe('a failure that settles nothing (FR-050)', () => {
+        it('should still notify on a 403, so a dialog waiting on it can settle', () => {
+            // The dialogs cannot be dismissed while their request is outstanding and settle
+            // only on a notice, so a branch that returns without one leaves a modal nobody can
+            // close but a page reload.
+            const error = new HttpErrorResponse({ status: 403 });
+            service.buildIndex = vi.fn().mockReturnValue(throwError(() => error));
+
+            store.buildIndex({ indexName: 'blogs', query: '+contentType:Blog' });
+
+            expect(store.indexesForbidden()).toBe(true);
+            expect(store.indexNotice()).toEqual(
+                expect.objectContaining({
+                    operation: DOT_AI_INDEX_OPERATION.BUILD,
+                    outcome: 'failed',
+                    indexName: 'blogs'
+                })
+            );
+        });
+    });
+
     describe('rebuildEmbeddingsDb', () => {
         it('should end every outstanding build, since every index went with the store', () => {
             service.getIndexes = vi.fn().mockReturnValue(of([]));
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
index 1fb81c4390e2..18a235618465 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-embeddings.feature.ts
@@ -94,10 +94,11 @@ export function withAiEmbeddings() {
                 indexName: string,
                 error: HttpErrorResponse
             ) => {
+                // Every path notifies, 403 included. A dialog cannot be dismissed while its
+                // request is outstanding, and it settles only on a notice — so a branch that
+                // returns without one leaves a modal nobody can close but a page reload.
                 if (error?.status === 403) {
                     patchState(store, { indexesForbidden: true });
-
-                    return EMPTY;
                 }
 
                 notify({ operation, outcome: 'failed', indexName, detail: extractReason(error) });
@@ -110,6 +111,23 @@ export function withAiEmbeddings() {
                     patchState(store, { indexFilter });
                 },
 
+                /**
+                 * Declares that an open dialog will render the outcome of this exact request.
+                 *
+                 * The tab reports everything else. Asking it to infer ownership from "is a
+                 * dialog open" was wrong: a dialog renders only outcomes matching its own
+                 * operation *and* index, so a delete that failed while the build dialog
+                 * happened to be up was suppressed by the tab, ignored by the dialog, and
+                 * never reported at all.
+                 */
+                claimIndexOutcome(owner: DotAiIndexNotice['operation'], indexName: string): void {
+                    patchState(store, { indexNoticeOwner: { operation: owner, indexName } });
+                },
+
+                releaseIndexOutcome(): void {
+                    patchState(store, { indexNoticeOwner: null });
+                },
+
                 buildIndex: rxMethod<DotAiEmbeddingsBuildForm>(
                     pipe(
                         tap(() => patchState(store, { indexNotice: null })),
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
index 028ff3aaa4ce..7dca09531695 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
@@ -222,6 +222,30 @@ describe('withAiIndexes', () => {
             expect(store.indexBuildSeeds()).toEqual({});
         });
 
+        it('should take the row with the seed, so a failed refresh leaves nothing behind', () => {
+            // loadIndexes' error branch leaves `indexes` untouched, so a row cleared only by
+            // the next successful refresh outlived the index it stood for.
+            stubIndexes([index({ name: 'blogs', fragments: 10 })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+
+            store.forgetIndexBuildSeeds('blogs');
+
+            expect(store.indexes().map((row) => row.name)).not.toContain('blogs');
+        });
+
+        it('should treat an empty name as a name, not as "all of them"', () => {
+            // '' is what a store-wide rebuild reports as its index name, so a falsy check here
+            // would quietly clear every seed.
+            stubIndexes([index({ name: 'blogs' })]);
+            store.loadIndexes();
+            store.markIndexBuilding('blogs');
+
+            store.forgetIndexBuildSeeds('');
+
+            expect(store.indexBuildSeeds()).toHaveProperty('blogs');
+        });
+
         it('should forget every seed when the whole store is rebuilt', () => {
             stubIndexes([index({ name: 'blogs' }), index({ name: 'other' })]);
             store.loadIndexes();
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
index 76f56c567248..8076ebe68dff 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
@@ -203,18 +203,25 @@ export function withAiIndexes() {
                  * become `settingsIndexName`, for the rest of the grace period.
                  */
                 forgetIndexBuildSeeds(indexName?: string): void {
-                    if (!indexName) {
-                        patchState(store, { indexBuildSeeds: {} });
+                    // `undefined`, not falsy: '' is a real value in this module — `report`
+                    // passes it as the index name for a store-wide rebuild — and it must not
+                    // be mistaken for "all of them".
+                    if (indexName === undefined) {
+                        patchState(store, { indexBuildSeeds: {}, indexes: [] });
 
                         return;
                     }
 
+                    // The row goes with the seed. `markIndexBuilding` writes both, and leaving
+                    // the row for the refresh to clear left a deleted index standing — as a
+                    // plausible-looking READY row with zeroes — whenever that refresh failed.
                     patchState(store, {
                         indexBuildSeeds: Object.fromEntries(
                             Object.entries(store.indexBuildSeeds()).filter(
                                 ([name]) => name !== indexName
                             )
-                        )
+                        ),
+                        indexes: store.indexes().filter((index) => index.name !== indexName)
                     });
                 },
 
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
index 2b0efcaa3f1e..189142076859 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.spec.ts
@@ -49,7 +49,7 @@ describe('DotAiEmbeddingsComponent', () => {
         // A real signal, not a mock fn: the component reads this inside an `effect`, which
         // only re-runs for tracked dependencies.
         indexNotice: signal<DotAiIndexNotice | null>(null),
-        dismissIndexNotice: vi.fn(),
+        indexNoticeOwner: signal<{ operation: string; indexName: string } | null>(null),
         removeFromIndex: vi.fn(),
         deleteIndex: vi.fn(),
         rebuildEmbeddingsDb: vi.fn()
@@ -81,6 +81,7 @@ describe('DotAiEmbeddingsComponent', () => {
         onClose = new Subject();
         onDialogDestroy = new Subject();
         storeMock.indexNotice.set(null);
+        storeMock.indexNoticeOwner.set(null);
         spectator = createComponent();
         dialogService = spectator.inject(DialogService, true);
         (dialogService.open as Mock).mockReturnValue({ onClose, onDestroy: onDialogDestroy });
@@ -163,28 +164,34 @@ describe('DotAiEmbeddingsComponent', () => {
             );
         });
 
-        it('should not discard an outcome that has not been reported yet', () => {
-            // Opening a dialog used to clear the notice unconditionally, so a delete that had
-            // failed a moment earlier was thrown away before anything announced it — the exact
-            // silence this change exists to remove. The dialogs filter by the index they
-            // themselves submitted, so a stale notice cannot greet them anyway.
+        it('should still report an outcome no open dialog owns', () => {
+            // A delete fails while the build dialog happens to be up. The dialog renders only
+            // outcomes for the request it submitted, so suppressing on "a dialog is open"
+            // alone left this reported by nobody at all.
+            clickButton('dotai-embeddings-new-index');
+            storeMock.indexNoticeOwner.set({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                indexName: 'other'
+            });
             storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.DELETE_INDEX,
                 outcome: 'failed',
-                indexName: 'blogs'
+                indexName: 'blogs',
+                detail: 'boom'
             });
-            spectator = createComponent();
-            toastSpy = vi.spyOn(spectator.inject(MessageService, true), 'add');
-
-            clickButton('dotai-embeddings-new-index');
+            spectator.detectChanges();
 
-            expect(storeMock.dismissIndexNotice).not.toHaveBeenCalled();
+            expect(toastSpy).toHaveBeenCalledWith(expect.objectContaining({ severity: 'error' }));
         });
 
         it('should stay quiet about an outcome the dialog is there to render', () => {
             // Otherwise the failure appears twice — once in the form holding the query, once
             // as a toast over a modal, which is the report nobody could act on.
             clickButton('dotai-embeddings-new-index');
+            storeMock.indexNoticeOwner.set({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                indexName: 'blogs'
+            });
             storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.BUILD,
                 outcome: 'failed',
@@ -201,7 +208,7 @@ describe('DotAiEmbeddingsComponent', () => {
             // after the dialog is destroyed, so this tab is the only thing left that can show
             // it. It used to render the success only, so a failure disappeared.
             clickButton('dotai-embeddings-new-index');
-            onDialogDestroy.next(undefined);
+            storeMock.indexNoticeOwner.set(null);
             storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.BUILD,
                 outcome: 'failed',
@@ -217,6 +224,10 @@ describe('DotAiEmbeddingsComponent', () => {
             // Suppressed while the dialog is up, and marked reported all the same — otherwise
             // closing the dialog toasts the error the user has just read and dismissed.
             clickButton('dotai-embeddings-new-index');
+            storeMock.indexNoticeOwner.set({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                indexName: 'blogs'
+            });
             storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.BUILD,
                 outcome: 'failed',
@@ -225,22 +236,27 @@ describe('DotAiEmbeddingsComponent', () => {
             });
             spectator.detectChanges();
 
-            onDialogDestroy.next(undefined);
+            storeMock.indexNoticeOwner.set(null);
             spectator.detectChanges();
 
             expect(toastSpy).not.toHaveBeenCalled();
         });
 
-        it('should hand back only when the dialog is really gone, not when it starts closing', () => {
+        it('should keep suppressing while the dialog is still closing', () => {
             // `close()` fires onClose and only then plays the leave animation, so the dialog is
-            // still up and still owns what the user has to act on.
+            // still up and still showing the outcome. Ownership is released in the dialog's own
+            // teardown, which runs after that — so this is about ownership, not the close event.
             clickButton('dotai-embeddings-new-index');
-            onClose.next(undefined);
+            storeMock.indexNoticeOwner.set({
+                operation: DOT_AI_INDEX_OPERATION.BUILD,
+                indexName: 'blogs'
+            });
             storeMock.indexNotice.set({
                 operation: DOT_AI_INDEX_OPERATION.BUILD,
                 outcome: 'failed',
                 indexName: 'blogs'
             });
+            onClose.next(undefined);
             spectator.detectChanges();
 
             expect(toastSpy).not.toHaveBeenCalled();
@@ -317,10 +333,20 @@ describe('DotAiEmbeddingsComponent', () => {
             );
         });
 
-        it('should not discard an unreported outcome when it opens', () => {
+        it('should report a removal outcome for an index no open dialog claimed', () => {
             clickButton('dotai-embeddings-remove-content');
+            storeMock.indexNoticeOwner.set({
+                operation: DOT_AI_INDEX_OPERATION.REMOVE_CONTENT,
+                indexName: 'other'
+            });
+            storeMock.indexNotice.set({
+                operation: DOT_AI_INDEX_OPERATION.REMOVE_CONTENT,
+                outcome: 'failed',
+                indexName: 'blogs'
+            });
+            spectator.detectChanges();
 
-            expect(storeMock.dismissIndexNotice).not.toHaveBeenCalled();
+            expect(toastSpy).toHaveBeenCalledWith(expect.objectContaining({ severity: 'error' }));
         });
 
         it('should be unavailable when there is no index to remove from', () => {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
index 6c0e31553bad..bab619e58bfa 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-embeddings.component.ts
@@ -1,4 +1,4 @@
-import { Component, computed, effect, inject, signal, untracked } from '@angular/core';
+import { Component, computed, effect, inject, untracked } from '@angular/core';
 
 import { ConfirmationService, MessageService } from 'primeng/api';
 import { ButtonModule } from 'primeng/button';
@@ -9,8 +9,6 @@ import { TagModule } from 'primeng/tag';
 import { ToastModule } from 'primeng/toast';
 import { ToolbarModule } from 'primeng/toolbar';
 
-import { take } from 'rxjs/operators';
-
 import { DotMessageService } from '@dotcms/data-access';
 import { DOT_AI_INDEX_STATUS, DotAiIndex } from '@dotcms/dotcms-models';
 import {
@@ -124,9 +122,6 @@ export default class DotAiEmbeddingsComponent {
 
     protected readonly statuses = DOT_AI_INDEX_STATUS;
 
-    /** Whether a dialog is up, and so is the one rendering what the user must act on. */
-    readonly #dialogOpen = signal(false);
-
     /** Identity guard: each operation makes a fresh notice, so this toasts each one once. */
     #toasted: DotAiIndexNotice | null = null;
 
@@ -137,13 +132,19 @@ export default class DotAiEmbeddingsComponent {
         // is what the rest of the admin does. Nothing renders a standing banner on the tab.
         effect(() => {
             const notice = this.store.indexNotice();
-            const dialogOpen = this.#dialogOpen();
+            const owner = this.store.indexNoticeOwner();
 
             if (!notice || notice === this.#toasted) {
                 return;
             }
 
-            if (dialogOpen && notice.outcome !== 'ok') {
+            // A dialog renders only outcomes for the request it submitted, so ownership has to
+            // match the operation *and* the index. Suppressing on "a dialog is open" alone
+            // swallowed, say, a delete that failed while the build dialog happened to be up.
+            const ownedByDialog =
+                owner?.operation === notice.operation && owner.indexName === notice.indexName;
+
+            if (ownedByDialog && notice.outcome !== 'ok') {
                 // The dialog is showing it inline. Marked as reported all the same, so closing
                 // the dialog does not then toast the error the user has just read and dismissed.
                 this.#toasted = notice;
@@ -196,47 +197,26 @@ export default class DotAiEmbeddingsComponent {
      * reporting.
      */
     protected openCreateDialog(): void {
-        this.#dialogOpen.set(true);
-
-        // `onDestroy`, not `onClose`: `close()` fires `onClose` immediately and only then
-        // plays the leave animation, so the dialog component — and the `DestroyRef` hook that
-        // clears an outcome it has already shown — lives on for the length of it. Handing over
-        // at `onClose` would render that outcome on the tab for those frames before the
-        // dialog's own teardown withdrew it. `onDestroy` fires once, on every close path
-        // (cancel, success, Escape, the header X), after the dialog has let go.
-        this.#dialogService
-            .open(DotAiIndexCreateComponent, {
-                header: this.#messageService.get('dotai.index.create.header'),
-                width: '700px',
-                closable: true,
-                // Escape is handled by the dialog itself: PrimeNG binds its own listener once
-                // at open time and never rereads the flag, so it cannot be told to stand down
-                // while a request is in flight. See `watchIndexOperation`.
-                closeOnEscape: false,
-                draggable: false
-            })
-            .onDestroy.pipe(take(1))
-            .subscribe(() => this.#dialogOpen.set(false));
+        this.#dialogService.open(DotAiIndexCreateComponent, {
+            header: this.#messageService.get('dotai.index.create.header'),
+            width: '700px',
+            closable: true,
+            // Escape is handled by the dialog itself: PrimeNG binds its own listener once
+            // at open time and never rereads the flag, so it cannot be told to stand down
+            // while a request is in flight. See `watchIndexOperation`.
+            closeOnEscape: false,
+            draggable: false
+        });
     }
 
     protected openRemoveContentDialog(): void {
-        this.#dialogOpen.set(true);
-
-        this.#dialogService
-            .open(DotAiIndexRemoveContentComponent, {
-                header: this.#messageService.get('dotai.embeddings.remove-content.header'),
-                width: '700px',
-                closable: true,
-                // Escape is handled by the dialog itself: PrimeNG binds its own listener once
-                // at open time and never rereads the flag, so it cannot be told to stand down
-                // while a request is in flight. See `watchIndexOperation`.
-                closeOnEscape: false,
-                draggable: false
-            })
-            // Same reason as the build dialog: `onDestroy` fires once, on every close path,
-            // after the dialog has let go — `onClose` fires before the leave animation.
-            .onDestroy.pipe(take(1))
-            .subscribe(() => this.#dialogOpen.set(false));
+        this.#dialogService.open(DotAiIndexRemoveContentComponent, {
+            header: this.#messageService.get('dotai.embeddings.remove-content.header'),
+            width: '700px',
+            closable: true,
+            closeOnEscape: false,
+            draggable: false
+        });
     }
 
     /** The one place an outcome becomes words. Severity follows the outcome, not the action. */
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
index fe3ca562215d..5011e22b697b 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.spec.ts
@@ -26,7 +26,8 @@ describe('DotAiIndexCreateComponent', () => {
         indexes: ReturnType<typeof signal<DotAiIndex[]>>;
         indexNotice: ReturnType<typeof signal<DotAiIndexNotice | null>>;
         buildIndex: ReturnType<typeof vi.fn>;
-        dismissIndexNotice: ReturnType<typeof vi.fn>;
+        claimIndexOutcome: ReturnType<typeof vi.fn>;
+        releaseIndexOutcome: ReturnType<typeof vi.fn>;
     };
 
     const createComponent = createComponentFactory({
@@ -56,7 +57,8 @@ describe('DotAiIndexCreateComponent', () => {
             ]),
             indexNotice: signal<DotAiIndexNotice | null>(null),
             buildIndex: vi.fn(),
-            dismissIndexNotice: vi.fn()
+            claimIndexOutcome: vi.fn(),
+            releaseIndexOutcome: vi.fn()
         };
 
         spectator = createComponent({
@@ -219,18 +221,17 @@ describe('DotAiIndexCreateComponent', () => {
         expect(dialogRef.close).toHaveBeenCalledWith();
     });
 
-    it('should leave an unshown outcome standing for the tab to report', () => {
-        // PrimeNG's own header X and Escape call DynamicDialogRef.close directly, so a build
-        // abandoned mid-flight used to fail into silence. The tab toasts whatever this dialog
-        // was not around to render, which means the notice has to survive its teardown.
-        store.indexNotice.set({
-            operation: DOT_AI_INDEX_OPERATION.BUILD,
-            outcome: 'failed',
-            indexName: 'blogs'
-        });
+    it('should claim its outcome at submit and release it on teardown', () => {
+        // The tab reports everything no open dialog claimed. Claiming at submit rather than at
+        // render is what keeps it independent of which effect runs first.
+        fillValidForm();
+        clickButton('dotai-index-create-submit');
+
+        expect(store.claimIndexOutcome).toHaveBeenCalledWith(DOT_AI_INDEX_OPERATION.BUILD, 'blogs');
+
         spectator.fixture.destroy();
 
-        expect(store.dismissIndexNotice).not.toHaveBeenCalled();
+        expect(store.releaseIndexOutcome).toHaveBeenCalled();
     });
 
     it('should not offer a delete mode any more', () => {
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
index 85cd0e0d5c41..7b0210ead239 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-create/dot-ai-index-create.component.ts
@@ -59,7 +59,9 @@ export class DotAiIndexCreateComponent {
     readonly #operation = watchIndexOperation(DOT_AI_INDEX_OPERATION.BUILD, {
         notice: this.store.indexNotice,
         close: () => this.#dialogRef.close(),
-        config: this.#dialogConfig
+        config: this.#dialogConfig,
+        claim: (operation, indexName) => this.store.claimIndexOutcome(operation, indexName),
+        release: () => this.store.releaseIndexOutcome()
     });
 
     protected readonly $submitting = this.#operation.$submitting;
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
index 3ec421f67380..3f85f11e213b 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.spec.ts
@@ -26,6 +26,8 @@ describe('DotAiIndexRemoveContentComponent', () => {
         indexes: ReturnType<typeof signal<DotAiIndex[]>>;
         indexNotice: ReturnType<typeof signal<DotAiIndexNotice | null>>;
         removeFromIndex: ReturnType<typeof vi.fn>;
+        claimIndexOutcome: ReturnType<typeof vi.fn>;
+        releaseIndexOutcome: ReturnType<typeof vi.fn>;
     };
 
     const createComponent = createComponentFactory({
@@ -54,7 +56,9 @@ describe('DotAiIndexRemoveContentComponent', () => {
         store = {
             indexes: signal<DotAiIndex[]>([index('blogs'), index('product')]),
             indexNotice: signal<DotAiIndexNotice | null>(null),
-            removeFromIndex: vi.fn()
+            removeFromIndex: vi.fn(),
+            claimIndexOutcome: vi.fn(),
+            releaseIndexOutcome: vi.fn()
         };
 
         spectator = createComponent({ providers: [{ provide: DotAiStore, useValue: store }] });
diff --git a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
index 7e083d2ede3d..1b29becdf5e3 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/tabs/dot-ai-embeddings/dot-ai-index-remove-content/dot-ai-index-remove-content.component.ts
@@ -65,7 +65,9 @@ export class DotAiIndexRemoveContentComponent {
     readonly #operation = watchIndexOperation(DOT_AI_INDEX_OPERATION.REMOVE_CONTENT, {
         notice: this.store.indexNotice,
         close: () => this.#dialogRef.close(),
-        config: this.#dialogConfig
+        config: this.#dialogConfig,
+        claim: (operation, indexName) => this.store.claimIndexOutcome(operation, indexName),
+        release: () => this.store.releaseIndexOutcome()
     });
 
     protected readonly $submitting = this.#operation.$submitting;
diff --git a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
index 2238e9d92b58..356d75c95a12 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/utils/dot-ai-index-dialog.utils.ts
@@ -52,6 +52,9 @@ export function watchIndexOperation(
         notice: Signal<DotAiIndexNotice | null>;
         close: () => void;
         config: DynamicDialogConfig;
+        /** Declares to the tab that this dialog will render the outcome itself. */
+        claim: (operation: DotAiIndexOperation, indexName: string) => void;
+        release: () => void;
     }
 ): DotAiIndexOperationDialog {
     const $submitting = signal(false);
@@ -75,14 +78,27 @@ export function watchIndexOperation(
     };
 
     const documentRef = inject(DOCUMENT);
-    const onEscape = (event: KeyboardEvent) => {
-        if (event.key === 'Escape' && !$submitting()) {
-            deps.close();
+    const unbindEscape = () => documentRef.removeEventListener('keydown', onEscape);
+
+    function onEscape(event: KeyboardEvent) {
+        // `defaultPrevented` leaves nested overlays — a select, a picker — to close themselves
+        // first. PrimeNG's own handler is gone (`closeOnEscape: false`), because it binds once
+        // at open and would not stand down mid-request.
+        if (event.key !== 'Escape' || event.defaultPrevented || $submitting()) {
+            return;
         }
-    };
+
+        // Unbound here rather than at teardown: DynamicDialog is destroyed only after its
+        // leave animation, and a live handler on a dialog already closing would close it twice.
+        unbindEscape();
+        deps.close();
+    }
 
     documentRef.addEventListener('keydown', onEscape);
-    inject(DestroyRef).onDestroy(() => documentRef.removeEventListener('keydown', onEscape));
+    inject(DestroyRef).onDestroy(() => {
+        unbindEscape();
+        deps.release();
+    });
 
     const $own = computed(() => {
         const notice = deps.notice();
@@ -121,6 +137,7 @@ export function watchIndexOperation(
             $target.set(indexName);
             $submitting.set(true);
             dismissable(false);
+            deps.claim(operation, indexName);
         }
     };
 }

From 51869fecfe45943740e154ae7a8c8a5666d84dbe Mon Sep 17 00:00:00 2001
From: Freddy Montes <freddymontes@gmail.com>
Date: Tue, 15 Sep 2026 12:36:16 -0600
Subject: [PATCH 11/11] fix(dotai): stop an index named after an
 Object.prototype member reading as Building
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`indexStatuses` decided BUILDING with `index.name in seeds`. The seed map comes
from `Object.fromEntries`, so `in` walks its prototype: an index named
`constructor`, `toString`, `valueOf` or `hasOwnProperty` read as seeded when it
was not, and then rendered Building forever — nothing clears a seed that never
existed. The create form's name pattern accepts all four and the backend stores
whatever it is given, so it is reachable rather than theoretical.

A regression from the commit that made `indexStatuses` a computed; the code it
replaced used `Set.has`, which has no prototype exposure.

Also corrects a doc reference to `BUILD_SEED_TTL_MS`, renamed to
`PENDING_SEED_TTL_MS` when its meaning narrowed to the pre-listing window.

Both raised by the review bot on #37541.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../src/lib/models/dot-ai-portlet.models.ts   |  2 +-
 .../features/with-ai-indexes.feature.spec.ts  | 23 +++++++++++++++++++
 .../store/features/with-ai-indexes.feature.ts | 20 +++++++++-------
 3 files changed, 36 insertions(+), 9 deletions(-)

diff --git a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
index fb0930935212..6e5ee2c10368 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/models/dot-ai-portlet.models.ts
@@ -143,7 +143,7 @@ export interface DotAiPortletState {
      * what lets the row show as Building in the meantime instead of not showing at all.
      *
      * The timestamp is the stop condition: a build that never materialises would otherwise poll
-     * for the lifetime of the page. See `BUILD_SEED_TTL_MS`.
+     * for the lifetime of the page. See `PENDING_SEED_TTL_MS`.
      */
     indexBuildSeeds: Record<string, number>;
     indexesForbidden: boolean;
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
index 7dca09531695..34fd3c19b65b 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.spec.ts
@@ -125,6 +125,29 @@ describe('withAiIndexes', () => {
         });
     });
 
+    it('should not call an index Building because its name is on Object.prototype', () => {
+        // The seed map comes from Object.fromEntries, so `in` walked its prototype: an index
+        // named constructor / toString / valueOf / hasOwnProperty read as seeded when it was
+        // not, and then rendered Building forever — nothing clears a seed that never existed.
+        // The create form's name pattern accepts all four.
+        stubIndexes([
+            index({ name: 'constructor' }),
+            index({ name: 'toString' }),
+            index({ name: 'valueOf' }),
+            index({ name: 'hasOwnProperty' })
+        ]);
+
+        store.loadIndexes();
+
+        expect(store.indexBuildSeeds()).toEqual({});
+        expect(Object.values(store.indexStatuses())).toEqual([
+            DOT_AI_INDEX_STATUS.READY,
+            DOT_AI_INDEX_STATUS.READY,
+            DOT_AI_INDEX_STATUS.READY,
+            DOT_AI_INDEX_STATUS.READY
+        ]);
+    });
+
     describe('an index the server has not caught up with', () => {
         // Embedding is asynchronous, so a freshly built index has nothing in dot_embeddings and
         // indexCount does not return it. Every assertion here is about the window in between,
diff --git a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
index 8076ebe68dff..95a872ab883c 100644
--- a/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
+++ b/core-web/libs/portlets/dot-ai/src/lib/store/features/with-ai-indexes.feature.ts
@@ -71,14 +71,18 @@ export function withAiIndexes() {
                 const seeds = store.indexBuildSeeds();
 
                 return Object.fromEntries(
-                    store
-                        .indexes()
-                        .map((index) => [
-                            index.name,
-                            index.name in seeds
-                                ? DOT_AI_INDEX_STATUS.BUILDING
-                                : DOT_AI_INDEX_STATUS.READY
-                        ])
+                    store.indexes().map((index) => [
+                        index.name,
+                        // `hasOwnProperty`, not `in`: the seed map comes from
+                        // `Object.fromEntries`, so `in` walks its prototype and an index
+                        // named `constructor`, `toString`, `valueOf` or `hasOwnProperty`
+                        // reads as seeded when it is not — then renders Building forever,
+                        // since nothing clears a seed that does not exist. The create
+                        // form's name pattern accepts all four.
+                        Object.prototype.hasOwnProperty.call(seeds, index.name)
+                            ? DOT_AI_INDEX_STATUS.BUILDING
+                            : DOT_AI_INDEX_STATUS.READY
+                    ])
                 );
             })
         })),